Merge branch 'master' into lp-surface-tilinglp-surface-tiling

This brings in the gallium-resources branch changes.  Things seem to be
working but there's probabaly bugs to be found.

Conflicts:

	src/gallium/drivers/llvmpipe/lp_rast.c
	src/gallium/drivers/llvmpipe/lp_scene.c
	src/gallium/drivers/llvmpipe/lp_texture.c
	src/gallium/drivers/llvmpipe/lp_texture.h

717 files changed, 46612 insertions, 29662 deletions

diff --git a/src/egl/drivers/dri2/egl_dri2.c b/src/egl/drivers/dri2/egl_dri2.c
index 15b3529cd29..8b6f78cdc9f 100644
--- a/src/egl/drivers/dri2/egl_dri2.c
+++ b/src/egl/drivers/dri2/egl_dri2.c
@@ -54,6 +54,8 @@
 struct dri2_egl_driver
 {
    _EGLDriver base;
+
+   void (*glFlush)(void);
 };
 
 struct dri2_egl_display
@@ -760,6 +762,7 @@ dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp,
    disp->Extensions.KHR_image_base = EGL_TRUE;
    disp->Extensions.KHR_image_pixmap = EGL_TRUE;
    disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
+   disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
 
    /* we're supporting EGL 1.4 */
    *major = 1;
@@ -873,6 +876,7 @@ static EGLBoolean
 dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
 		  _EGLSurface *rsurf, _EGLContext *ctx)
 {
+   struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    struct dri2_egl_surface *dri2_dsurf = dri2_egl_surface(dsurf);
    struct dri2_egl_surface *dri2_rsurf = dri2_egl_surface(rsurf);
@@ -884,6 +888,10 @@ dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
    if (!_eglBindContext(&ctx, &dsurf, &rsurf))
       return EGL_FALSE;
 
+   /* flush before context switch */
+   if (ctx && dri2_drv->glFlush)
+      dri2_drv->glFlush();
+
    ddraw = (dri2_dsurf) ? dri2_dsurf->dri_drawable : NULL;
    rdraw = (dri2_rsurf) ? dri2_rsurf->dri_drawable : NULL;
    cctx = (dri2_ctx) ? dri2_ctx->dri_context : NULL;
@@ -1011,10 +1019,18 @@ dri2_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
 static EGLBoolean
 dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
 {
+   struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
+   _EGLContext *ctx;
    xcb_dri2_copy_region_cookie_t cookie;
 
+   if (dri2_drv->glFlush) {
+      ctx = _eglGetCurrentContext();
+      if (ctx && ctx->DrawSurface == &dri2_surf->base)
+         dri2_drv->glFlush();
+   }
+
    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
 
 #if 0
@@ -1352,5 +1368,8 @@ _eglMain(const char *args)
    dri2_drv->base.Name = "DRI2";
    dri2_drv->base.Unload = dri2_unload;
 
+   dri2_drv->glFlush =
+      (void (*)(void)) dri2_get_proc_address(&dri2_drv->base, "glFlush");
+
    return &dri2_drv->base;
 }
diff --git a/src/egl/main/eglcontext.c b/src/egl/main/eglcontext.c
index 5e831aab332..d5a1e79a994 100644
--- a/src/egl/main/eglcontext.c
+++ b/src/egl/main/eglcontext.c
@@ -208,39 +208,56 @@ _eglQueryContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *c,
  * bound to;  when the context is NULL, the same surfaces are returned.
  */
 static void
-_eglBindContextToSurfaces(_EGLContext *ctx,
+_eglBindContextToSurfaces(_EGLContext *newCtx,
                           _EGLSurface **draw, _EGLSurface **read)
 {
    _EGLSurface *newDraw = *draw, *newRead = *read;
    _EGLContext *oldCtx;
 
+   /*
+    * The goal is to bind a newCtx to newDraw.  Since newDraw may already have
+    * a binding context (oldCtx), and newCtx may already be bound to another
+    * surface (oldDraw), the old bindings are broken first and the new one is
+    * created.
+    */
    oldCtx = newDraw->CurrentContext;
-   if (ctx != oldCtx) {
+   if (newCtx != oldCtx) {
       if (oldCtx) {
-         assert(*draw == oldCtx->DrawSurface);
+         assert(oldCtx->DrawSurface == newDraw);
          oldCtx->DrawSurface = NULL;
       }
-      if (ctx) {
-         *draw = ctx->DrawSurface;
-         ctx->DrawSurface = newDraw;
+
+      if (newCtx) {
+         _EGLSurface *oldDraw = newCtx->DrawSurface;
+         if (oldDraw)
+            oldDraw->CurrentContext = NULL;
+
+         newCtx->DrawSurface = newDraw;
+         *draw = oldDraw;
       }
 
-      newDraw->CurrentContext = ctx;
+      newDraw->CurrentContext = newCtx;
    }
 
+   /* likewise */
    if (newRead != newDraw)
       oldCtx = newRead->CurrentContext;
-   if (ctx != oldCtx) {
+   if (newCtx != oldCtx) {
       if (oldCtx) {
-         assert(*read == oldCtx->ReadSurface);
+         assert(oldCtx->ReadSurface == newRead);
          oldCtx->ReadSurface = NULL;
       }
-      if (ctx) {
-         *read = ctx->ReadSurface;
-         ctx->ReadSurface = newRead;
+
+      if (newCtx) {
+         _EGLSurface *oldRead = newCtx->ReadSurface;
+         if (oldRead)
+            oldRead->CurrentContext = NULL;
+
+         newCtx->ReadSurface = newRead;
+         *read = oldRead;
       }
 
-      newRead->CurrentContext = ctx;
+      newRead->CurrentContext = newCtx;
    }
 }
 
@@ -360,19 +377,13 @@ _eglBindContext(_EGLContext **ctx, _EGLSurface **draw, _EGLSurface **read)
 
    /* bind the new context */
    oldCtx = _eglBindContextToThread(newCtx, t);
-   *ctx = oldCtx;
+
    if (newCtx)
       _eglBindContextToSurfaces(newCtx, draw, read);
 
    /* unbind the old context from its binding surfaces */
    if (oldCtx && oldCtx != newCtx) {
-      /*
-       * If the new context replaces some old context, the new one should not
-       * be current before the replacement and it should not be bound to any
-       * surface.
-       */
-      if (newCtx)
-         assert(!*draw && !*read);
+      assert(!*draw && !*read);
 
       *draw = oldCtx->DrawSurface;
       *read = oldCtx->ReadSurface;
@@ -381,6 +392,9 @@ _eglBindContext(_EGLContext **ctx, _EGLSurface **draw, _EGLSurface **read)
       _eglBindContextToSurfaces(NULL, draw, read);
    }
 
+   *ctx = oldCtx;
+   /* draw and read have been updated in _eglBindContextToSurfaces */
+
    return EGL_TRUE;
 }
 
diff --git a/src/gallium/SConscript b/src/gallium/SConscript
index b8c04f72379..6c0e7a518d1 100644
--- a/src/gallium/SConscript
+++ b/src/gallium/SConscript
@@ -22,3 +22,7 @@ if platform == 'windows':
 SConscript('winsys/SConscript')
 
 SConscript('targets/SConscript')
+
+if platform != 'embedded':
+	SConscript('tests/unit/SConscript')
+	#SConscript('tests/raw/SConscript')
diff --git a/src/gallium/auxiliary/Makefile b/src/gallium/auxiliary/Makefile
index 843778d8100..c4d6b528b7c 100644
--- a/src/gallium/auxiliary/Makefile
+++ b/src/gallium/auxiliary/Makefile
@@ -106,9 +106,13 @@ C_SOURCES = \
 	util/u_dl.c \
 	util/u_draw_quad.c \
 	util/u_format.c \
+	util/u_format_other.c \
 	util/u_format_s3tc.c \
+	util/u_format_srgb.c \
 	util/u_format_table.c \
 	util/u_format_tests.c \
+	util/u_format_yuv.c \
+	util/u_format_zs.c \
 	util/u_gen_mipmap.c \
 	util/u_half.c \
 	util/u_handle_table.c \
@@ -127,9 +131,9 @@ C_SOURCES = \
 	util/u_surface.c \
 	util/u_texture.c \
 	util/u_tile.c \
-	util/u_timed_winsys.c \
+	util/u_transfer.c \
+	util/u_resource.c \
 	util/u_upload_mgr.c \
-	util/u_simple_screen.c \
 	target-helpers/wrap_screen.c
 
 	# Disabling until pipe-video branch gets merged in
@@ -151,6 +155,7 @@ GALLIVM_SOURCES = \
         gallivm/lp_bld_depth.c \
         gallivm/lp_bld_flow.c \
         gallivm/lp_bld_format_soa.c \
+        gallivm/lp_bld_init.c \
         gallivm/lp_bld_interp.c \
         gallivm/lp_bld_intr.c \
         gallivm/lp_bld_logic.c \
@@ -161,14 +166,17 @@ GALLIVM_SOURCES = \
         gallivm/lp_bld_struct.c \
         gallivm/lp_bld_swizzle.c \
         gallivm/lp_bld_tgsi_soa.c \
-        gallivm/lp_bld_type.c
+        gallivm/lp_bld_type.c \
+        draw/draw_llvm.c \
+        draw/draw_pt_fetch_shade_pipeline_llvm.c \
+        draw/draw_llvm_translate.c
 
-GALLIVM_CPP_SOURCES = \
-        gallivm/lp_bld_init.cpp
+GALLIVM_CPP_SOURCES =
 
 GENERATED_SOURCES = \
 	indices/u_indices_gen.c \
 	indices/u_unfilled_gen.c \
+	util/u_format_srgb.c \
 	util/u_format_table.c \
 	util/u_half.c
 
@@ -193,11 +201,11 @@ indices/u_indices_gen.c: indices/u_indices_gen.py
 indices/u_unfilled_gen.c: indices/u_unfilled_gen.py
 	python $< > $@
 
+util/u_format_srgb.c: util/u_format_srgb.py
+	python $< > $@
+
 util/u_format_table.c: util/u_format_table.py util/u_format_pack.py util/u_format_parse.py util/u_format.csv
 	python util/u_format_table.py util/u_format.csv > $@
 
-util/u_format_access.c: util/u_format_access.py util/u_format_parse.py util/u_format.csv
-	python util/u_format_access.py util/u_format.csv > $@
-
 util/u_half.c: util/u_half.py
 	python util/u_half.py > $@
diff --git a/src/gallium/auxiliary/SConscript b/src/gallium/auxiliary/SConscript
index 73d4150448f..3ad06003268 100644
--- a/src/gallium/auxiliary/SConscript
+++ b/src/gallium/auxiliary/SConscript
@@ -24,6 +24,13 @@ env.CodeGenerate(
 )
 
 env.CodeGenerate(
+    target = 'util/u_format_srgb.c', 
+    script = 'util/u_format_srgb.py', 
+    source = [],
+    command = python_cmd + ' $SCRIPT > $TARGET'
+)
+
+env.CodeGenerate(
     target = 'util/u_format_table.c',
     script = 'util/u_format_table.py',
     source = ['util/u_format.csv'],
@@ -148,9 +155,13 @@ source = [
     'util/u_dl.c',
     'util/u_draw_quad.c',
     'util/u_format.c',
+    'util/u_format_other.c',
     'util/u_format_s3tc.c',
+    'util/u_format_srgb.c',
     'util/u_format_table.c',
     'util/u_format_tests.c',
+    'util/u_format_yuv.c',
+    'util/u_format_zs.c',
     'util/u_gen_mipmap.c',
     'util/u_half.c',
     'util/u_handle_table.c',
@@ -161,6 +172,7 @@ source = [
     'util/u_math.c',
     'util/u_mm.c',
     'util/u_rect.c',
+    'util/u_resource.c',
     'util/u_ringbuffer.c',
     'util/u_sampler.c',
     'util/u_simple_shaders.c',
@@ -168,9 +180,8 @@ source = [
     'util/u_surface.c',
     'util/u_texture.c',
     'util/u_tile.c',
-    'util/u_timed_winsys.c',
+    'util/u_transfer.c',
     'util/u_upload_mgr.c',
-    'util/u_simple_screen.c',
     # Disabling until pipe-video branch gets merged in
     #'vl/vl_bitstream_parser.c',
     #'vl/vl_mpeg12_mc_renderer.c',
@@ -180,7 +191,7 @@ source = [
     'target-helpers/wrap_screen.c',
 ]
 
-if drawllvm:
+if env['llvm']:
     source += [
     'gallivm/lp_bld_alpha.c',
     'gallivm/lp_bld_arit.c',
@@ -196,7 +207,7 @@ if drawllvm:
     'gallivm/lp_bld_interp.c',
     'gallivm/lp_bld_intr.c',
     'gallivm/lp_bld_logic.c',
-    'gallivm/lp_bld_init.cpp',
+    'gallivm/lp_bld_init.c',
     'gallivm/lp_bld_pack.c',
     'gallivm/lp_bld_printf.c',
     'gallivm/lp_bld_sample.c',
@@ -205,6 +216,9 @@ if drawllvm:
     'gallivm/lp_bld_swizzle.c',
     'gallivm/lp_bld_tgsi_soa.c',
     'gallivm/lp_bld_type.c',
+    'draw/draw_llvm.c',
+    'draw/draw_pt_fetch_shade_pipeline_llvm.c',
+    'draw/draw_llvm_translate.c'
     ]
 
 gallium = env.ConvenienceLibrary(
diff --git a/src/gallium/auxiliary/draw/draw_context.c b/src/gallium/auxiliary/draw/draw_context.c
index bb0988543f5..b6574a9fea1 100644
--- a/src/gallium/auxiliary/draw/draw_context.c
+++ b/src/gallium/auxiliary/draw/draw_context.c
@@ -44,6 +44,18 @@ struct draw_context *draw_create( void )
    if (draw == NULL)
       goto fail;
 
+   if (!draw_init(draw))
+      goto fail;
+
+   return draw;
+
+fail:
+   draw_destroy( draw );
+   return NULL;
+}
+
+boolean draw_init(struct draw_context *draw)
+{
    ASSIGN_4V( draw->plane[0], -1,  0,  0, 1 );
    ASSIGN_4V( draw->plane[1],  1,  0,  0, 1 );
    ASSIGN_4V( draw->plane[2],  0, -1,  0, 1 );
@@ -57,22 +69,18 @@ struct draw_context *draw_create( void )
 
 
    if (!draw_pipeline_init( draw ))
-      goto fail;
+      return FALSE;
 
    if (!draw_pt_init( draw ))
-      goto fail;
+      return FALSE;
 
    if (!draw_vs_init( draw ))
-      goto fail;
+      return FALSE;
 
    if (!draw_gs_init( draw ))
-      goto fail;
+      return FALSE;
 
-   return draw;
-
-fail:
-   draw_destroy( draw );   
-   return NULL;
+   return TRUE;
 }
 
 
diff --git a/src/gallium/auxiliary/draw/draw_context.h b/src/gallium/auxiliary/draw/draw_context.h
index acd81b9712d..1af4961716c 100644
--- a/src/gallium/auxiliary/draw/draw_context.h
+++ b/src/gallium/auxiliary/draw/draw_context.h
@@ -40,7 +40,6 @@
 
 #include "pipe/p_state.h"
 
-
 struct pipe_context;
 struct draw_context;
 struct draw_stage;
@@ -197,6 +196,11 @@ boolean draw_need_pipeline(const struct draw_context *draw,
                            const struct pipe_rasterizer_state *rasterizer,
                            unsigned prim );
 
-
+#ifdef HAVE_LLVM
+/*******************************************************************************
+ * LLVM integration
+ */
+struct draw_context *draw_create_with_llvm(void);
+#endif
 
 #endif /* DRAW_CONTEXT_H */
diff --git a/src/gallium/auxiliary/draw/draw_gs.c b/src/gallium/auxiliary/draw/draw_gs.c
index 7069aa6b181..131deed43e4 100644
--- a/src/gallium/auxiliary/draw/draw_gs.c
+++ b/src/gallium/auxiliary/draw/draw_gs.c
@@ -342,10 +342,10 @@ void draw_geometry_shader_delete(struct draw_geometry_shader *shader)
 void draw_geometry_shader_prepare(struct draw_geometry_shader *shader,
                                   struct draw_context *draw)
 {
-    if (shader->machine->Tokens != shader->state.tokens) {
-       tgsi_exec_machine_bind_shader(shader->machine,
-                                     shader->state.tokens,
-                                     draw->gs.num_samplers,
-                                     draw->gs.samplers);
-    }
+   if (shader && shader->machine->Tokens != shader->state.tokens) {
+      tgsi_exec_machine_bind_shader(shader->machine,
+                                    shader->state.tokens,
+                                    draw->gs.num_samplers,
+                                    draw->gs.samplers);
+   }
 }
diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c
new file mode 100644
index 00000000000..364a560ecad
--- /dev/null
+++ b/src/gallium/auxiliary/draw/draw_llvm.c
@@ -0,0 +1,727 @@
+#include "draw_llvm.h"
+
+#include "draw_context.h"
+#include "draw_vs.h"
+
+#include "gallivm/lp_bld_arit.h"
+#include "gallivm/lp_bld_interp.h"
+#include "gallivm/lp_bld_struct.h"
+#include "gallivm/lp_bld_type.h"
+#include "gallivm/lp_bld_flow.h"
+#include "gallivm/lp_bld_debug.h"
+#include "gallivm/lp_bld_tgsi.h"
+#include "gallivm/lp_bld_printf.h"
+#include "gallivm/lp_bld_init.h"
+
+#include "util/u_cpu_detect.h"
+#include "util/u_string.h"
+
+#include <llvm-c/Transforms/Scalar.h>
+
+#define DEBUG_STORE 0
+
+
+/* generates the draw jit function */
+static void
+draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *var);
+
+static void
+init_globals(struct draw_llvm *llvm)
+{
+   LLVMTypeRef texture_type;
+
+   /* struct draw_jit_texture */
+   {
+      LLVMTypeRef elem_types[4];
+
+      elem_types[DRAW_JIT_TEXTURE_WIDTH]  = LLVMInt32Type();
+      elem_types[DRAW_JIT_TEXTURE_HEIGHT] = LLVMInt32Type();
+      elem_types[DRAW_JIT_TEXTURE_STRIDE] = LLVMInt32Type();
+      elem_types[DRAW_JIT_TEXTURE_DATA]   = LLVMPointerType(LLVMInt8Type(), 0);
+
+      texture_type = LLVMStructType(elem_types, Elements(elem_types), 0);
+
+      LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, width,
+                             llvm->target, texture_type,
+                             DRAW_JIT_TEXTURE_WIDTH);
+      LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, height,
+                             llvm->target, texture_type,
+                             DRAW_JIT_TEXTURE_HEIGHT);
+      LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, stride,
+                             llvm->target, texture_type,
+                             DRAW_JIT_TEXTURE_STRIDE);
+      LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, data,
+                             llvm->target, texture_type,
+                             DRAW_JIT_TEXTURE_DATA);
+      LP_CHECK_STRUCT_SIZE(struct draw_jit_texture,
+                           llvm->target, texture_type);
+
+      LLVMAddTypeName(llvm->module, "texture", texture_type);
+   }
+
+
+   /* struct draw_jit_context */
+   {
+      LLVMTypeRef elem_types[3];
+      LLVMTypeRef context_type;
+
+      elem_types[0] = LLVMPointerType(LLVMFloatType(), 0); /* vs_constants */
+      elem_types[1] = LLVMPointerType(LLVMFloatType(), 0); /* vs_constants */
+      elem_types[2] = LLVMArrayType(texture_type, PIPE_MAX_SAMPLERS); /* textures */
+
+      context_type = LLVMStructType(elem_types, Elements(elem_types), 0);
+
+      LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, vs_constants,
+                             llvm->target, context_type, 0);
+      LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, gs_constants,
+                             llvm->target, context_type, 1);
+      LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, textures,
+                             llvm->target, context_type,
+                             DRAW_JIT_CONTEXT_TEXTURES_INDEX);
+      LP_CHECK_STRUCT_SIZE(struct draw_jit_context,
+                           llvm->target, context_type);
+
+      LLVMAddTypeName(llvm->module, "draw_jit_context", context_type);
+
+      llvm->context_ptr_type = LLVMPointerType(context_type, 0);
+   }
+   {
+      LLVMTypeRef buffer_ptr = LLVMPointerType(LLVMIntType(8), 0);
+      llvm->buffer_ptr_type = LLVMPointerType(buffer_ptr, 0);
+   }
+   /* struct pipe_vertex_buffer */
+   {
+      LLVMTypeRef elem_types[4];
+      LLVMTypeRef vb_type;
+
+      elem_types[0] = LLVMInt32Type();
+      elem_types[1] = LLVMInt32Type();
+      elem_types[2] = LLVMInt32Type();
+      elem_types[3] = LLVMPointerType(LLVMOpaqueType(), 0); /* vs_constants */
+
+      vb_type = LLVMStructType(elem_types, Elements(elem_types), 0);
+
+      LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, stride,
+                             llvm->target, vb_type, 0);
+      LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, buffer_offset,
+                             llvm->target, vb_type, 2);
+      LP_CHECK_STRUCT_SIZE(struct pipe_vertex_buffer,
+                           llvm->target, vb_type);
+
+      LLVMAddTypeName(llvm->module, "pipe_vertex_buffer", vb_type);
+
+      llvm->vb_ptr_type = LLVMPointerType(vb_type, 0);
+   }
+}
+
+static LLVMTypeRef
+create_vertex_header(struct draw_llvm *llvm, int data_elems)
+{
+   /* struct vertex_header */
+   LLVMTypeRef elem_types[3];
+   LLVMTypeRef vertex_header;
+   char struct_name[24];
+
+   util_snprintf(struct_name, 23, "vertex_header%d", data_elems);
+
+   elem_types[0]  = LLVMIntType(32);
+   elem_types[1]  = LLVMArrayType(LLVMFloatType(), 4);
+   elem_types[2]  = LLVMArrayType(elem_types[1], data_elems);
+
+   vertex_header = LLVMStructType(elem_types, Elements(elem_types), 0);
+
+   /* these are bit-fields and we can't take address of them
+      LP_CHECK_MEMBER_OFFSET(struct vertex_header, clipmask,
+      llvm->target, vertex_header,
+      DRAW_JIT_VERTEX_CLIPMASK);
+      LP_CHECK_MEMBER_OFFSET(struct vertex_header, edgeflag,
+      llvm->target, vertex_header,
+      DRAW_JIT_VERTEX_EDGEFLAG);
+      LP_CHECK_MEMBER_OFFSET(struct vertex_header, pad,
+      llvm->target, vertex_header,
+      DRAW_JIT_VERTEX_PAD);
+      LP_CHECK_MEMBER_OFFSET(struct vertex_header, vertex_id,
+      llvm->target, vertex_header,
+      DRAW_JIT_VERTEX_VERTEX_ID);
+   */
+   LP_CHECK_MEMBER_OFFSET(struct vertex_header, clip,
+                          llvm->target, vertex_header,
+                          DRAW_JIT_VERTEX_CLIP);
+   LP_CHECK_MEMBER_OFFSET(struct vertex_header, data,
+                          llvm->target, vertex_header,
+                          DRAW_JIT_VERTEX_DATA);
+
+   LLVMAddTypeName(llvm->module, struct_name, vertex_header);
+
+   return LLVMPointerType(vertex_header, 0);
+}
+
+struct draw_llvm *
+draw_llvm_create(struct draw_context *draw)
+{
+   struct draw_llvm *llvm = CALLOC_STRUCT( draw_llvm );
+
+   util_cpu_detect();
+
+   llvm->draw = draw;
+   llvm->engine = draw->engine;
+
+   debug_assert(llvm->engine);
+
+   llvm->module = LLVMModuleCreateWithName("draw_llvm");
+   llvm->provider = LLVMCreateModuleProviderForExistingModule(llvm->module);
+
+   LLVMAddModuleProvider(llvm->engine, llvm->provider);
+
+   llvm->target = LLVMGetExecutionEngineTargetData(llvm->engine);
+
+   llvm->pass = LLVMCreateFunctionPassManager(llvm->provider);
+   LLVMAddTargetData(llvm->target, llvm->pass);
+   /* These are the passes currently listed in llvm-c/Transforms/Scalar.h,
+    * but there are more on SVN. */
+   /* TODO: Add more passes */
+   LLVMAddConstantPropagationPass(llvm->pass);
+   if(util_cpu_caps.has_sse4_1) {
+      /* FIXME: There is a bug in this pass, whereby the combination of fptosi
+       * and sitofp (necessary for trunc/floor/ceil/round implementation)
+       * somehow becomes invalid code.
+       */
+      LLVMAddInstructionCombiningPass(llvm->pass);
+   }
+   LLVMAddPromoteMemoryToRegisterPass(llvm->pass);
+   LLVMAddGVNPass(llvm->pass);
+   LLVMAddCFGSimplificationPass(llvm->pass);
+
+   init_globals(llvm);
+
+
+#if 1
+   LLVMDumpModule(llvm->module);
+#endif
+
+   return llvm;
+}
+
+void
+draw_llvm_destroy(struct draw_llvm *llvm)
+{
+   free(llvm);
+}
+
+struct draw_llvm_variant *
+draw_llvm_prepare(struct draw_llvm *llvm, int num_inputs)
+{
+   struct draw_llvm_variant *variant = MALLOC(sizeof(struct draw_llvm_variant));
+
+   draw_llvm_make_variant_key(llvm, &variant->key);
+
+   llvm->vertex_header_ptr_type = create_vertex_header(llvm, num_inputs);
+
+   draw_llvm_generate(llvm, variant);
+
+   return variant;
+}
+
+
+struct draw_context *draw_create_with_llvm(void)
+{
+   struct draw_context *draw = CALLOC_STRUCT( draw_context );
+   if (draw == NULL)
+      goto fail;
+
+   assert(lp_build_engine);
+   draw->engine = lp_build_engine;
+
+   if (!draw_init(draw))
+      goto fail;
+
+   return draw;
+
+fail:
+   draw_destroy( draw );
+   return NULL;
+}
+
+static void
+generate_vs(struct draw_llvm *llvm,
+            LLVMBuilderRef builder,
+            LLVMValueRef (*outputs)[NUM_CHANNELS],
+            const LLVMValueRef (*inputs)[NUM_CHANNELS],
+            LLVMValueRef context_ptr)
+{
+   const struct tgsi_token *tokens = llvm->draw->vs.vertex_shader->state.tokens;
+   struct lp_type vs_type;
+   LLVMValueRef consts_ptr = draw_jit_context_vs_constants(builder, context_ptr);
+
+   memset(&vs_type, 0, sizeof vs_type);
+   vs_type.floating = TRUE; /* floating point values */
+   vs_type.sign = TRUE;     /* values are signed */
+   vs_type.norm = FALSE;    /* values are not limited to [0,1] or [-1,1] */
+   vs_type.width = 32;      /* 32-bit float */
+   vs_type.length = 4;      /* 4 elements per vector */
+#if 0
+   num_vs = 4;              /* number of vertices per block */
+#endif
+
+   /*tgsi_dump(tokens, 0);*/
+   lp_build_tgsi_soa(builder,
+                     tokens,
+                     vs_type,
+                     NULL /*struct lp_build_mask_context *mask*/,
+                     consts_ptr,
+                     NULL /*pos*/,
+                     inputs,
+                     outputs,
+                     NULL/*sampler*/);
+}
+
+#if DEBUG_STORE
+static void print_vectorf(LLVMBuilderRef builder,
+                         LLVMValueRef vec)
+{
+   LLVMValueRef val[4];
+   val[0] = LLVMBuildExtractElement(builder, vec,
+                                    LLVMConstInt(LLVMInt32Type(), 0, 0), "");
+   val[1] = LLVMBuildExtractElement(builder, vec,
+                                    LLVMConstInt(LLVMInt32Type(), 1, 0), "");
+   val[2] = LLVMBuildExtractElement(builder, vec,
+                                    LLVMConstInt(LLVMInt32Type(), 2, 0), "");
+   val[3] = LLVMBuildExtractElement(builder, vec,
+                                    LLVMConstInt(LLVMInt32Type(), 3, 0), "");
+   lp_build_printf(builder, "vector = [%f, %f, %f, %f]\n",
+                   val[0], val[1], val[2], val[3]);
+}
+#endif
+
+static void
+generate_fetch(LLVMBuilderRef builder,
+               LLVMValueRef vbuffers_ptr,
+               LLVMValueRef *res,
+               struct pipe_vertex_element *velem,
+               LLVMValueRef vbuf,
+               LLVMValueRef index)
+{
+   LLVMValueRef indices = LLVMConstInt(LLVMInt64Type(), velem->vertex_buffer_index, 0);
+   LLVMValueRef vbuffer_ptr = LLVMBuildGEP(builder, vbuffers_ptr,
+                                           &indices, 1, "");
+   LLVMValueRef vb_stride = draw_jit_vbuffer_stride(builder, vbuf);
+   LLVMValueRef vb_buffer_offset = draw_jit_vbuffer_offset(builder, vbuf);
+   LLVMValueRef stride = LLVMBuildMul(builder,
+                                      vb_stride,
+                                      index, "");
+
+   vbuffer_ptr = LLVMBuildLoad(builder, vbuffer_ptr, "vbuffer");
+
+   stride = LLVMBuildAdd(builder, stride,
+                         vb_buffer_offset,
+                         "");
+   stride = LLVMBuildAdd(builder, stride,
+                         LLVMConstInt(LLVMInt32Type(), velem->src_offset, 0),
+                         "");
+
+   /*lp_build_printf(builder, "vbuf index = %d, stride is %d\n", indices, stride);*/
+   vbuffer_ptr = LLVMBuildGEP(builder, vbuffer_ptr, &stride, 1, "");
+
+   *res = draw_llvm_translate_from(builder, vbuffer_ptr, velem->src_format);
+}
+
+static LLVMValueRef
+aos_to_soa(LLVMBuilderRef builder,
+           LLVMValueRef val0,
+           LLVMValueRef val1,
+           LLVMValueRef val2,
+           LLVMValueRef val3,
+           LLVMValueRef channel)
+{
+   LLVMValueRef ex, res;
+
+   ex = LLVMBuildExtractElement(builder, val0,
+                                channel, "");
+   res = LLVMBuildInsertElement(builder,
+                                LLVMConstNull(LLVMTypeOf(val0)),
+                                ex,
+                                LLVMConstInt(LLVMInt32Type(), 0, 0),
+                                "");
+
+   ex = LLVMBuildExtractElement(builder, val1,
+                                channel, "");
+   res = LLVMBuildInsertElement(builder,
+                                res, ex,
+                                LLVMConstInt(LLVMInt32Type(), 1, 0),
+                                "");
+
+   ex = LLVMBuildExtractElement(builder, val2,
+                                channel, "");
+   res = LLVMBuildInsertElement(builder,
+                                res, ex,
+                                LLVMConstInt(LLVMInt32Type(), 2, 0),
+                                "");
+
+   ex = LLVMBuildExtractElement(builder, val3,
+                                channel, "");
+   res = LLVMBuildInsertElement(builder,
+                                res, ex,
+                                LLVMConstInt(LLVMInt32Type(), 3, 0),
+                                "");
+
+   return res;
+}
+
+static void
+soa_to_aos(LLVMBuilderRef builder,
+           LLVMValueRef soa[NUM_CHANNELS],
+           LLVMValueRef aos[NUM_CHANNELS])
+{
+   LLVMValueRef comp;
+   int i = 0;
+
+   debug_assert(NUM_CHANNELS == 4);
+
+   aos[0] = LLVMConstNull(LLVMTypeOf(soa[0]));
+   aos[1] = aos[2] = aos[3] = aos[0];
+
+   for (i = 0; i < NUM_CHANNELS; ++i) {
+      LLVMValueRef channel = LLVMConstInt(LLVMInt32Type(), i, 0);
+
+      comp = LLVMBuildExtractElement(builder, soa[i],
+                                     LLVMConstInt(LLVMInt32Type(), 0, 0), "");
+      aos[0] = LLVMBuildInsertElement(builder, aos[0], comp, channel, "");
+
+      comp = LLVMBuildExtractElement(builder, soa[i],
+                                     LLVMConstInt(LLVMInt32Type(), 1, 0), "");
+      aos[1] = LLVMBuildInsertElement(builder, aos[1], comp, channel, "");
+
+      comp = LLVMBuildExtractElement(builder, soa[i],
+                                     LLVMConstInt(LLVMInt32Type(), 2, 0), "");
+      aos[2] = LLVMBuildInsertElement(builder, aos[2], comp, channel, "");
+
+      comp = LLVMBuildExtractElement(builder, soa[i],
+                                     LLVMConstInt(LLVMInt32Type(), 3, 0), "");
+      aos[3] = LLVMBuildInsertElement(builder, aos[3], comp, channel, "");
+
+   }
+}
+
+static void
+convert_to_soa(LLVMBuilderRef builder,
+               LLVMValueRef (*aos)[NUM_CHANNELS],
+               LLVMValueRef (*soa)[NUM_CHANNELS],
+               int num_attribs)
+{
+   int i;
+
+   debug_assert(NUM_CHANNELS == 4);
+
+   for (i = 0; i < num_attribs; ++i) {
+      LLVMValueRef val0 = aos[i][0];
+      LLVMValueRef val1 = aos[i][1];
+      LLVMValueRef val2 = aos[i][2];
+      LLVMValueRef val3 = aos[i][3];
+
+      soa[i][0] = aos_to_soa(builder, val0, val1, val2, val3,
+                             LLVMConstInt(LLVMInt32Type(), 0, 0));
+      soa[i][1] = aos_to_soa(builder, val0, val1, val2, val3,
+                             LLVMConstInt(LLVMInt32Type(), 1, 0));
+      soa[i][2] = aos_to_soa(builder, val0, val1, val2, val3,
+                             LLVMConstInt(LLVMInt32Type(), 2, 0));
+      soa[i][3] = aos_to_soa(builder, val0, val1, val2, val3,
+                             LLVMConstInt(LLVMInt32Type(), 3, 0));
+   }
+}
+
+static void
+store_aos(LLVMBuilderRef builder,
+          LLVMValueRef io_ptr,
+          LLVMValueRef index,
+          LLVMValueRef value)
+{
+   LLVMValueRef id_ptr = draw_jit_header_id(builder, io_ptr);
+   LLVMValueRef data_ptr = draw_jit_header_data(builder, io_ptr);
+   LLVMValueRef indices[3];
+
+   indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+   indices[1] = index;
+   indices[2] = LLVMConstInt(LLVMInt32Type(), 0, 0);
+
+   /* undefined vertex */
+   LLVMBuildStore(builder, LLVMConstInt(LLVMInt32Type(),
+                                        0xffff, 0), id_ptr);
+
+#if DEBUG_STORE
+   lp_build_printf(builder, "    ---- %p storing attribute %d (io = %p)\n", data_ptr, index, io_ptr);
+#endif
+#if 0
+   /*lp_build_printf(builder, " ---- %p storing at %d (%p)  ", io_ptr, index, data_ptr);
+     print_vectorf(builder, value);*/
+   data_ptr = LLVMBuildBitCast(builder, data_ptr,
+                               LLVMPointerType(LLVMArrayType(LLVMVectorType(LLVMFloatType(), 4), 0), 0),
+                               "datavec");
+   data_ptr = LLVMBuildGEP(builder, data_ptr, indices, 2, "");
+
+   LLVMBuildStore(builder, value, data_ptr);
+#else
+   {
+      LLVMValueRef x, y, z, w;
+      LLVMValueRef idx0, idx1, idx2, idx3;
+      LLVMValueRef gep0, gep1, gep2, gep3;
+      data_ptr = LLVMBuildGEP(builder, data_ptr, indices, 3, "");
+
+      idx0 = LLVMConstInt(LLVMInt32Type(), 0, 0);
+      idx1 = LLVMConstInt(LLVMInt32Type(), 1, 0);
+      idx2 = LLVMConstInt(LLVMInt32Type(), 2, 0);
+      idx3 = LLVMConstInt(LLVMInt32Type(), 3, 0);
+
+      x = LLVMBuildExtractElement(builder, value,
+                                  idx0, "");
+      y = LLVMBuildExtractElement(builder, value,
+                                  idx1, "");
+      z = LLVMBuildExtractElement(builder, value,
+                                  idx2, "");
+      w = LLVMBuildExtractElement(builder, value,
+                                  idx3, "");
+
+      gep0 = LLVMBuildGEP(builder, data_ptr, &idx0, 1, "");
+      gep1 = LLVMBuildGEP(builder, data_ptr, &idx1, 1, "");
+      gep2 = LLVMBuildGEP(builder, data_ptr, &idx2, 1, "");
+      gep3 = LLVMBuildGEP(builder, data_ptr, &idx3, 1, "");
+
+      /*lp_build_printf(builder, "##### x = %f (%p), y = %f (%p), z = %f (%p), w = %f (%p)\n",
+        x, gep0, y, gep1, z, gep2, w, gep3);*/
+      LLVMBuildStore(builder, x, gep0);
+      LLVMBuildStore(builder, y, gep1);
+      LLVMBuildStore(builder, z, gep2);
+      LLVMBuildStore(builder, w, gep3);
+   }
+#endif
+}
+
+static void
+store_aos_array(LLVMBuilderRef builder,
+                LLVMValueRef io_ptr,
+                LLVMValueRef aos[NUM_CHANNELS],
+                int attrib,
+                int num_outputs)
+{
+   LLVMValueRef attr_index = LLVMConstInt(LLVMInt32Type(), attrib, 0);
+   LLVMValueRef ind0 = LLVMConstInt(LLVMInt32Type(), 0, 0);
+   LLVMValueRef ind1 = LLVMConstInt(LLVMInt32Type(), 1, 0);
+   LLVMValueRef ind2 = LLVMConstInt(LLVMInt32Type(), 2, 0);
+   LLVMValueRef ind3 = LLVMConstInt(LLVMInt32Type(), 3, 0);
+   LLVMValueRef io0_ptr, io1_ptr, io2_ptr, io3_ptr;
+
+   debug_assert(NUM_CHANNELS == 4);
+
+   io0_ptr = LLVMBuildGEP(builder, io_ptr,
+                          &ind0, 1, "");
+   io1_ptr = LLVMBuildGEP(builder, io_ptr,
+                          &ind1, 1, "");
+   io2_ptr = LLVMBuildGEP(builder, io_ptr,
+                          &ind2, 1, "");
+   io3_ptr = LLVMBuildGEP(builder, io_ptr,
+                          &ind3, 1, "");
+
+#if DEBUG_STORE
+   lp_build_printf(builder, "   io = %p, indexes[%d, %d, %d, %d]\n",
+                   io_ptr, ind0, ind1, ind2, ind3);
+#endif
+
+   store_aos(builder, io0_ptr, attr_index, aos[0]);
+   store_aos(builder, io1_ptr, attr_index, aos[1]);
+   store_aos(builder, io2_ptr, attr_index, aos[2]);
+   store_aos(builder, io3_ptr, attr_index, aos[3]);
+}
+
+static void
+convert_to_aos(LLVMBuilderRef builder,
+               LLVMValueRef io,
+               LLVMValueRef (*outputs)[NUM_CHANNELS],
+               int num_outputs,
+               int max_vertices)
+{
+   unsigned chan, attrib;
+
+#if DEBUG_STORE
+   lp_build_printf(builder, "   # storing begin\n");
+#endif
+   for (attrib = 0; attrib < num_outputs; ++attrib) {
+      LLVMValueRef soa[4];
+      LLVMValueRef aos[4];
+      for(chan = 0; chan < NUM_CHANNELS; ++chan) {
+         if(outputs[attrib][chan]) {
+            LLVMValueRef out = LLVMBuildLoad(builder, outputs[attrib][chan], "");
+            lp_build_name(out, "output%u.%c", attrib, "xyzw"[chan]);
+            /*lp_build_printf(builder, "output %d : %d ",
+                            LLVMConstInt(LLVMInt32Type(), attrib, 0),
+                            LLVMConstInt(LLVMInt32Type(), chan, 0));
+              print_vectorf(builder, out);*/
+            soa[chan] = out;
+         } else
+            soa[chan] = 0;
+      }
+      soa_to_aos(builder, soa, aos);
+      store_aos_array(builder,
+                      io,
+                      aos,
+                      attrib,
+                      num_outputs);
+   }
+#if DEBUG_STORE
+   lp_build_printf(builder, "   # storing end\n");
+#endif
+}
+
+static void
+draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant)
+{
+   LLVMTypeRef arg_types[7];
+   LLVMTypeRef func_type;
+   LLVMValueRef context_ptr;
+   LLVMBasicBlockRef block;
+   LLVMBuilderRef builder;
+   LLVMValueRef start, end, count, stride, step, io_itr;
+   LLVMValueRef io_ptr, vbuffers_ptr, vb_ptr;
+   struct draw_context *draw = llvm->draw;
+   unsigned i, j;
+   struct lp_build_context bld;
+   struct lp_build_loop_state lp_loop;
+   struct lp_type vs_type = lp_type_float_vec(32);
+   const int max_vertices = 4;
+   LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][NUM_CHANNELS];
+
+   arg_types[0] = llvm->context_ptr_type;           /* context */
+   arg_types[1] = llvm->vertex_header_ptr_type;     /* vertex_header */
+   arg_types[2] = llvm->buffer_ptr_type;            /* vbuffers */
+   arg_types[3] = LLVMInt32Type();                  /* start */
+   arg_types[4] = LLVMInt32Type();                  /* count */
+   arg_types[5] = LLVMInt32Type();                  /* stride */
+   arg_types[6] = llvm->vb_ptr_type;                /* pipe_vertex_buffer's */
+
+   func_type = LLVMFunctionType(LLVMVoidType(), arg_types, Elements(arg_types), 0);
+
+   variant->function = LLVMAddFunction(llvm->module, "draw_llvm_shader", func_type);
+   LLVMSetFunctionCallConv(variant->function, LLVMCCallConv);
+   for(i = 0; i < Elements(arg_types); ++i)
+      if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
+         LLVMAddAttribute(LLVMGetParam(variant->function, i), LLVMNoAliasAttribute);
+
+   context_ptr  = LLVMGetParam(variant->function, 0);
+   io_ptr       = LLVMGetParam(variant->function, 1);
+   vbuffers_ptr = LLVMGetParam(variant->function, 2);
+   start        = LLVMGetParam(variant->function, 3);
+   count        = LLVMGetParam(variant->function, 4);
+   stride       = LLVMGetParam(variant->function, 5);
+   vb_ptr       = LLVMGetParam(variant->function, 6);
+
+   lp_build_name(context_ptr, "context");
+   lp_build_name(io_ptr, "io");
+   lp_build_name(vbuffers_ptr, "vbuffers");
+   lp_build_name(start, "start");
+   lp_build_name(count, "count");
+   lp_build_name(stride, "stride");
+   lp_build_name(vb_ptr, "vb");
+
+   /*
+    * Function body
+    */
+
+   block = LLVMAppendBasicBlock(variant->function, "entry");
+   builder = LLVMCreateBuilder();
+   LLVMPositionBuilderAtEnd(builder, block);
+
+   lp_build_context_init(&bld, builder, vs_type);
+
+   end = lp_build_add(&bld, start, count);
+
+   step = LLVMConstInt(LLVMInt32Type(), max_vertices, 0);
+
+#if DEBUG_STORE
+   lp_build_printf(builder, "start = %d, end = %d, step = %d\n",
+                   start, end, step);
+#endif
+   lp_build_loop_begin(builder, start, &lp_loop);
+   {
+      LLVMValueRef inputs[PIPE_MAX_SHADER_INPUTS][NUM_CHANNELS];
+      LLVMValueRef aos_attribs[PIPE_MAX_SHADER_INPUTS][NUM_CHANNELS] = { { 0 } };
+      LLVMValueRef io;
+      const LLVMValueRef (*ptr_aos)[NUM_CHANNELS];
+
+      io_itr = LLVMBuildSub(builder, lp_loop.counter, start, "");
+      io = LLVMBuildGEP(builder, io_ptr, &io_itr, 1, "");
+#if DEBUG_STORE
+      lp_build_printf(builder, " --- io %d = %p, loop counter %d\n",
+                      io_itr, io, lp_loop.counter);
+#endif
+      for (i = 0; i < NUM_CHANNELS; ++i) {
+         LLVMValueRef true_index = LLVMBuildAdd(
+            builder,
+            lp_loop.counter,
+            LLVMConstInt(LLVMInt32Type(), i, 0), "");
+         for (j = 0; j < draw->pt.nr_vertex_elements; ++j) {
+            struct pipe_vertex_element *velem = &draw->pt.vertex_element[j];
+            LLVMValueRef vb_index = LLVMConstInt(LLVMInt32Type(),
+                                                 velem->vertex_buffer_index,
+                                                 0);
+            LLVMValueRef vb = LLVMBuildGEP(builder, vb_ptr,
+                                           &vb_index, 1, "");
+            generate_fetch(builder, vbuffers_ptr,
+                           &aos_attribs[j][i], velem, vb, true_index);
+         }
+      }
+      convert_to_soa(builder, aos_attribs, inputs,
+                     draw->pt.nr_vertex_elements);
+
+      ptr_aos = (const LLVMValueRef (*)[NUM_CHANNELS]) inputs;
+      generate_vs(llvm,
+                  builder,
+                  outputs,
+                  ptr_aos,
+                  context_ptr);
+
+      convert_to_aos(builder, io, outputs,
+                     draw->vs.vertex_shader->info.num_outputs,
+                     max_vertices);
+   }
+   lp_build_loop_end_cond(builder, end, step, LLVMIntUGE, &lp_loop);
+
+   LLVMBuildRetVoid(builder);
+
+   LLVMDisposeBuilder(builder);
+
+   /*
+    * Translate the LLVM IR into machine code.
+    */
+#ifdef DEBUG
+   if(LLVMVerifyFunction(variant->function, LLVMPrintMessageAction)) {
+      LLVMDumpValue(variant->function);
+      assert(0);
+   }
+#endif
+
+   LLVMRunFunctionPassManager(llvm->pass, variant->function);
+
+   if (0) {
+      LLVMDumpValue(variant->function);
+      debug_printf("\n");
+   }
+   variant->jit_func = (draw_jit_vert_func)LLVMGetPointerToGlobal(llvm->draw->engine, variant->function);
+
+   if (0)
+      lp_disassemble(variant->jit_func);
+}
+
+void
+draw_llvm_make_variant_key(struct draw_llvm *llvm,
+                           struct draw_llvm_variant_key *key)
+{
+   memset(key, 0, sizeof(struct draw_llvm_variant_key));
+
+   key->nr_vertex_elements = llvm->draw->pt.nr_vertex_elements;
+
+   memcpy(key->vertex_element,
+          llvm->draw->pt.vertex_element,
+          sizeof(struct pipe_vertex_element) * key->nr_vertex_elements);
+
+   memcpy(&key->vs,
+          &llvm->draw->vs.vertex_shader->state,
+          sizeof(struct pipe_shader_state));
+}
diff --git a/src/gallium/auxiliary/draw/draw_llvm.h b/src/gallium/auxiliary/draw/draw_llvm.h
new file mode 100644
index 00000000000..28b9044a81e
--- /dev/null
+++ b/src/gallium/auxiliary/draw/draw_llvm.h
@@ -0,0 +1,144 @@
+#ifndef HAVE_LLVM_H
+#define HAVE_LLVM_H
+
+#include "draw/draw_private.h"
+
+#include "pipe/p_context.h"
+
+#include <llvm-c/Core.h>
+#include <llvm-c/Analysis.h>
+#include <llvm-c/Target.h>
+#include <llvm-c/ExecutionEngine.h>
+
+struct draw_jit_texture
+{
+   uint32_t width;
+   uint32_t height;
+   uint32_t stride;
+   const void *data;
+};
+
+enum {
+   DRAW_JIT_TEXTURE_WIDTH = 0,
+   DRAW_JIT_TEXTURE_HEIGHT,
+   DRAW_JIT_TEXTURE_STRIDE,
+   DRAW_JIT_TEXTURE_DATA
+};
+
+enum {
+   DRAW_JIT_VERTEX_VERTEX_ID = 0,
+   DRAW_JIT_VERTEX_CLIP,
+   DRAW_JIT_VERTEX_DATA
+};
+
+/**
+ * This structure is passed directly to the generated vertex shader.
+ *
+ * It contains the derived state.
+ *
+ * Changes here must be reflected in the draw_jit_context_* macros.
+ * Changes to the ordering should be avoided.
+ *
+ * Only use types with a clear size and padding here, in particular prefer the
+ * stdint.h types to the basic integer types.
+ */
+struct draw_jit_context
+{
+   const float *vs_constants;
+   const float *gs_constants;
+
+
+   struct draw_jit_texture textures[PIPE_MAX_SAMPLERS];
+};
+
+
+#define draw_jit_context_vs_constants(_builder, _ptr) \
+   lp_build_struct_get(_builder, _ptr, 0, "vs_constants")
+
+#define draw_jit_context_gs_constants(_builder, _ptr) \
+   lp_build_struct_get(_builder, _ptr, 1, "gs_constants")
+
+#define DRAW_JIT_CONTEXT_TEXTURES_INDEX 2
+
+#define draw_jit_context_textures(_builder, _ptr) \
+   lp_build_struct_get_ptr(_builder, _ptr, DRAW_JIT_CONTEXT_TEXTURES_INDEX, "textures")
+
+
+
+#define draw_jit_header_id(_builder, _ptr)              \
+   lp_build_struct_get_ptr(_builder, _ptr, 0, "id")
+
+#define draw_jit_header_clip(_builder, _ptr) \
+   lp_build_struct_get(_builder, _ptr, 1, "clip")
+
+#define draw_jit_header_data(_builder, _ptr)            \
+   lp_build_struct_get_ptr(_builder, _ptr, 2, "data")
+
+
+#define draw_jit_vbuffer_stride(_builder, _ptr)         \
+   lp_build_struct_get(_builder, _ptr, 0, "stride")
+
+#define draw_jit_vbuffer_offset(_builder, _ptr)                 \
+   lp_build_struct_get(_builder, _ptr, 2, "buffer_offset")
+
+
+typedef void
+(*draw_jit_vert_func)(struct draw_jit_context *context,
+                      struct vertex_header *io,
+                      const char *vbuffers[PIPE_MAX_ATTRIBS],
+                      unsigned start,
+                      unsigned count,
+                      unsigned stride,
+                      struct pipe_vertex_buffer *vertex_buffers);
+
+struct draw_llvm {
+   struct draw_context *draw;
+
+   struct draw_jit_context jit_context;
+
+   LLVMModuleRef module;
+   LLVMExecutionEngineRef engine;
+   LLVMModuleProviderRef provider;
+   LLVMTargetDataRef target;
+   LLVMPassManagerRef pass;
+
+   LLVMTypeRef context_ptr_type;
+   LLVMTypeRef vertex_header_ptr_type;
+   LLVMTypeRef buffer_ptr_type;
+   LLVMTypeRef vb_ptr_type;
+};
+
+struct draw_llvm_variant_key
+{
+   struct pipe_vertex_element vertex_element[PIPE_MAX_ATTRIBS];
+   unsigned                   nr_vertex_elements;
+   struct pipe_shader_state   vs;
+};
+
+struct draw_llvm_variant
+{
+   struct draw_llvm_variant_key key;
+   LLVMValueRef function;
+   draw_jit_vert_func jit_func;
+
+   struct draw_llvm_variant *next;
+};
+
+struct draw_llvm *
+draw_llvm_create(struct draw_context *draw);
+
+void
+draw_llvm_destroy(struct draw_llvm *llvm);
+
+struct draw_llvm_variant *
+draw_llvm_prepare(struct draw_llvm *llvm, int num_inputs);
+
+void
+draw_llvm_make_variant_key(struct draw_llvm *llvm,
+                           struct draw_llvm_variant_key *key);
+
+LLVMValueRef
+draw_llvm_translate_from(LLVMBuilderRef builder,
+                         LLVMValueRef vbuffer,
+                         enum pipe_format from_format);
+#endif
diff --git a/src/gallium/auxiliary/draw/draw_llvm_translate.c b/src/gallium/auxiliary/draw/draw_llvm_translate.c
new file mode 100644
index 00000000000..2a95823f2cb
--- /dev/null
+++ b/src/gallium/auxiliary/draw/draw_llvm_translate.c
@@ -0,0 +1,481 @@
+#include "draw_private.h"
+#include "draw_context.h"
+
+#include "draw_llvm.h"
+
+#include "gallivm/lp_bld_arit.h"
+#include "gallivm/lp_bld_interp.h"
+#include "gallivm/lp_bld_struct.h"
+#include "gallivm/lp_bld_type.h"
+#include "gallivm/lp_bld_debug.h"
+
+#include "util/u_memory.h"
+#include "pipe/p_state.h"
+
+
+#define DRAW_DBG 0
+
+static  LLVMValueRef
+from_64_float(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMDoubleType(), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   return LLVMBuildFPTrunc(builder, l, LLVMFloatType(), "");
+}
+
+static LLVMValueRef
+from_32_float(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMFloatType(), 0) , "");
+   return LLVMBuildLoad(builder, bc, "");
+}
+
+static INLINE LLVMValueRef
+from_8_uscaled(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
+   return LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+}
+
+static INLINE LLVMValueRef
+from_16_uscaled(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMIntType(16), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   return LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+}
+
+static INLINE LLVMValueRef
+from_32_uscaled(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMIntType(32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   return LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+}
+
+static INLINE LLVMValueRef
+from_8_sscaled(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
+   return LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+}
+
+static INLINE LLVMValueRef
+from_16_sscaled(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMIntType(16), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   return LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+}
+
+static INLINE LLVMValueRef
+from_32_sscaled(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMIntType(32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   return LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+}
+
+
+static INLINE LLVMValueRef
+from_8_unorm(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
+   LLVMValueRef uscaled = LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+   return LLVMBuildFDiv(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 255.), "");
+}
+
+static INLINE LLVMValueRef
+from_16_unorm(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMIntType(16), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+   return LLVMBuildFDiv(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 65535.), "");
+}
+
+static INLINE LLVMValueRef
+from_32_unorm(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMIntType(32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildUIToFP(builder, l, LLVMFloatType(), "");
+
+   return LLVMBuildFDiv(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 4294967295.), "");
+}
+
+static INLINE LLVMValueRef
+from_8_snorm(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
+   LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+   return LLVMBuildFDiv(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 127.0), "");
+}
+
+static INLINE LLVMValueRef
+from_16_snorm(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMIntType(16), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+   return LLVMBuildFDiv(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 32767.0f), "");
+}
+
+static INLINE LLVMValueRef
+from_32_snorm(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMIntType(32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+
+   return LLVMBuildFDiv(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 2147483647.0), "");
+}
+
+static INLINE LLVMValueRef
+from_32_fixed(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef bc = LLVMBuildBitCast(builder, val,
+                                      LLVMPointerType(LLVMIntType(32), 0) , "");
+   LLVMValueRef l = LLVMBuildLoad(builder, bc, "");
+   LLVMValueRef uscaled = LLVMBuildSIToFP(builder, l, LLVMFloatType(), "");
+
+   return LLVMBuildFDiv(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 65536.0), "");
+}
+
+static LLVMValueRef
+to_64_float(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   return LLVMBuildFPExt(builder, l, LLVMDoubleType(), "");
+}
+
+static LLVMValueRef
+to_32_float(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   return LLVMBuildLoad(builder, fp, "");
+}
+
+static INLINE LLVMValueRef
+to_8_uscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   return LLVMBuildFPToUI(builder, l, LLVMIntType(8), "");
+}
+
+static INLINE LLVMValueRef
+to_16_uscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   return LLVMBuildFPToUI(builder, l, LLVMIntType(16), "");
+}
+
+static INLINE LLVMValueRef
+to_32_uscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   return LLVMBuildFPToUI(builder, l, LLVMIntType(32), "");
+}
+
+static INLINE LLVMValueRef
+to_8_sscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   return LLVMBuildFPToSI(builder, l, LLVMIntType(8), "");
+}
+
+static INLINE LLVMValueRef
+to_16_sscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   return LLVMBuildFPToSI(builder, l, LLVMIntType(16), "");
+}
+
+static INLINE LLVMValueRef
+to_32_sscaled(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   return LLVMBuildFPToSI(builder, l, LLVMIntType(32), "");
+}
+
+static INLINE LLVMValueRef
+to_8_unorm(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToUI(builder, l, LLVMIntType(8), "");
+   return LLVMBuildFMul(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 255.), "");
+}
+
+static INLINE LLVMValueRef
+to_16_unorm(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToUI(builder, l, LLVMIntType(32), "");
+   return LLVMBuildFMul(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 65535.), "");
+}
+
+static INLINE LLVMValueRef
+to_32_unorm(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToUI(builder, l, LLVMIntType(32), "");
+
+   return LLVMBuildFMul(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 4294967295.), "");
+}
+
+static INLINE LLVMValueRef
+to_8_snorm(LLVMBuilderRef builder, LLVMValueRef val)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, val, "");
+   LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(8), "");
+   return LLVMBuildFMul(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 127.0), "");
+}
+
+static INLINE LLVMValueRef
+to_16_snorm(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(16), "");
+   return LLVMBuildFMul(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 32767.0f), "");
+}
+
+static INLINE LLVMValueRef
+to_32_snorm(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(32), "");
+
+   return LLVMBuildFMul(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 2147483647.0), "");
+}
+
+static INLINE LLVMValueRef
+to_32_fixed(LLVMBuilderRef builder, LLVMValueRef fp)
+{
+   LLVMValueRef l = LLVMBuildLoad(builder, fp, "");
+   LLVMValueRef uscaled = LLVMBuildFPToSI(builder, l, LLVMIntType(32), "");
+
+   return LLVMBuildFMul(builder, uscaled,
+                        LLVMConstReal(LLVMFloatType(), 65536.0), "");
+}
+
+typedef LLVMValueRef (*from_func)(LLVMBuilderRef, LLVMValueRef);
+typedef  LLVMValueRef (*to_func)(LLVMBuilderRef, LLVMValueRef);
+
+/* so that underneath can avoid function calls which are prohibited
+ * for static initialization we need this conversion */
+enum ll_type {
+   LL_Double,
+   LL_Float,
+   LL_Int32,
+   LL_Int16,
+   LL_Int8
+};
+
+static INLINE LLVMTypeRef
+ll_type_to_llvm(enum ll_type type)
+{
+   switch (type) {
+   case LL_Double:
+      return LLVMDoubleType();
+   case LL_Float:
+      return LLVMFloatType();
+   case LL_Int32:
+      return LLVMInt32Type();
+   case LL_Int16:
+      return LLVMIntType(16);
+   case LL_Int8:
+      return LLVMIntType(8);
+   }
+   return LLVMIntType(8);
+}
+
+static INLINE int
+ll_type_size(enum ll_type type)
+{
+   switch (type) {
+   case LL_Double:
+      return 8;
+   case LL_Float:
+      return 4;
+   case LL_Int32:
+      return 4;
+   case LL_Int16:
+      return 2;
+   case LL_Int8:
+      return 1;
+   }
+   return 1;
+}
+
+struct draw_llvm_translate {
+   int format;
+   from_func from;
+   to_func to;
+   enum ll_type type;
+   int num_components;
+} translates[] =
+{
+   {PIPE_FORMAT_R64_FLOAT,          from_64_float, to_64_float, LL_Double, 1},
+   {PIPE_FORMAT_R64G64_FLOAT,       from_64_float, to_64_float, LL_Double, 2},
+   {PIPE_FORMAT_R64G64B64_FLOAT,    from_64_float, to_64_float, LL_Double, 3},
+   {PIPE_FORMAT_R64G64B64A64_FLOAT, from_64_float, to_64_float, LL_Double, 4},
+   {PIPE_FORMAT_R32_FLOAT,          from_32_float, to_32_float, LL_Float, 1},
+   {PIPE_FORMAT_R32G32_FLOAT,       from_32_float, to_32_float, LL_Float, 2},
+   {PIPE_FORMAT_R32G32B32_FLOAT,    from_32_float, to_32_float, LL_Float, 3},
+   {PIPE_FORMAT_R32G32B32A32_FLOAT, from_32_float, to_32_float, LL_Float, 4},
+
+   {PIPE_FORMAT_R32_UNORM,          from_32_unorm, to_32_unorm, LL_Int32, 1},
+   {PIPE_FORMAT_R32G32_UNORM,       from_32_unorm, to_32_unorm, LL_Int32, 2},
+   {PIPE_FORMAT_R32G32B32_UNORM,    from_32_unorm, to_32_unorm, LL_Int32, 3},
+   {PIPE_FORMAT_R32G32B32A32_UNORM, from_32_unorm, to_32_unorm, LL_Int32, 4},
+
+   {PIPE_FORMAT_R32_USCALED,          from_32_uscaled, to_32_uscaled, LL_Int32, 1},
+   {PIPE_FORMAT_R32G32_USCALED,       from_32_uscaled, to_32_uscaled, LL_Int32, 2},
+   {PIPE_FORMAT_R32G32B32_USCALED,    from_32_uscaled, to_32_uscaled, LL_Int32, 3},
+   {PIPE_FORMAT_R32G32B32A32_USCALED, from_32_uscaled, to_32_uscaled, LL_Int32, 4},
+
+   {PIPE_FORMAT_R32_SNORM,          from_32_snorm, to_32_snorm, LL_Int32, 1},
+   {PIPE_FORMAT_R32G32_SNORM,       from_32_snorm, to_32_snorm, LL_Int32, 2},
+   {PIPE_FORMAT_R32G32B32_SNORM,    from_32_snorm, to_32_snorm, LL_Int32, 3},
+   {PIPE_FORMAT_R32G32B32A32_SNORM, from_32_snorm, to_32_snorm, LL_Int32, 4},
+
+   {PIPE_FORMAT_R32_SSCALED,          from_32_sscaled, to_32_sscaled, LL_Int32, 1},
+   {PIPE_FORMAT_R32G32_SSCALED,       from_32_sscaled, to_32_sscaled, LL_Int32, 2},
+   {PIPE_FORMAT_R32G32B32_SSCALED,    from_32_sscaled, to_32_sscaled, LL_Int32, 3},
+   {PIPE_FORMAT_R32G32B32A32_SSCALED, from_32_sscaled, to_32_sscaled, LL_Int32, 4},
+
+   {PIPE_FORMAT_R16_UNORM,          from_16_unorm, to_16_unorm, LL_Int16, 1},
+   {PIPE_FORMAT_R16G16_UNORM,       from_16_unorm, to_16_unorm, LL_Int16, 2},
+   {PIPE_FORMAT_R16G16B16_UNORM,    from_16_unorm, to_16_unorm, LL_Int16, 3},
+   {PIPE_FORMAT_R16G16B16A16_UNORM, from_16_unorm, to_16_unorm, LL_Int16, 4},
+
+   {PIPE_FORMAT_R16_USCALED,          from_16_uscaled, to_16_uscaled, LL_Int16, 1},
+   {PIPE_FORMAT_R16G16_USCALED,       from_16_uscaled, to_16_uscaled, LL_Int16, 2},
+   {PIPE_FORMAT_R16G16B16_USCALED,    from_16_uscaled, to_16_uscaled, LL_Int16, 3},
+   {PIPE_FORMAT_R16G16B16A16_USCALED, from_16_uscaled, to_16_uscaled, LL_Int16, 4},
+
+   {PIPE_FORMAT_R16_SNORM,          from_16_snorm, to_16_snorm, LL_Int16, 1},
+   {PIPE_FORMAT_R16G16_SNORM,       from_16_snorm, to_16_snorm, LL_Int16, 2},
+   {PIPE_FORMAT_R16G16B16_SNORM,    from_16_snorm, to_16_snorm, LL_Int16, 3},
+   {PIPE_FORMAT_R16G16B16A16_SNORM, from_16_snorm, to_16_snorm, LL_Int16, 4},
+
+   {PIPE_FORMAT_R16_SSCALED,          from_16_sscaled, to_16_sscaled, LL_Int16, 1},
+   {PIPE_FORMAT_R16G16_SSCALED,       from_16_sscaled, to_16_sscaled, LL_Int16, 2},
+   {PIPE_FORMAT_R16G16B16_SSCALED,    from_16_sscaled, to_16_sscaled, LL_Int16, 3},
+   {PIPE_FORMAT_R16G16B16A16_SSCALED, from_16_sscaled, to_16_sscaled, LL_Int16, 4},
+
+   {PIPE_FORMAT_R8_UNORM,       from_8_unorm, to_8_unorm, LL_Int8, 1},
+   {PIPE_FORMAT_R8G8_UNORM,     from_8_unorm, to_8_unorm, LL_Int8, 2},
+   {PIPE_FORMAT_R8G8B8_UNORM,   from_8_unorm, to_8_unorm, LL_Int8, 3},
+   {PIPE_FORMAT_R8G8B8A8_UNORM, from_8_unorm, to_8_unorm, LL_Int8, 4},
+
+   {PIPE_FORMAT_R8_USCALED,       from_8_uscaled, to_8_uscaled, LL_Int8, 1},
+   {PIPE_FORMAT_R8G8_USCALED,     from_8_uscaled, to_8_uscaled, LL_Int8, 2},
+   {PIPE_FORMAT_R8G8B8_USCALED,   from_8_uscaled, to_8_uscaled, LL_Int8, 3},
+   {PIPE_FORMAT_R8G8B8A8_USCALED, from_8_uscaled, to_8_uscaled, LL_Int8, 4},
+
+   {PIPE_FORMAT_R8_SNORM,       from_8_snorm, to_8_snorm, LL_Int8, 1},
+   {PIPE_FORMAT_R8G8_SNORM,     from_8_snorm, to_8_snorm, LL_Int8, 2},
+   {PIPE_FORMAT_R8G8B8_SNORM,   from_8_snorm, to_8_snorm, LL_Int8, 3},
+   {PIPE_FORMAT_R8G8B8A8_SNORM, from_8_snorm, to_8_snorm, LL_Int8, 4},
+
+   {PIPE_FORMAT_R8_SSCALED,       from_8_sscaled, to_8_sscaled, LL_Int8, 1},
+   {PIPE_FORMAT_R8G8_SSCALED,     from_8_sscaled, to_8_sscaled, LL_Int8, 2},
+   {PIPE_FORMAT_R8G8B8_SSCALED,   from_8_sscaled, to_8_sscaled, LL_Int8, 3},
+   {PIPE_FORMAT_R8G8B8A8_SSCALED, from_8_sscaled, to_8_sscaled, LL_Int8, 4},
+
+   {PIPE_FORMAT_R32_FIXED,          from_32_fixed, to_32_fixed, LL_Int32, 1},
+   {PIPE_FORMAT_R32G32_FIXED,       from_32_fixed, to_32_fixed, LL_Int32, 2},
+   {PIPE_FORMAT_R32G32B32_FIXED,    from_32_fixed, to_32_fixed, LL_Int32, 3},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, from_32_fixed, to_32_fixed, LL_Int32, 4},
+
+   {PIPE_FORMAT_A8R8G8B8_UNORM, from_8_unorm, to_8_unorm, LL_Int8, 4},
+   {PIPE_FORMAT_B8G8R8A8_UNORM, from_8_unorm, to_8_unorm, LL_Int8, 4},
+};
+
+
+static LLVMValueRef
+fetch(LLVMBuilderRef builder,
+      LLVMValueRef ptr, int val_size, int nr_components,
+      from_func func)
+{
+   int i;
+   int offset = 0;
+   LLVMValueRef res = LLVMConstNull(
+      LLVMVectorType(LLVMFloatType(), 4));
+   LLVMValueRef defaults[4];
+
+   defaults[0] = LLVMConstReal(LLVMFloatType(), 0);
+   defaults[1] = LLVMConstReal(LLVMFloatType(), 0);
+   defaults[2] = LLVMConstReal(LLVMFloatType(), 0);
+   defaults[3] = LLVMConstReal(LLVMFloatType(), 1);
+
+   for (i = 0; i < nr_components; ++i) {
+      LLVMValueRef src_index = LLVMConstInt(LLVMInt32Type(), offset, 0);
+      LLVMValueRef dst_index = LLVMConstInt(LLVMInt32Type(), i, 0);
+      LLVMValueRef src_tmp;
+      LLVMValueRef component;
+
+      src_tmp = LLVMBuildGEP(builder, ptr, &src_index, 1, "src_tmp");
+
+      /* convert src_tmp to float */
+      component = func(builder, src_tmp);
+
+      /* vec.comp = component */
+      res = LLVMBuildInsertElement(builder,
+                                   res,
+                                   component,
+                                   dst_index, "");
+      offset += val_size;
+   }
+   for (; i < 4; ++i) {
+      LLVMValueRef dst_index = LLVMConstInt(LLVMInt32Type(), i, 0);
+      res = LLVMBuildInsertElement(builder,
+                                   res,
+                                   defaults[i],
+                                   dst_index, "");
+   }
+   return res;
+}
+
+
+LLVMValueRef
+draw_llvm_translate_from(LLVMBuilderRef builder,
+                         LLVMValueRef vbuffer,
+                         enum pipe_format from_format)
+{
+   int i;
+   for (i = 0; i < Elements(translates); ++i) {
+      if (translates[i].format == from_format) {
+         /*LLVMTypeRef type = ll_type_to_llvm(translates[i].type);*/
+         return fetch(builder,
+                      vbuffer,
+                      ll_type_size(translates[i].type),
+                      translates[i].num_components,
+                      translates[i].from);
+      }
+   }
+   return LLVMGetUndef(LLVMVectorType(LLVMFloatType(), 4));
+}
diff --git a/src/gallium/auxiliary/draw/draw_pipe_aaline.c b/src/gallium/auxiliary/draw/draw_pipe_aaline.c
index f4615064e65..e96dbecd262 100644
--- a/src/gallium/auxiliary/draw/draw_pipe_aaline.c
+++ b/src/gallium/auxiliary/draw/draw_pipe_aaline.c
@@ -88,7 +88,7 @@ struct aaline_stage
    uint pos_slot;
 
    void *sampler_cso;
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct pipe_sampler_view *sampler_view;
    uint num_samplers;
    uint num_sampler_views;
@@ -396,7 +396,7 @@ aaline_create_texture(struct aaline_stage *aaline)
 {
    struct pipe_context *pipe = aaline->pipe;
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_texture texTemp;
+   struct pipe_resource texTemp;
    struct pipe_sampler_view viewTempl;
    uint level;
 
@@ -407,8 +407,9 @@ aaline_create_texture(struct aaline_stage *aaline)
    texTemp.width0 = 1 << MAX_TEXTURE_LEVEL;
    texTemp.height0 = 1 << MAX_TEXTURE_LEVEL;
    texTemp.depth0 = 1;
+   texTemp.bind = PIPE_BIND_SAMPLER_VIEW;
 
-   aaline->texture = screen->texture_create(screen, &texTemp);
+   aaline->texture = screen->resource_create(screen, &texTemp);
    if (!aaline->texture)
       return FALSE;
 
@@ -428,16 +429,23 @@ aaline_create_texture(struct aaline_stage *aaline)
     */
    for (level = 0; level <= MAX_TEXTURE_LEVEL; level++) {
       struct pipe_transfer *transfer;
+      struct pipe_box box;
       const uint size = u_minify(aaline->texture->width0, level);
       ubyte *data;
       uint i, j;
 
       assert(aaline->texture->width0 == aaline->texture->height0);
 
+      u_box_origin_2d( size, size, &box );
+
       /* This texture is new, no need to flush. 
        */
-      transfer = pipe->get_tex_transfer(pipe, aaline->texture, 0, level, 0,
-                                         PIPE_TRANSFER_WRITE, 0, 0, size, size);
+      transfer = pipe->get_transfer(pipe,
+				    aaline->texture,
+				    u_subresource(0, level), 
+				    PIPE_TRANSFER_WRITE,
+				    &box);
+
       data = pipe->transfer_map(pipe, transfer);
       if (data == NULL)
          return FALSE;
@@ -463,7 +471,7 @@ aaline_create_texture(struct aaline_stage *aaline)
 
       /* unmap */
       pipe->transfer_unmap(pipe, transfer);
-      pipe->tex_transfer_destroy(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
    }
    return TRUE;
 }
@@ -746,7 +754,7 @@ aaline_destroy(struct draw_stage *stage)
       aaline->pipe->delete_sampler_state(aaline->pipe, aaline->sampler_cso);
 
    if (aaline->texture)
-      pipe_texture_reference(&aaline->texture, NULL);
+      pipe_resource_reference(&aaline->texture, NULL);
 
    if (aaline->sampler_view) {
       pipe_sampler_view_reference(&aaline->sampler_view, NULL);
diff --git a/src/gallium/auxiliary/draw/draw_pipe_pstipple.c b/src/gallium/auxiliary/draw/draw_pipe_pstipple.c
index 794fd81d70f..ef30db094fe 100644
--- a/src/gallium/auxiliary/draw/draw_pipe_pstipple.c
+++ b/src/gallium/auxiliary/draw/draw_pipe_pstipple.c
@@ -75,7 +75,7 @@ struct pstip_stage
    struct draw_stage stage;
 
    void *sampler_cso;
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct pipe_sampler_view *sampler_view;
    uint num_samplers;
    uint num_sampler_views;
@@ -389,8 +389,8 @@ pstip_update_texture(struct pstip_stage *pstip)
     */
    pipe->flush( pipe, PIPE_FLUSH_TEXTURE_CACHE, NULL );
 
-   transfer = pipe->get_tex_transfer(pipe, pstip->texture, 0, 0, 0,
-				     PIPE_TRANSFER_WRITE, 0, 0, 32, 32);
+   transfer = pipe_get_transfer(pipe, pstip->texture, 0, 0, 0,
+				    PIPE_TRANSFER_WRITE, 0, 0, 32, 32);
    data = pipe->transfer_map(pipe, transfer);
 
    /*
@@ -414,7 +414,7 @@ pstip_update_texture(struct pstip_stage *pstip)
 
    /* unmap */
    pipe->transfer_unmap(pipe, transfer);
-   pipe->tex_transfer_destroy(pipe, transfer);
+   pipe->transfer_destroy(pipe, transfer);
 }
 
 
@@ -426,7 +426,7 @@ pstip_create_texture(struct pstip_stage *pstip)
 {
    struct pipe_context *pipe = pstip->pipe;
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_texture texTemp;
+   struct pipe_resource texTemp;
    struct pipe_sampler_view viewTempl;
 
    memset(&texTemp, 0, sizeof(texTemp));
@@ -436,8 +436,9 @@ pstip_create_texture(struct pstip_stage *pstip)
    texTemp.width0 = 32;
    texTemp.height0 = 32;
    texTemp.depth0 = 1;
+   texTemp.bind = PIPE_BIND_SAMPLER_VIEW;
 
-   pstip->texture = screen->texture_create(screen, &texTemp);
+   pstip->texture = screen->resource_create(screen, &texTemp);
    if (pstip->texture == NULL)
       return FALSE;
 
@@ -591,7 +592,7 @@ pstip_destroy(struct draw_stage *stage)
 
    pstip->pipe->delete_sampler_state(pstip->pipe, pstip->sampler_cso);
 
-   pipe_texture_reference(&pstip->texture, NULL);
+   pipe_resource_reference(&pstip->texture, NULL);
 
    if (pstip->sampler_view) {
       pipe_sampler_view_reference(&pstip->sampler_view, NULL);
diff --git a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c
index fdabce7d443..6864b4015b3 100644
--- a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c
+++ b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c
@@ -113,7 +113,10 @@ static void set_texcoords(const struct widepoint_stage *wide,
       /* put gl_PointCoord into the extra vertex slot */
       uint slot = wide->stage.draw->extra_shader_outputs.slot;
       v->data[slot][0] = tc[0];
-      v->data[slot][1] = tc[1];
+      if (wide->texcoord_mode == PIPE_SPRITE_COORD_LOWER_LEFT)
+         v->data[slot][1] = 1.0f - tc[1];
+      else
+         v->data[slot][1] = tc[1];
       v->data[slot][2] = 0.0F;
       v->data[slot][3] = 1.0F;
    }
diff --git a/src/gallium/auxiliary/draw/draw_private.h b/src/gallium/auxiliary/draw/draw_private.h
index 1e6e01af9e2..da64102d9d1 100644
--- a/src/gallium/auxiliary/draw/draw_private.h
+++ b/src/gallium/auxiliary/draw/draw_private.h
@@ -46,6 +46,10 @@
 
 #include "tgsi/tgsi_scan.h"
 
+#ifdef HAVE_LLVM
+#include <llvm-c/ExecutionEngine.h>
+#endif
+
 
 struct pipe_context;
 struct draw_vertex_shader;
@@ -237,9 +241,16 @@ struct draw_context
 
    unsigned instance_id;
 
+#ifdef HAVE_LLVM
+   LLVMExecutionEngineRef engine;
+#endif
    void *driver_private;
 };
 
+/*******************************************************************************
+ * Draw common initialization code
+ */
+boolean draw_init(struct draw_context *draw);
 
 /*******************************************************************************
  * Vertex shader code:
diff --git a/src/gallium/auxiliary/draw/draw_pt.c b/src/gallium/auxiliary/draw/draw_pt.c
index a8cdc57ad96..43f6c5650a0 100644
--- a/src/gallium/auxiliary/draw/draw_pt.c
+++ b/src/gallium/auxiliary/draw/draw_pt.c
@@ -140,7 +140,14 @@ boolean draw_pt_init( struct draw_context *draw )
    if (!draw->pt.middle.fetch_shade_emit)
       return FALSE;
 
-   draw->pt.middle.general = draw_pt_fetch_pipeline_or_emit( draw );
+#if HAVE_LLVM
+   draw->pt.middle.general = draw_pt_fetch_pipeline_or_emit_llvm( draw );
+#else
+   draw->pt.middle.general = NULL;
+#endif
+
+   if (!draw->pt.middle.general)
+      draw->pt.middle.general = draw_pt_fetch_pipeline_or_emit( draw );
    if (!draw->pt.middle.general)
       return FALSE;
 
diff --git a/src/gallium/auxiliary/draw/draw_pt.h b/src/gallium/auxiliary/draw/draw_pt.h
index d5e0d92a605..c2797a759ee 100644
--- a/src/gallium/auxiliary/draw/draw_pt.h
+++ b/src/gallium/auxiliary/draw/draw_pt.h
@@ -147,6 +147,7 @@ struct draw_pt_front_end *draw_pt_varray(struct draw_context *draw);
 struct draw_pt_middle_end *draw_pt_fetch_emit( struct draw_context *draw );
 struct draw_pt_middle_end *draw_pt_middle_fse( struct draw_context *draw );
 struct draw_pt_middle_end *draw_pt_fetch_pipeline_or_emit(struct draw_context *draw);
+struct draw_pt_middle_end *draw_pt_fetch_pipeline_or_emit_llvm(struct draw_context *draw);
 
 
 
diff --git a/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c b/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
new file mode 100644
index 00000000000..f71271bd915
--- /dev/null
+++ b/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
@@ -0,0 +1,440 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMWare, Inc.
+ * 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.
+ *
+ **************************************************************************/
+
+#include "util/u_math.h"
+#include "util/u_memory.h"
+#include "draw/draw_context.h"
+#include "draw/draw_vbuf.h"
+#include "draw/draw_vertex.h"
+#include "draw/draw_pt.h"
+#include "draw/draw_vs.h"
+#include "draw/draw_gs.h"
+#include "draw/draw_llvm.h"
+
+
+struct llvm_middle_end {
+   struct draw_pt_middle_end base;
+   struct draw_context *draw;
+
+   struct pt_emit *emit;
+   struct pt_fetch *fetch;
+   struct pt_post_vs *post_vs;
+
+
+   unsigned vertex_data_offset;
+   unsigned vertex_size;
+   unsigned prim;
+   unsigned opt;
+
+   struct draw_llvm *llvm;
+   struct draw_llvm_variant *variants;
+   struct draw_llvm_variant *current_variant;
+   int nr_variants;
+};
+
+
+static void
+llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
+                         unsigned prim,
+                         unsigned opt,
+                         unsigned *max_vertices )
+{
+   struct llvm_middle_end *fpme = (struct llvm_middle_end *)middle;
+   struct draw_context *draw = fpme->draw;
+   struct draw_vertex_shader *vs = draw->vs.vertex_shader;
+   struct draw_geometry_shader *gs = draw->gs.geometry_shader;
+   struct draw_llvm_variant_key key;
+   struct draw_llvm_variant *variant = NULL;
+   unsigned i;
+   unsigned instance_id_index = ~0;
+
+   /* Add one to num_outputs because the pipeline occasionally tags on
+    * an additional texcoord, eg for AA lines.
+    */
+   unsigned nr = MAX2( vs->info.num_inputs,
+		       vs->info.num_outputs + 1 );
+
+   /* Scan for instanceID system value.
+    */
+   for (i = 0; i < vs->info.num_inputs; i++) {
+      if (vs->info.input_semantic_name[i] == TGSI_SEMANTIC_INSTANCEID) {
+         instance_id_index = i;
+         break;
+      }
+   }
+
+   fpme->prim = prim;
+   fpme->opt = opt;
+
+   /* Always leave room for the vertex header whether we need it or
+    * not.  It's hard to get rid of it in particular because of the
+    * viewport code in draw_pt_post_vs.c.
+    */
+   fpme->vertex_size = sizeof(struct vertex_header) + nr * 4 * sizeof(float);
+
+
+
+   draw_pt_fetch_prepare( fpme->fetch,
+                          vs->info.num_inputs,
+                          fpme->vertex_size,
+                          instance_id_index );
+   if (opt & PT_SHADE) {
+      vs->prepare(vs, draw);
+      draw_geometry_shader_prepare(gs, draw);
+   }
+
+
+   /* XXX: it's not really gl rasterization rules we care about here,
+    * but gl vs dx9 clip spaces.
+    */
+   draw_pt_post_vs_prepare( fpme->post_vs,
+			    (boolean)draw->bypass_clipping,
+			    (boolean)(draw->identity_viewport),
+			    (boolean)draw->rasterizer->gl_rasterization_rules,
+			    (draw->vs.edgeflag_output ? true : false) );
+
+   if (!(opt & PT_PIPELINE)) {
+      draw_pt_emit_prepare( fpme->emit,
+			    prim,
+                            max_vertices );
+
+      *max_vertices = MAX2( *max_vertices,
+                            DRAW_PIPE_MAX_VERTICES );
+   }
+   else {
+      *max_vertices = DRAW_PIPE_MAX_VERTICES;
+   }
+
+   /* return even number */
+   *max_vertices = *max_vertices & ~1;
+
+   draw_llvm_make_variant_key(fpme->llvm, &key);
+
+   variant = fpme->variants;
+   while(variant) {
+      if(memcmp(&variant->key, &key, sizeof key) == 0)
+         break;
+
+      variant = variant->next;
+   }
+
+   if (!variant) {
+      variant = draw_llvm_prepare(fpme->llvm, nr);
+      variant->next = fpme->variants;
+      fpme->variants = variant;
+      ++fpme->nr_variants;
+   }
+   fpme->current_variant = variant;
+
+   /*XXX we only support one constant buffer */
+   fpme->llvm->jit_context.vs_constants =
+      draw->pt.user.vs_constants[0];
+   fpme->llvm->jit_context.gs_constants =
+      draw->pt.user.gs_constants[0];
+}
+
+
+
+static void llvm_middle_end_run( struct draw_pt_middle_end *middle,
+                                 const unsigned *fetch_elts,
+                                 unsigned fetch_count,
+                                 const ushort *draw_elts,
+                                 unsigned draw_count )
+{
+   struct llvm_middle_end *fpme = (struct llvm_middle_end *)middle;
+   struct draw_context *draw = fpme->draw;
+   struct draw_vertex_shader *vshader = draw->vs.vertex_shader;
+   struct draw_geometry_shader *gshader = draw->gs.geometry_shader;
+   unsigned opt = fpme->opt;
+   unsigned alloc_count = align( fetch_count, 4 );
+
+   struct vertex_header *pipeline_verts =
+      (struct vertex_header *)MALLOC(fpme->vertex_size * alloc_count);
+
+   if (!pipeline_verts) {
+      /* Not much we can do here - just skip the rendering.
+       */
+      assert(0);
+      return;
+   }
+
+   /* Fetch into our vertex buffer
+    */
+   draw_pt_fetch_run( fpme->fetch,
+		      fetch_elts,
+		      fetch_count,
+		      (char *)pipeline_verts );
+
+   /* Run the shader, note that this overwrites the data[] parts of
+    * the pipeline verts.  If there is no shader, eg if
+    * bypass_vs_clip_and_viewport, then the inputs == outputs, and are
+    * already in the correct place.*/
+   if (opt & PT_SHADE)
+   {
+      vshader->run_linear(vshader,
+                          (const float (*)[4])pipeline_verts->data,
+                          (      float (*)[4])pipeline_verts->data,
+                          draw->pt.user.vs_constants,
+                          fetch_count,
+                          fpme->vertex_size,
+                          fpme->vertex_size);
+      if (gshader)
+         draw_geometry_shader_run(gshader,
+                                  (const float (*)[4])pipeline_verts->data,
+                                  (      float (*)[4])pipeline_verts->data,
+                                  draw->pt.user.gs_constants,
+                                  fetch_count,
+                                  fpme->vertex_size,
+                                  fpme->vertex_size);
+   }
+
+   if (draw_pt_post_vs_run( fpme->post_vs,
+			    pipeline_verts,
+			    fetch_count,
+			    fpme->vertex_size ))
+   {
+      opt |= PT_PIPELINE;
+   }
+
+   /* Do we need to run the pipeline?
+    */
+   if (opt & PT_PIPELINE) {
+      draw_pipeline_run( fpme->draw,
+                         fpme->prim,
+                         pipeline_verts,
+                         fetch_count,
+                         fpme->vertex_size,
+                         draw_elts,
+                         draw_count );
+   }
+   else {
+      draw_pt_emit( fpme->emit,
+		    (const float (*)[4])pipeline_verts->data,
+		    fetch_count,
+		    fpme->vertex_size,
+		    draw_elts,
+		    draw_count );
+   }
+
+
+   FREE(pipeline_verts);
+}
+
+
+static void llvm_middle_end_linear_run( struct draw_pt_middle_end *middle,
+                                       unsigned start,
+                                       unsigned count)
+{
+   struct llvm_middle_end *fpme = (struct llvm_middle_end *)middle;
+   struct draw_context *draw = fpme->draw;
+   unsigned opt = fpme->opt;
+   unsigned alloc_count = align( count, 4 );
+
+   struct vertex_header *pipeline_verts =
+      (struct vertex_header *)MALLOC(fpme->vertex_size * alloc_count);
+
+   if (!pipeline_verts) {
+      /* Not much we can do here - just skip the rendering.
+       */
+      assert(0);
+      return;
+   }
+
+#if 0
+   debug_printf("#### Pipeline = %p (data = %p)\n",
+                pipeline_verts, pipeline_verts->data);
+#endif
+   fpme->current_variant->jit_func( &fpme->llvm->jit_context,
+                                    pipeline_verts,
+                                    (const char **)draw->pt.user.vbuffer,
+                                    start,
+                                    count,
+                                    fpme->vertex_size,
+                                    draw->pt.vertex_buffer );
+
+   if (draw_pt_post_vs_run( fpme->post_vs,
+			    pipeline_verts,
+			    count,
+			    fpme->vertex_size ))
+   {
+      opt |= PT_PIPELINE;
+   }
+
+   /* Do we need to run the pipeline?
+    */
+   if (opt & PT_PIPELINE) {
+      draw_pipeline_run_linear( fpme->draw,
+                                fpme->prim,
+                                pipeline_verts,
+                                count,
+                                fpme->vertex_size);
+   }
+   else {
+      draw_pt_emit_linear( fpme->emit,
+                           (const float (*)[4])pipeline_verts->data,
+                           fpme->vertex_size,
+                           count );
+   }
+
+   FREE(pipeline_verts);
+}
+
+
+
+static boolean
+llvm_middle_end_linear_run_elts( struct draw_pt_middle_end *middle,
+                                 unsigned start,
+                                 unsigned count,
+                                 const ushort *draw_elts,
+                                 unsigned draw_count )
+{
+   struct llvm_middle_end *fpme = (struct llvm_middle_end *)middle;
+   struct draw_context *draw = fpme->draw;
+   unsigned opt = fpme->opt;
+   unsigned alloc_count = align( count, 4 );
+
+   struct vertex_header *pipeline_verts =
+      (struct vertex_header *)MALLOC(fpme->vertex_size * alloc_count);
+
+   if (!pipeline_verts)
+      return FALSE;
+
+   fpme->current_variant->jit_func( &fpme->llvm->jit_context,
+                                    pipeline_verts,
+                                    (const char **)draw->pt.user.vbuffer,
+                                    start,
+                                    count,
+                                    fpme->vertex_size,
+                                    draw->pt.vertex_buffer );
+
+   if (draw_pt_post_vs_run( fpme->post_vs,
+			    pipeline_verts,
+			    count,
+			    fpme->vertex_size ))
+   {
+      opt |= PT_PIPELINE;
+   }
+
+   /* Do we need to run the pipeline?
+    */
+   if (opt & PT_PIPELINE) {
+      draw_pipeline_run( fpme->draw,
+                         fpme->prim,
+                         pipeline_verts,
+                         count,
+                         fpme->vertex_size,
+                         draw_elts,
+                         draw_count );
+   }
+   else {
+      draw_pt_emit( fpme->emit,
+		    (const float (*)[4])pipeline_verts->data,
+		    count,
+		    fpme->vertex_size,
+		    draw_elts,
+		    draw_count );
+   }
+
+   FREE(pipeline_verts);
+   return TRUE;
+}
+
+
+
+static void llvm_middle_end_finish( struct draw_pt_middle_end *middle )
+{
+   /* nothing to do */
+}
+
+static void llvm_middle_end_destroy( struct draw_pt_middle_end *middle )
+{
+   struct llvm_middle_end *fpme = (struct llvm_middle_end *)middle;
+
+   if (fpme->fetch)
+      draw_pt_fetch_destroy( fpme->fetch );
+
+   if (fpme->emit)
+      draw_pt_emit_destroy( fpme->emit );
+
+   if (fpme->post_vs)
+      draw_pt_post_vs_destroy( fpme->post_vs );
+
+   if (fpme->llvm)
+      draw_llvm_destroy( fpme->llvm );
+
+   FREE(middle);
+}
+
+
+struct draw_pt_middle_end *draw_pt_fetch_pipeline_or_emit_llvm( struct draw_context *draw )
+{
+   struct llvm_middle_end *fpme = 0;
+
+   if (!draw->engine)
+      return NULL;
+
+   fpme = CALLOC_STRUCT( llvm_middle_end );
+   if (!fpme)
+      goto fail;
+
+   fpme->base.prepare         = llvm_middle_end_prepare;
+   fpme->base.run             = llvm_middle_end_run;
+   fpme->base.run_linear      = llvm_middle_end_linear_run;
+   fpme->base.run_linear_elts = llvm_middle_end_linear_run_elts;
+   fpme->base.finish          = llvm_middle_end_finish;
+   fpme->base.destroy         = llvm_middle_end_destroy;
+
+   fpme->draw = draw;
+
+   fpme->fetch = draw_pt_fetch_create( draw );
+   if (!fpme->fetch)
+      goto fail;
+
+   fpme->post_vs = draw_pt_post_vs_create( draw );
+   if (!fpme->post_vs)
+      goto fail;
+
+   fpme->emit = draw_pt_emit_create( draw );
+   if (!fpme->emit)
+      goto fail;
+
+   fpme->llvm = draw_llvm_create(draw);
+   if (!fpme->llvm)
+      goto fail;
+
+   fpme->variants = NULL;
+   fpme->current_variant = NULL;
+   fpme->nr_variants = 0;
+
+   return &fpme->base;
+
+ fail:
+   if (fpme)
+      llvm_middle_end_destroy( &fpme->base );
+
+   return NULL;
+}
diff --git a/src/gallium/auxiliary/draw/draw_pt_post_vs.c b/src/gallium/auxiliary/draw/draw_pt_post_vs.c
index 9728d5c2bdf..5525dfc748d 100644
--- a/src/gallium/auxiliary/draw/draw_pt_post_vs.c
+++ b/src/gallium/auxiliary/draw/draw_pt_post_vs.c
@@ -108,6 +108,11 @@ static boolean post_vs_cliptest_viewport_gl( struct pt_post_vs *pvs,
    for (j = 0; j < count; j++) {
       float *position = out->data[pos];
 
+#if 0
+      debug_printf("%d) io = %p, data = %p = [%f, %f, %f, %f]\n",
+                   j, out, position, position[0], position[1], position[2], position[3]);
+#endif
+
       out->clip[0] = position[0];
       out->clip[1] = position[1];
       out->clip[2] = position[2];
diff --git a/src/gallium/auxiliary/draw/draw_vs_llvm.c b/src/gallium/auxiliary/draw/draw_vs_llvm.c
index 5f7a645f5d8..2a3b6b39b95 100644
--- a/src/gallium/auxiliary/draw/draw_vs_llvm.c
+++ b/src/gallium/auxiliary/draw/draw_vs_llvm.c
@@ -40,7 +40,7 @@
 
 #include "tgsi/tgsi_parse.h"
 
-#ifdef MESA_LLVM
+#ifdef HAVE_LLVM
 
 struct draw_llvm_vertex_shader {
    struct draw_vertex_shader base;
@@ -64,12 +64,8 @@ vs_llvm_run_linear( struct draw_vertex_shader *base,
 		   unsigned input_stride,
 		   unsigned output_stride )
 {
-   struct draw_llvm_vertex_shader *shader =
-      (struct draw_llvm_vertex_shader *)base;
 }
 
-
-
 static void
 vs_llvm_delete( struct draw_vertex_shader *base )
 {
@@ -90,6 +86,7 @@ struct draw_vertex_shader *
 draw_create_vs_llvm(struct draw_context *draw,
 		    const struct pipe_shader_state *templ)
 {
+#if 0
    struct draw_llvm_vertex_shader *vs;
 
    vs = CALLOC_STRUCT( draw_llvm_vertex_shader );
@@ -113,6 +110,8 @@ draw_create_vs_llvm(struct draw_context *draw,
    vs->machine = draw->vs.machine;
 
    return &vs->base;
+#endif
+   return NULL;
 }
 
 
diff --git a/src/gallium/auxiliary/gallivm/lp_bld.h b/src/gallium/auxiliary/gallivm/lp_bld.h
index 70a4960f913..2fa682f4009 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld.h
+++ b/src/gallium/auxiliary/gallivm/lp_bld.h
@@ -38,9 +38,9 @@
 #include <llvm-c/Core.h>  
 
 
-/** Set version to 0 if missing to avoid #ifdef HAVE_LLVM everywhere */
+/** Ensure HAVE_LLVM is set to avoid #ifdef HAVE_LLVM everywhere */
 #ifndef HAVE_LLVM
-#define HAVE_LLVM 0x0207
+#error "HAVE_LLVM should be set with LLVM's version number, e.g. (0x0207 for 2.7)"
 #endif
 
 
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_depth.c b/src/gallium/auxiliary/gallivm/lp_bld_depth.c
index c6d0e4bc04e..564ea2e3189 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_depth.c
+++ b/src/gallium/auxiliary/gallivm/lp_bld_depth.c
@@ -116,7 +116,7 @@ lp_build_stencil_test_single(struct lp_build_context *bld,
       stencilVals = LLVMBuildAnd(bld->builder, stencilVals, valuemask, "");
    }
 
-   res = lp_build_cmp(bld, stencil->func, stencilVals, stencilRef);
+   res = lp_build_cmp(bld, stencil->func, stencilRef, stencilVals);
 
    return res;
 }
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_flow.c b/src/gallium/auxiliary/gallivm/lp_bld_flow.c
index 106fc03e46f..e60ab4f6ba1 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_flow.c
+++ b/src/gallium/auxiliary/gallivm/lp_bld_flow.c
@@ -570,6 +570,35 @@ lp_build_loop_end(LLVMBuilderRef builder,
    LLVMPositionBuilderAtEnd(builder, after_block);
 }
 
+void
+lp_build_loop_end_cond(LLVMBuilderRef builder,
+                       LLVMValueRef end,
+                       LLVMValueRef step,
+                       int llvm_cond,
+                       struct lp_build_loop_state *state)
+{
+   LLVMBasicBlockRef block = LLVMGetInsertBlock(builder);
+   LLVMValueRef function = LLVMGetBasicBlockParent(block);
+   LLVMValueRef next;
+   LLVMValueRef cond;
+   LLVMBasicBlockRef after_block;
+
+   if (!step)
+      step = LLVMConstInt(LLVMTypeOf(end), 1, 0);
+
+   next = LLVMBuildAdd(builder, state->counter, step, "");
+
+   cond = LLVMBuildICmp(builder, llvm_cond, next, end, "");
+
+   after_block = LLVMAppendBasicBlock(function, "");
+
+   LLVMBuildCondBr(builder, cond, after_block, state->block);
+
+   LLVMAddIncoming(state->counter, &next, &block, 1);
+
+   LLVMPositionBuilderAtEnd(builder, after_block);
+}
+
 
 
 /*
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_flow.h b/src/gallium/auxiliary/gallivm/lp_bld_flow.h
index c2b50e1b602..745838570c8 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_flow.h
+++ b/src/gallium/auxiliary/gallivm/lp_bld_flow.h
@@ -124,6 +124,13 @@ lp_build_loop_end(LLVMBuilderRef builder,
                   LLVMValueRef step,
                   struct lp_build_loop_state *state);
 
+void
+lp_build_loop_end_cond(LLVMBuilderRef builder,
+                       LLVMValueRef end,
+                       LLVMValueRef step,
+                       int cond, /* LLVM condition */
+                       struct lp_build_loop_state *state);
+
 
 
 
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format.h b/src/gallium/auxiliary/gallivm/lp_bld_format.h
index 73ab6de3f21..bb1298ed3f4 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_format.h
+++ b/src/gallium/auxiliary/gallivm/lp_bld_format.h
@@ -80,4 +80,15 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
                          LLVMValueRef *rgba);
 
 
+void
+lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
+                        const struct util_format_description *format_desc,
+                        struct lp_type type,
+                        LLVMValueRef base_ptr,
+                        LLVMValueRef offsets,
+                        LLVMValueRef i,
+                        LLVMValueRef j,
+                        LLVMValueRef *rgba);
+
+
 #endif /* !LP_BLD_FORMAT_H */
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_format_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_format_soa.c
index 9f242844e5a..2b66162eb40 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_format_soa.c
+++ b/src/gallium/auxiliary/gallivm/lp_bld_format_soa.c
@@ -27,10 +27,14 @@
 
 
 #include "util/u_format.h"
+#include "util/u_memory.h"
+#include "util/u_string.h"
 
 #include "lp_bld_type.h"
 #include "lp_bld_const.h"
 #include "lp_bld_conv.h"
+#include "lp_bld_sample.h" /* for lp_build_gather */
+#include "lp_bld_init.h"
 #include "lp_bld_format.h"
 
 
@@ -109,7 +113,7 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
    unsigned start;
    unsigned chan;
 
-   /* FIXME: Support more pixel formats */
+   assert(format_desc->layout == UTIL_FORMAT_LAYOUT_PLAIN);
    assert(format_desc->block.width == 1);
    assert(format_desc->block.height == 1);
    assert(format_desc->block.bits <= type.width);
@@ -223,8 +227,17 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
          break;
 
       case UTIL_FORMAT_TYPE_FIXED:
-         assert(0);
-         input = lp_build_undef(type);
+         if (type.floating) {
+            double scale = 1.0 / ((1 << (format_desc->channel[chan].size/2)) - 1);
+            LLVMValueRef scale_val = lp_build_const_vec(type, scale);
+            input = LLVMBuildSIToFP(builder, input, lp_build_vec_type(type), "");
+            input = LLVMBuildMul(builder, input, scale_val, "");
+         }
+         else {
+            /* FIXME */
+            assert(0);
+            input = lp_build_undef(type);
+         }
          break;
 
       default:
@@ -240,3 +253,144 @@ lp_build_unpack_rgba_soa(LLVMBuilderRef builder,
 
    lp_build_format_swizzle_soa(format_desc, type, inputs, rgba);
 }
+
+
+/**
+ * Fetch a pixel into a SoA.
+ *
+ * i and j are the sub-block pixel coordinates.
+ */
+void
+lp_build_fetch_rgba_soa(LLVMBuilderRef builder,
+                        const struct util_format_description *format_desc,
+                        struct lp_type type,
+                        LLVMValueRef base_ptr,
+                        LLVMValueRef offset,
+                        LLVMValueRef i,
+                        LLVMValueRef j,
+                        LLVMValueRef *rgba)
+{
+
+   if (format_desc->layout == UTIL_FORMAT_LAYOUT_PLAIN &&
+       (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
+        format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS) &&
+       format_desc->block.width == 1 &&
+       format_desc->block.height == 1 &&
+       format_desc->block.bits <= type.width &&
+       (format_desc->channel[0].type != UTIL_FORMAT_TYPE_FLOAT ||
+        format_desc->channel[0].size == 32))
+   {
+      /*
+       * The packed pixel fits into an element of the destination format. Put
+       * the packed pixels into a vector and estract each component for all
+       * vector elements in parallel.
+       */
+
+      LLVMValueRef packed;
+
+      /*
+       * gather the texels from the texture
+       */
+      packed = lp_build_gather(builder,
+                               type.length,
+                               format_desc->block.bits,
+                               type.width,
+                               base_ptr, offset);
+
+      /*
+       * convert texels to float rgba
+       */
+      lp_build_unpack_rgba_soa(builder,
+                               format_desc,
+                               type,
+                               packed, rgba);
+   }
+   else {
+      /*
+       * Fallback to calling util_format_description::fetch_rgba_float for each
+       * pixel.
+       *
+       * This is definitely not the most efficient way of fetching pixels, as
+       * we miss the opportunity to do vectorization, but this it is a
+       * convenient for formats or scenarios for which there was no opportunity
+       * or incentive to optimize.
+       */
+
+      LLVMModuleRef module = LLVMGetGlobalParent(LLVMGetBasicBlockParent(LLVMGetInsertBlock(builder)));
+      char name[256];
+      LLVMValueRef function;
+      LLVMValueRef tmp;
+      unsigned k, chan;
+
+      assert(type.floating);
+
+      util_snprintf(name, sizeof name, "util_format_%s_fetch_rgba_float", format_desc->short_name);
+
+      /*
+       * Declare and bind format_desc->fetch_rgba_float().
+       */
+
+      function = LLVMGetNamedFunction(module, name);
+      if (!function) {
+         LLVMTypeRef ret_type;
+         LLVMTypeRef arg_types[4];
+         LLVMTypeRef function_type;
+
+         ret_type = LLVMVoidType();
+         arg_types[0] = LLVMPointerType(LLVMFloatType(), 0);
+         arg_types[1] = LLVMPointerType(LLVMInt8Type(), 0);
+         arg_types[3] = arg_types[2] = LLVMIntType(sizeof(unsigned) * 8);
+         function_type = LLVMFunctionType(ret_type, arg_types, Elements(arg_types), 0);
+         function = LLVMAddFunction(module, name, function_type);
+
+         LLVMSetFunctionCallConv(function, LLVMCCallConv);
+         LLVMSetLinkage(function, LLVMExternalLinkage);
+
+         assert(LLVMIsDeclaration(function));
+
+         LLVMAddGlobalMapping(lp_build_engine, function, format_desc->fetch_rgba_float);
+      }
+
+      for (chan = 0; chan < 4; ++chan) {
+         rgba[chan] = lp_build_undef(type);
+      }
+
+      tmp = LLVMBuildArrayAlloca(builder,
+                                 LLVMFloatType(),
+                                 LLVMConstInt(LLVMInt32Type(), 4, 0),
+                                 "");
+
+      /*
+       * Invoke format_desc->fetch_rgba_float() for each pixel and insert the result
+       * in the SoA vectors.
+       */
+
+      for(k = 0; k < type.length; ++k) {
+         LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), k, 0);
+         LLVMValueRef offset_elem;
+         LLVMValueRef ptr;
+         LLVMValueRef i_elem, j_elem;
+         LLVMValueRef args[4];
+
+         offset_elem = LLVMBuildExtractElement(builder, offset, index, "");
+         ptr = LLVMBuildGEP(builder, base_ptr, &offset_elem, 1, "");
+
+         i_elem = LLVMBuildExtractElement(builder, i, index, "");
+         j_elem = LLVMBuildExtractElement(builder, j, index, "");
+
+         args[0] = tmp;
+         args[1] = ptr;
+         args[2] = i_elem;
+         args[3] = j_elem;
+
+         LLVMBuildCall(builder, function, args, 4, "");
+
+         for (chan = 0; chan < 4; ++chan) {
+            LLVMValueRef chan_val = LLVMConstInt(LLVMInt32Type(), chan, 0),
+            tmp_chan = LLVMBuildGEP(builder, tmp, &chan_val, 1, "");
+            tmp_chan = LLVMBuildLoad(builder, tmp_chan, "");
+            rgba[chan] = LLVMBuildInsertElement(builder, rgba[chan], tmp_chan, index, "");
+         }
+      }
+   }
+}
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_init.cpp b/src/gallium/auxiliary/gallivm/lp_bld_init.c
index 067397a520b..de07c222a39 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_init.cpp
+++ b/src/gallium/auxiliary/gallivm/lp_bld_init.c
@@ -26,33 +26,42 @@
  **************************************************************************/
 
 
-#include <llvm/Config/config.h>
-#include <llvm/Target/TargetSelect.h>
-#include <llvm/Target/TargetOptions.h>
-
-#include "pipe/p_config.h"
-
+#include "pipe/p_compiler.h"
+#include "util/u_debug.h"
 #include "lp_bld_init.h"
 
 
-extern "C" void LLVMLinkInJIT();
+LLVMModuleRef lp_build_module = NULL;
+LLVMExecutionEngineRef lp_build_engine = NULL;
+LLVMModuleProviderRef lp_build_provider = NULL;
+LLVMTargetDataRef lp_build_target = NULL;
 
 
-extern "C" void
+void
 lp_build_init(void)
 {
-#if defined(PIPE_OS_WINDOWS) && defined(PIPE_ARCH_X86)
-   /*
-    * This is mis-detected on some hardware / software combinations.
-    */
-   llvm::StackAlignment = 4;
-   llvm::RealignStack = true;
-#endif
-
-   /* Same as LLVMInitializeNativeTarget(); */
-   llvm::InitializeNativeTarget();
+   LLVMInitializeNativeTarget();
 
    LLVMLinkInJIT();
+
+   if (!lp_build_module)
+      lp_build_module = LLVMModuleCreateWithName("gallivm");
+
+   if (!lp_build_provider)
+      lp_build_provider = LLVMCreateModuleProviderForExistingModule(lp_build_module);
+
+   if (!lp_build_engine) {
+      char *error = NULL;
+
+      if (LLVMCreateJITCompiler(&lp_build_engine, lp_build_provider, 1, &error)) {
+         _debug_printf("%s\n", error);
+         LLVMDisposeMessage(error);
+         assert(0);
+      }
+   }
+
+   if (!lp_build_target)
+      lp_build_target = LLVMGetExecutionEngineTargetData(lp_build_engine);
 }
 
 
@@ -64,6 +73,6 @@ lp_build_init(void)
  */
 #if defined(_MSC_VER) && defined(_DEBUG)
 #include <crtdefs.h>
-extern "C" _CRTIMP void __cdecl
+_CRTIMP void __cdecl
 _invalid_parameter_noinfo(void) {}
 #endif
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_init.h b/src/gallium/auxiliary/gallivm/lp_bld_init.h
index 07f50d1c433..0ec2afcd1be 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_init.h
+++ b/src/gallium/auxiliary/gallivm/lp_bld_init.h
@@ -30,18 +30,18 @@
 #define LP_BLD_INIT_H
 
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include "lp_bld.h"
+#include <llvm-c/ExecutionEngine.h>
 
 
-void
-lp_build_init(void);
+extern LLVMModuleRef lp_build_module;
+extern LLVMExecutionEngineRef lp_build_engine;
+extern LLVMModuleProviderRef lp_build_provider;
+extern LLVMTargetDataRef lp_build_target;
 
 
-#ifdef __cplusplus
-}
-#endif
+void
+lp_build_init(void);
 
 
 #endif /* !LP_BLD_INIT_H */
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.c b/src/gallium/auxiliary/gallivm/lp_bld_sample.c
index bb76ad4c6bf..eb75b9b393d 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_sample.c
+++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.c
@@ -51,9 +51,11 @@
  */
 void
 lp_sampler_static_state(struct lp_sampler_static_state *state,
-                        const struct pipe_texture *texture,
+                        const struct pipe_sampler_view *view,
                         const struct pipe_sampler_state *sampler)
 {
+   const struct pipe_resource *texture = view->texture;
+
    memset(state, 0, sizeof *state);
 
    if(!texture)
@@ -74,7 +76,7 @@ lp_sampler_static_state(struct lp_sampler_static_state *state,
     * regarding 1D/2D/3D/CUBE textures, wrap modes, etc.
     */
 
-   state->format            = texture->format;
+   state->format            = view->format;
    state->target            = texture->target;
    state->pot_width         = util_is_pot(texture->width0);
    state->pot_height        = util_is_pot(texture->height0);
@@ -104,6 +106,10 @@ lp_sampler_static_state(struct lp_sampler_static_state *state,
    state->border_color[1]   = sampler->border_color[1];
    state->border_color[2]   = sampler->border_color[2];
    state->border_color[3]   = sampler->border_color[3];
+
+   /*
+    * FIXME: Handle the remainder of pipe_sampler_view.
+    */
 }
 
 
@@ -157,9 +163,10 @@ lp_build_gather(LLVMBuilderRef builder,
 
 
 /**
- * Compute the offset of a pixel.
+ * Compute the offset of a pixel block.
  *
- * x, y, z, y_stride, z_stride are vectors
+ * x, y, z, y_stride, z_stride are vectors, and they refer to pixel blocks, as
+ * per format description, and not individual pixels.
  */
 LLVMValueRef
 lp_build_sample_offset(struct lp_build_context *bld,
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.h b/src/gallium/auxiliary/gallivm/lp_bld_sample.h
index 92f3c57435a..8c1af95c506 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_sample.h
+++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.h
@@ -38,7 +38,8 @@
 
 #include "gallivm/lp_bld.h"
 
-struct pipe_texture;
+struct pipe_resource;
+struct pipe_sampler_view;
 struct pipe_sampler_state;
 struct util_format_description;
 struct lp_type;
@@ -48,14 +49,14 @@ struct lp_build_context;
 /**
  * Sampler static state.
  *
- * These are the bits of state from pipe_texture and pipe_sampler_state that
+ * These are the bits of state from pipe_resource and pipe_sampler_state that
  * are embedded in the generated code.
  */
 struct lp_sampler_static_state
 {
    /* pipe_texture's state */
    enum pipe_format format;
-   unsigned target:2;
+   unsigned target:3;
    unsigned pot_width:1;
    unsigned pot_height:1;
    unsigned pot_depth:1;
@@ -78,7 +79,7 @@ struct lp_sampler_static_state
 /**
  * Sampler dynamic state.
  *
- * These are the bits of state from pipe_texture and pipe_sampler_state that
+ * These are the bits of state from pipe_resource and pipe_sampler_state that
  * are computed in runtime.
  *
  * There are obtained through callbacks, as we don't want to tie the texture
@@ -130,7 +131,7 @@ struct lp_sampler_dynamic_state
  */
 void
 lp_sampler_static_state(struct lp_sampler_static_state *state,
-                        const struct pipe_texture *texture,
+                        const struct pipe_sampler_view *view,
                         const struct pipe_sampler_state *sampler);
 
 
diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c
index 5b56f2cf3b7..395eaaba269 100644
--- a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c
+++ b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c
@@ -211,7 +211,7 @@ lp_build_sample_texel_soa(struct lp_build_sample_context *bld,
    const int dims = texture_dims(bld->static_state->target);
    struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
    LLVMValueRef offset;
-   LLVMValueRef packed;
+   LLVMValueRef i, j;
    LLVMValueRef use_border = NULL;
 
    /* use_border = x < 0 || x >= width || y < 0 || y >= height */
@@ -249,6 +249,43 @@ lp_build_sample_texel_soa(struct lp_build_sample_context *bld,
    }
 
    /*
+    * Describe the coordinates in terms of pixel blocks.
+    *
+    * TODO: pixel blocks are power of two. LLVM should convert rem/div to
+    * bit arithmetic. Verify this.
+    */
+
+   if (bld->format_desc->block.width == 1) {
+      i = bld->uint_coord_bld.zero;
+   }
+   else {
+      LLVMValueRef block_width = lp_build_const_int_vec(bld->uint_coord_bld.type, bld->format_desc->block.width);
+      i = LLVMBuildURem(bld->builder, x, block_width, "");
+      x = LLVMBuildUDiv(bld->builder, x, block_width, "");
+   }
+
+   if (bld->format_desc->block.height == 1) {
+      j = bld->uint_coord_bld.zero;
+   }
+   else {
+      LLVMValueRef block_height = lp_build_const_int_vec(bld->uint_coord_bld.type, bld->format_desc->block.height);
+      j = LLVMBuildURem(bld->builder, y, block_height, "");
+      y = LLVMBuildUDiv(bld->builder, y, block_height, "");
+   }
+
+   /* convert x,y,z coords to linear offset from start of texture, in bytes */
+   offset = lp_build_sample_offset(&bld->uint_coord_bld,
+                                   bld->format_desc,
+                                   x, y, z, y_stride, z_stride);
+
+   lp_build_fetch_rgba_soa(bld->builder,
+                           bld->format_desc,
+                           bld->texel_type,
+                           data_ptr, offset,
+                           i, j,
+                           texel);
+
+   /*
     * Note: if we find an app which frequently samples the texture border
     * we might want to implement a true conditional here to avoid sampling
     * the texture whenever possible (since that's quite a bit of code).
@@ -263,30 +300,6 @@ lp_build_sample_texel_soa(struct lp_build_sample_context *bld,
     * the texel color results with the border color.
     */
 
-   /* convert x,y,z coords to linear offset from start of texture, in bytes */
-   offset = lp_build_sample_offset(&bld->uint_coord_bld,
-                                   bld->format_desc,
-                                   x, y, z, y_stride, z_stride);
-
-   assert(bld->format_desc->block.width == 1);
-   assert(bld->format_desc->block.height == 1);
-   assert(bld->format_desc->block.bits <= bld->texel_type.width);
-
-   /* gather the texels from the texture */
-   packed = lp_build_gather(bld->builder,
-                            bld->texel_type.length,
-                            bld->format_desc->block.bits,
-                            bld->texel_type.width,
-                            data_ptr, offset);
-
-   texel[0] = texel[1] = texel[2] = texel[3] = NULL;
-
-   /* convert texels to float rgba */
-   lp_build_unpack_rgba_soa(bld->builder,
-                            bld->format_desc,
-                            bld->texel_type,
-                            packed, texel);
-
    if (use_border) {
       /* select texel color or border color depending on use_border */
       int chan;
diff --git a/src/gallium/auxiliary/pipebuffer/pb_buffer.h b/src/gallium/auxiliary/pipebuffer/pb_buffer.h
index 34b1b77df40..a6c50dcf0c1 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_buffer.h
+++ b/src/gallium/auxiliary/pipebuffer/pb_buffer.h
@@ -48,7 +48,6 @@
 #include "util/u_debug.h"
 #include "util/u_inlines.h"
 #include "pipe/p_defines.h"
-#include "pipe/p_state.h"
 
 
 #ifdef __cplusplus
@@ -58,8 +57,23 @@ extern "C" {
 
 struct pb_vtbl;
 struct pb_validate;
+struct pipe_fence_handle;
 
 
+#define PB_USAGE_CPU_READ  (1 << 0)
+#define PB_USAGE_CPU_WRITE (1 << 1)
+#define PB_USAGE_GPU_READ  (1 << 2)
+#define PB_USAGE_GPU_WRITE (1 << 3)
+#define PB_USAGE_UNSYNCHRONIZED (1 << 10)
+#define PB_USAGE_DONTBLOCK (1 << 9)
+
+#define PB_USAGE_CPU_READ_WRITE \
+   ( PB_USAGE_CPU_READ | PB_USAGE_CPU_WRITE )
+#define PB_USAGE_GPU_READ_WRITE \
+   ( PB_USAGE_GPU_READ | PB_USAGE_GPU_WRITE )
+#define PB_USAGE_WRITE \
+   ( PB_USAGE_CPU_WRITE | PB_USAGE_GPU_WRITE )
+
 /**
  * Buffer description.
  * 
@@ -83,7 +97,14 @@ typedef unsigned pb_size;
  */
 struct pb_buffer 
 {
-   struct pipe_buffer base;
+   /* This used to be a pipe_buffer struct:
+    */
+   struct {
+      struct pipe_reference  reference;
+      unsigned               size;
+      unsigned               alignment;
+      unsigned               usage;
+   } base;
 
    /**
     * Pointer to the virtual function table.
@@ -106,7 +127,7 @@ struct pb_vtbl
 
    /** 
     * Map the entire data store of a buffer object into the client's address.
-    * flags is bitmask of PIPE_BUFFER_FLAG_READ/WRITE. 
+    * flags is bitmask of PB_USAGE_CPU_READ/WRITE. 
     */
    void *(*map)( struct pb_buffer *buf, 
                  unsigned flags );
@@ -138,23 +159,6 @@ struct pb_vtbl
 };
 
 
-static INLINE struct pipe_buffer *
-pb_pipe_buffer( struct pb_buffer *pbuf )
-{
-   assert(pbuf);
-   return &pbuf->base;
-}
-
-
-static INLINE struct pb_buffer *
-pb_buffer( struct pipe_buffer *buf )
-{
-   assert(buf);
-   /* Could add a magic cookie check on debug builds.
-    */
-   return (struct pb_buffer *)buf;
-}
-
 
 /* Accessor functions for pb->vtbl:
  */
diff --git a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c
index d97f749b6ed..d6cf6405825 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c
@@ -135,7 +135,7 @@ struct fenced_buffer
    void *data;
 
    /**
-    * A bitmask of PIPE_BUFFER_USAGE_CPU/GPU_READ/WRITE describing the current
+    * A bitmask of PB_USAGE_CPU/GPU_READ/WRITE describing the current
     * buffer usage.
     */
    unsigned flags;
@@ -270,7 +270,7 @@ fenced_buffer_add_locked(struct fenced_manager *fenced_mgr,
                          struct fenced_buffer *fenced_buf)
 {
    assert(pipe_is_referenced(&fenced_buf->base.base.reference));
-   assert(fenced_buf->flags & PIPE_BUFFER_USAGE_GPU_READ_WRITE);
+   assert(fenced_buf->flags & PB_USAGE_GPU_READ_WRITE);
    assert(fenced_buf->fence);
 
    p_atomic_inc(&fenced_buf->base.base.reference.count);
@@ -299,7 +299,7 @@ fenced_buffer_remove_locked(struct fenced_manager *fenced_mgr,
    assert(fenced_buf->mgr == fenced_mgr);
 
    ops->fence_reference(ops, &fenced_buf->fence, NULL);
-   fenced_buf->flags &= ~PIPE_BUFFER_USAGE_GPU_READ_WRITE;
+   fenced_buf->flags &= ~PB_USAGE_GPU_READ_WRITE;
 
    assert(fenced_buf->head.prev);
    assert(fenced_buf->head.next);
@@ -377,7 +377,7 @@ fenced_buffer_finish_locked(struct fenced_manager *fenced_mgr,
 
          assert(!destroyed);
 
-         fenced_buf->flags &= ~PIPE_BUFFER_USAGE_GPU_READ_WRITE;
+         fenced_buf->flags &= ~PB_USAGE_GPU_READ_WRITE;
 
          ret = PIPE_OK;
       }
@@ -624,7 +624,7 @@ fenced_buffer_copy_storage_to_gpu_locked(struct fenced_buffer *fenced_buf)
    assert(fenced_buf->data);
    assert(fenced_buf->buffer);
 
-   map = pb_map(fenced_buf->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
+   map = pb_map(fenced_buf->buffer, PB_USAGE_CPU_WRITE);
    if(!map)
       return PIPE_ERROR;
 
@@ -644,7 +644,7 @@ fenced_buffer_copy_storage_to_cpu_locked(struct fenced_buffer *fenced_buf)
    assert(fenced_buf->data);
    assert(fenced_buf->buffer);
 
-   map = pb_map(fenced_buf->buffer, PIPE_BUFFER_USAGE_CPU_READ);
+   map = pb_map(fenced_buf->buffer, PB_USAGE_CPU_READ);
    if(!map)
       return PIPE_ERROR;
 
@@ -683,24 +683,24 @@ fenced_buffer_map(struct pb_buffer *buf,
 
    pipe_mutex_lock(fenced_mgr->mutex);
 
-   assert(!(flags & PIPE_BUFFER_USAGE_GPU_READ_WRITE));
+   assert(!(flags & PB_USAGE_GPU_READ_WRITE));
 
    /*
     * Serialize writes.
     */
-   while((fenced_buf->flags & PIPE_BUFFER_USAGE_GPU_WRITE) ||
-         ((fenced_buf->flags & PIPE_BUFFER_USAGE_GPU_READ) &&
-          (flags & PIPE_BUFFER_USAGE_CPU_WRITE))) {
+   while((fenced_buf->flags & PB_USAGE_GPU_WRITE) ||
+         ((fenced_buf->flags & PB_USAGE_GPU_READ) &&
+          (flags & PB_USAGE_CPU_WRITE))) {
 
       /* 
        * Don't wait for the GPU to finish accessing it, if blocking is forbidden.
        */
-      if((flags & PIPE_BUFFER_USAGE_DONTBLOCK) &&
+      if((flags & PB_USAGE_DONTBLOCK) &&
           ops->fence_signalled(ops, fenced_buf->fence, 0) != 0) {
          goto done;
       }
 
-      if (flags & PIPE_BUFFER_USAGE_UNSYNCHRONIZED) {
+      if (flags & PB_USAGE_UNSYNCHRONIZED) {
          break;
       }
 
@@ -721,7 +721,7 @@ fenced_buffer_map(struct pb_buffer *buf,
 
    if(map) {
       ++fenced_buf->mapcount;
-      fenced_buf->flags |= flags & PIPE_BUFFER_USAGE_CPU_READ_WRITE;
+      fenced_buf->flags |= flags & PB_USAGE_CPU_READ_WRITE;
    }
 
 done:
@@ -745,7 +745,7 @@ fenced_buffer_unmap(struct pb_buffer *buf)
          pb_unmap(fenced_buf->buffer);
       --fenced_buf->mapcount;
       if(!fenced_buf->mapcount)
-	 fenced_buf->flags &= ~PIPE_BUFFER_USAGE_CPU_READ_WRITE;
+	 fenced_buf->flags &= ~PB_USAGE_CPU_READ_WRITE;
    }
 
    pipe_mutex_unlock(fenced_mgr->mutex);
@@ -771,9 +771,9 @@ fenced_buffer_validate(struct pb_buffer *buf,
       goto done;
    }
 
-   assert(flags & PIPE_BUFFER_USAGE_GPU_READ_WRITE);
-   assert(!(flags & ~PIPE_BUFFER_USAGE_GPU_READ_WRITE));
-   flags &= PIPE_BUFFER_USAGE_GPU_READ_WRITE;
+   assert(flags & PB_USAGE_GPU_READ_WRITE);
+   assert(!(flags & ~PB_USAGE_GPU_READ_WRITE));
+   flags &= PB_USAGE_GPU_READ_WRITE;
 
    /* Buffer cannot be validated in two different lists */
    if(fenced_buf->vl && fenced_buf->vl != vl) {
diff --git a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.h b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.h
index 0372f81d0a1..004c2b939a2 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.h
+++ b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.h
@@ -59,7 +59,6 @@ extern "C" {
 #endif
 
 
-struct pipe_buffer;
 struct pipe_fence_handle;
 
 
diff --git a/src/gallium/auxiliary/pipebuffer/pb_buffer_malloc.c b/src/gallium/auxiliary/pipebuffer/pb_buffer_malloc.c
index 6bdce5fcb06..b706f429be5 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_buffer_malloc.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_buffer_malloc.c
@@ -135,9 +135,9 @@ pb_malloc_buffer_create(pb_size size,
       return NULL;
 
    pipe_reference_init(&buf->base.base.reference, 1);
-   buf->base.base.alignment = desc->alignment;
    buf->base.base.usage = desc->usage;
    buf->base.base.size = size;
+   buf->base.base.alignment = desc->alignment;
    buf->base.vtbl = &malloc_buffer_vtbl;
 
    buf->data = align_malloc(size, desc->alignment < sizeof(void*) ? sizeof(void*) : desc->alignment);
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h b/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h
index 06669917ff6..cec2524da2b 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h
@@ -60,7 +60,6 @@ extern "C" {
 
 
 struct pb_desc;
-struct pipe_buffer;
 
 
 /** 
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_cache.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_cache.c
index 0f2ae05daed..88501e8d72d 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_cache.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_cache.c
@@ -242,7 +242,7 @@ pb_cache_is_buffer_compat(struct pb_cache_buffer *buf,
    if(!pb_check_usage(desc->usage, buf->base.base.usage))
       return FALSE;
 
-   map = pb_map(buf->buffer, PIPE_BUFFER_USAGE_DONTBLOCK);
+   map = pb_map(buf->buffer, PB_USAGE_DONTBLOCK);
    if (!map) {
       return FALSE;
    }
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_debug.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_debug.c
index a5dbded2bce..0dc5b31a754 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_debug.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_debug.c
@@ -158,7 +158,7 @@ pb_debug_buffer_fill(struct pb_debug_buffer *buf)
 {
    uint8_t *map;
    
-   map = pb_map(buf->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
+   map = pb_map(buf->buffer, PB_USAGE_CPU_WRITE);
    assert(map);
    if(map) {
       fill_random_pattern(map, buf->underflow_size);
@@ -180,8 +180,8 @@ pb_debug_buffer_check(struct pb_debug_buffer *buf)
    uint8_t *map;
    
    map = pb_map(buf->buffer,
-                PIPE_BUFFER_USAGE_CPU_READ |
-                PIPE_BUFFER_USAGE_UNSYNCHRONIZED);
+                PB_USAGE_CPU_READ |
+                PB_USAGE_UNSYNCHRONIZED);
    assert(map);
    if(map) {
       boolean underflow, overflow;
@@ -382,8 +382,8 @@ pb_debug_manager_create_buffer(struct pb_manager *_mgr,
    
    real_size = mgr->underflow_size + size + mgr->overflow_size;
    real_desc = *desc;
-   real_desc.usage |= PIPE_BUFFER_USAGE_CPU_WRITE;
-   real_desc.usage |= PIPE_BUFFER_USAGE_CPU_READ;
+   real_desc.usage |= PB_USAGE_CPU_WRITE;
+   real_desc.usage |= PB_USAGE_CPU_READ;
 
    buf->buffer = mgr->provider->create_buffer(mgr->provider, 
                                               real_size, 
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_mm.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_mm.c
index 63195715d68..faf7c352674 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_mm.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_mm.c
@@ -268,8 +268,8 @@ mm_bufmgr_create_from_buffer(struct pb_buffer *buffer,
    mm->buffer = buffer; 
 
    mm->map = pb_map(mm->buffer, 
-		    PIPE_BUFFER_USAGE_CPU_READ |
-		    PIPE_BUFFER_USAGE_CPU_WRITE);
+		    PB_USAGE_CPU_READ |
+		    PB_USAGE_CPU_WRITE);
    if(!mm->map)
       goto failure;
 
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_ondemand.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_ondemand.c
index cb32d251367..31f1ebbeb7c 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_ondemand.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_ondemand.c
@@ -150,7 +150,7 @@ pb_ondemand_buffer_instantiate(struct pb_ondemand_buffer *buf)
       if(!buf->buffer)
          return PIPE_ERROR_OUT_OF_MEMORY;
       
-      map = pb_map(buf->buffer, PIPE_BUFFER_USAGE_CPU_READ);
+      map = pb_map(buf->buffer, PB_USAGE_CPU_READ);
       if(!map) {
          pb_reference(&buf->buffer, NULL);
          return PIPE_ERROR;
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_pool.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_pool.c
index fea234ae8c7..fdcce428784 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_pool.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_pool.c
@@ -284,8 +284,8 @@ pool_bufmgr_create(struct pb_manager *provider,
       goto failure;
 
    pool->map = pb_map(pool->buffer,
-                          PIPE_BUFFER_USAGE_CPU_READ |
-                          PIPE_BUFFER_USAGE_CPU_WRITE);
+                          PB_USAGE_CPU_READ |
+                          PB_USAGE_CPU_WRITE);
    if(!pool->map)
       goto failure;
 
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_slab.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_slab.c
index 24e2820f881..7a3305aaf37 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_slab.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_slab.c
@@ -315,8 +315,8 @@ pb_slab_create(struct pb_slab_manager *mgr)
    /* Note down the slab virtual address. All mappings are accessed directly 
     * through this address so it is required that the buffer is pinned. */
    slab->virtual = pb_map(slab->bo, 
-                          PIPE_BUFFER_USAGE_CPU_READ |
-                          PIPE_BUFFER_USAGE_CPU_WRITE);
+                          PB_USAGE_CPU_READ |
+                          PB_USAGE_CPU_WRITE);
    if(!slab->virtual) {
       ret = PIPE_ERROR_OUT_OF_MEMORY;
       goto out_err1;
diff --git a/src/gallium/auxiliary/pipebuffer/pb_validate.c b/src/gallium/auxiliary/pipebuffer/pb_validate.c
index 903afc749d3..b585422460b 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_validate.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_validate.c
@@ -69,9 +69,9 @@ pb_validate_add_buffer(struct pb_validate *vl,
    if(!buf)
       return PIPE_ERROR;
 
-   assert(flags & PIPE_BUFFER_USAGE_GPU_READ_WRITE);
-   assert(!(flags & ~PIPE_BUFFER_USAGE_GPU_READ_WRITE));
-   flags &= PIPE_BUFFER_USAGE_GPU_READ_WRITE;
+   assert(flags & PB_USAGE_GPU_READ_WRITE);
+   assert(!(flags & ~PB_USAGE_GPU_READ_WRITE));
+   flags &= PB_USAGE_GPU_READ_WRITE;
 
    /* We only need to store one reference for each buffer, so avoid storing
     * consecutive references for the same buffer. It might not be the most 
diff --git a/src/gallium/auxiliary/util/.gitignore b/src/gallium/auxiliary/util/.gitignore
index 53fe9b8a652..da74de623d7 100644
--- a/src/gallium/auxiliary/util/.gitignore
+++ b/src/gallium/auxiliary/util/.gitignore
@@ -1 +1,2 @@
+u_format_srgb.c
 u_format_table.c
diff --git a/src/gallium/auxiliary/util/u_atomic.h b/src/gallium/auxiliary/util/u_atomic.h
index 3c42477ad4f..a1568233906 100644
--- a/src/gallium/auxiliary/util/u_atomic.h
+++ b/src/gallium/auxiliary/util/u_atomic.h
@@ -29,7 +29,7 @@
 #define PIPE_ATOMIC_ASM_MSVC_X86                
 #elif (defined(PIPE_CC_GCC) && defined(PIPE_ARCH_X86))
 #define PIPE_ATOMIC_ASM_GCC_X86
-#elif defined(PIPE_CC_GCC)
+#elif defined(PIPE_CC_GCC) && (PIPE_CC_GCC_VERSION >= 401)
 #define PIPE_ATOMIC_GCC_INTRINSIC
 #else
 #error "Unsupported platform"
diff --git a/src/gallium/auxiliary/util/u_blit.c b/src/gallium/auxiliary/util/u_blit.c
index cd95f85b63b..7850f81e585 100644
--- a/src/gallium/auxiliary/util/u_blit.c
+++ b/src/gallium/auxiliary/util/u_blit.c
@@ -69,7 +69,7 @@ struct blit_state
    void *vs;
    void *fs[TGSI_WRITEMASK_XYZW + 1];
 
-   struct pipe_buffer *vbuf;  /**< quad vertices */
+   struct pipe_resource *vbuf;  /**< quad vertices */
    unsigned vbuf_slot;
 
    float vertices[4][2][4];   /**< vertex/texcoords for quad */
@@ -167,7 +167,7 @@ util_destroy_blit(struct blit_state *ctx)
       if (ctx->fs[i])
          pipe->delete_fs_state(pipe, ctx->fs[i]);
 
-   pipe_buffer_reference(&ctx->vbuf, NULL);
+   pipe_resource_reference(&ctx->vbuf, NULL);
 
    FREE(ctx);
 }
@@ -186,8 +186,7 @@ get_next_slot( struct blit_state *ctx )
 
    if (!ctx->vbuf) {
       ctx->vbuf = pipe_buffer_create(ctx->pipe->screen,
-                                     32,
-                                     PIPE_BUFFER_USAGE_VERTEX,
+                                     PIPE_BIND_VERTEX_BUFFER,
                                      max_slots * sizeof ctx->vertices);
    }
    
@@ -236,7 +235,7 @@ setup_vertex_data_tex(struct blit_state *ctx,
 
    offset = get_next_slot( ctx );
 
-   pipe_buffer_write_nooverlap(ctx->pipe->screen, ctx->vbuf,
+   pipe_buffer_write_nooverlap(ctx->pipe, ctx->vbuf,
                                offset, sizeof(ctx->vertices), ctx->vertices);
 
    return offset;
@@ -304,9 +303,9 @@ util_blit_pixels_writemask(struct blit_state *ctx,
           filter == PIPE_TEX_MIPFILTER_LINEAR);
 
    assert(screen->is_format_supported(screen, src->format, PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_SAMPLER, 0));
+                                      PIPE_BIND_SAMPLER_VIEW, 0));
    assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_RENDER_TARGET, 0));
+                                      PIPE_BIND_RENDER_TARGET, 0));
 
    /* do the regions overlap? */
    overlap = util_same_surface(src, dst) &&
@@ -335,7 +334,7 @@ util_blit_pixels_writemask(struct blit_state *ctx,
    }
    
    assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_RENDER_TARGET, 0));
+                                      PIPE_BIND_RENDER_TARGET, 0));
 
    /* Create a temporary texture when src and dest alias or when src
     * is anything other than a single-level 2d texture.
@@ -346,8 +345,8 @@ util_blit_pixels_writemask(struct blit_state *ctx,
        src->texture->target != PIPE_TEXTURE_2D ||
        src->texture->last_level != 0)
    {
-      struct pipe_texture texTemp;
-      struct pipe_texture *tex;
+      struct pipe_resource texTemp;
+      struct pipe_resource *tex;
       struct pipe_sampler_view sv_templ;
       struct pipe_surface *texSurf;
       const int srcLeft = MIN2(srcX0, srcX1);
@@ -376,7 +375,7 @@ util_blit_pixels_writemask(struct blit_state *ctx,
       texTemp.height0 = srcH;
       texTemp.depth0 = 1;
 
-      tex = screen->texture_create(screen, &texTemp);
+      tex = screen->resource_create(screen, &texTemp);
       if (!tex)
          return;
 
@@ -384,12 +383,12 @@ util_blit_pixels_writemask(struct blit_state *ctx,
 
       sampler_view = ctx->pipe->create_sampler_view(ctx->pipe, tex, &sv_templ);
       if (!sampler_view) {
-         pipe_texture_reference(&tex, NULL);
+         pipe_resource_reference(&tex, NULL);
          return;
       }
 
       texSurf = screen->get_tex_surface(screen, tex, 0, 0, 0, 
-                                        PIPE_BUFFER_USAGE_GPU_WRITE);
+                                        PIPE_BIND_BLIT_DESTINATION);
 
       /* load temp texture */
       if (pipe->surface_copy) {
@@ -412,7 +411,7 @@ util_blit_pixels_writemask(struct blit_state *ctx,
       t0 = 0.0f;
       t1 = 1.0f;
 
-      pipe_texture_reference(&tex, NULL);
+      pipe_resource_reference(&tex, NULL);
    }
    else {
       pipe_sampler_view_reference(&sampler_view, src_sampler_view);
@@ -540,7 +539,7 @@ util_blit_pixels(struct blit_state *ctx,
  */
 void util_blit_flush( struct blit_state *ctx )
 {
-   pipe_buffer_reference(&ctx->vbuf, NULL);
+   pipe_resource_reference(&ctx->vbuf, NULL);
    ctx->vbuf_slot = 0;
 } 
 
@@ -566,7 +565,7 @@ util_blit_pixels_tex(struct blit_state *ctx,
    struct pipe_framebuffer_state fb;
    float s0, t0, s1, t1;
    unsigned offset;
-   struct pipe_texture *tex = src_sampler_view->texture;
+   struct pipe_resource *tex = src_sampler_view->texture;
 
    assert(filter == PIPE_TEX_MIPFILTER_NEAREST ||
           filter == PIPE_TEX_MIPFILTER_LINEAR);
@@ -582,7 +581,7 @@ util_blit_pixels_tex(struct blit_state *ctx,
 
    assert(ctx->pipe->screen->is_format_supported(ctx->pipe->screen, dst->format,
                                                  PIPE_TEXTURE_2D,
-                                                 PIPE_TEXTURE_USAGE_RENDER_TARGET,
+                                                 PIPE_BIND_RENDER_TARGET,
                                                  0));
 
    /* save state (restored below) */
diff --git a/src/gallium/auxiliary/util/u_blit.h b/src/gallium/auxiliary/util/u_blit.h
index 1ebe65b4558..464ff9aaced 100644
--- a/src/gallium/auxiliary/util/u_blit.h
+++ b/src/gallium/auxiliary/util/u_blit.h
@@ -37,7 +37,7 @@ extern "C" {
    
 struct pipe_context;
 struct pipe_surface;
-struct pipe_texture;
+struct pipe_resource;
 struct cso_context;
 
 
diff --git a/src/gallium/auxiliary/util/u_blitter.c b/src/gallium/auxiliary/util/u_blitter.c
index 1692987e8e3..f3b42f7bf9c 100644
--- a/src/gallium/auxiliary/util/u_blitter.c
+++ b/src/gallium/auxiliary/util/u_blitter.c
@@ -56,7 +56,7 @@ struct blitter_context_priv
    struct blitter_context blitter;
 
    struct pipe_context *pipe; /**< pipe context */
-   struct pipe_buffer *vbuf;  /**< quad */
+   struct pipe_resource *vbuf;  /**< quad */
 
    float vertices[4][2][4];   /**< {pos, color} or {pos, texcoord} */
 
@@ -168,6 +168,7 @@ struct blitter_context *util_blitter_create(struct pipe_context *pipe)
    sampler_state->wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
    sampler_state->wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
    sampler_state->wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+   sampler_state->normalized_coords = TRUE;
    /* The sampler state objects which sample from a specified mipmap level
     * are created on-demand. */
 
@@ -215,8 +216,7 @@ struct blitter_context *util_blitter_create(struct pipe_context *pipe)
 
    /* create the vertex buffer */
    ctx->vbuf = pipe_buffer_create(ctx->pipe->screen,
-                                  32,
-                                  PIPE_BUFFER_USAGE_VERTEX,
+                                  PIPE_BIND_VERTEX_BUFFER,
                                   sizeof(ctx->vertices));
 
    return &ctx->blitter;
@@ -259,7 +259,7 @@ void util_blitter_destroy(struct blitter_context *blitter)
       pipe_sampler_view_reference(&ctx->sampler_view, NULL);
    }
 
-   pipe_buffer_reference(&ctx->vbuf, NULL);
+   pipe_resource_reference(&ctx->vbuf, NULL);
    FREE(ctx);
 }
 
@@ -451,7 +451,7 @@ static void blitter_draw_quad(struct blitter_context_priv *ctx)
    struct pipe_context *pipe = ctx->pipe;
 
    /* write vertices and draw them */
-   pipe_buffer_write(pipe->screen, ctx->vbuf,
+   pipe_buffer_write(pipe, ctx->vbuf,
                      0, sizeof(ctx->vertices), ctx->vertices);
 
    util_draw_vertex_buffer(pipe, ctx->vbuf, 0, PIPE_PRIM_TRIANGLE_FAN,
@@ -714,8 +714,8 @@ static void util_blitter_overlap_copy(struct blitter_context *blitter,
    struct pipe_context *pipe = ctx->pipe;
    struct pipe_screen *screen = pipe->screen;
 
-   struct pipe_texture texTemp;
-   struct pipe_texture *texture;
+   struct pipe_resource texTemp;
+   struct pipe_resource *texture;
    struct pipe_surface *tex_surf;
 
    /* check whether the states are properly saved */
@@ -729,13 +729,13 @@ static void util_blitter_overlap_copy(struct blitter_context *blitter,
    texTemp.height0 = height;
    texTemp.depth0 = 1;
 
-   texture = screen->texture_create(screen, &texTemp);
+   texture = screen->resource_create(screen, &texTemp);
    if (!texture)
       return;
 
    tex_surf = screen->get_tex_surface(screen, texture, 0, 0, 0,
-				      PIPE_BUFFER_USAGE_GPU_READ | 
-				      PIPE_BUFFER_USAGE_GPU_WRITE);
+				      PIPE_BIND_BLIT_SOURCE | 
+				      PIPE_BIND_BLIT_DESTINATION);
 
    /* blit from the src to the temp */
    util_blitter_do_copy(blitter, tex_surf, 0, 0,
@@ -747,7 +747,7 @@ static void util_blitter_overlap_copy(struct blitter_context *blitter,
 			width, height,
 			FALSE);
    pipe_surface_reference(&tex_surf, NULL);
-   pipe_texture_reference(&texture, NULL);
+   pipe_resource_reference(&texture, NULL);
    blitter_restore_CSOs(ctx);
 }
 
@@ -781,8 +781,8 @@ void util_blitter_copy(struct blitter_context *blitter,
 		   
    is_depth = util_format_get_component_bits(src->format, UTIL_FORMAT_COLORSPACE_ZS, 0) != 0;
    is_stencil = util_format_get_component_bits(src->format, UTIL_FORMAT_COLORSPACE_ZS, 1) != 0;
-   dst_tex_usage = is_depth || is_stencil ? PIPE_TEXTURE_USAGE_DEPTH_STENCIL :
-                                            PIPE_TEXTURE_USAGE_RENDER_TARGET;
+   dst_tex_usage = is_depth || is_stencil ? PIPE_BIND_DEPTH_STENCIL :
+                                            PIPE_BIND_RENDER_TARGET;
 
    /* check if we can sample from and render to the surfaces */
    /* (assuming copying a stencil buffer is not possible) */
@@ -790,7 +790,7 @@ void util_blitter_copy(struct blitter_context *blitter,
        !screen->is_format_supported(screen, dst->format, dst->texture->target,
                                     dst_tex_usage, 0) ||
        !screen->is_format_supported(screen, src->format, src->texture->target,
-                                    PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                    PIPE_BIND_SAMPLER_VIEW, 0)) {
       util_surface_copy(pipe, FALSE, dst, dstx, dsty, src, srcx, srcy,
                         width, height);
       return;
@@ -827,7 +827,7 @@ void util_blitter_fill(struct blitter_context *blitter,
    /* check if we can render to the surface */
    if (util_format_is_depth_or_stencil(dst->format) || /* unlikely, but you never know */
        !screen->is_format_supported(screen, dst->format, dst->texture->target,
-                                    PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
+                                    PIPE_BIND_RENDER_TARGET, 0)) {
       util_surface_fill(pipe, dst, dstx, dsty, width, height, value);
       return;
    }
diff --git a/src/gallium/auxiliary/util/u_box.h b/src/gallium/auxiliary/util/u_box.h
new file mode 100644
index 00000000000..919967b55a7
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_box.h
@@ -0,0 +1,73 @@
+#ifndef UTIL_BOX_INLINES_H
+#define UTIL_BOX_INLINES_H
+
+#include "pipe/p_state.h"
+
+static INLINE
+void u_box_1d( unsigned x,
+	       unsigned w,
+	       struct pipe_box *box )
+{
+   box->x = x;
+   box->y = 0;
+   box->z = 0;
+   box->width = w;
+   box->height = 1;
+   box->depth = 1;
+}
+
+static INLINE
+void u_box_2d( unsigned x,
+	       unsigned y,
+	       unsigned w,
+	       unsigned h,
+	       struct pipe_box *box )
+{
+   box->x = x;
+   box->y = y;
+   box->z = 0;
+   box->width = w;
+   box->height = h;
+   box->depth = 1;
+}
+
+static INLINE
+void u_box_origin_2d( unsigned w,
+		      unsigned h,
+		      struct pipe_box *box )
+{
+   box->x = 0;
+   box->y = 0;
+   box->z = 0;
+   box->width = w;
+   box->height = h;
+   box->depth = 1;
+}
+
+static INLINE
+void u_box_2d_zslice( unsigned x,
+		      unsigned y,
+		      unsigned z,
+		      unsigned w,
+		      unsigned h,
+		      struct pipe_box *box )
+{
+   box->x = x;
+   box->y = y;
+   box->z = z;
+   box->width = w;
+   box->height = h;
+   box->depth = 1;
+}
+
+static INLINE
+struct pipe_subresource u_subresource( unsigned face,
+				       unsigned level )
+{
+   struct pipe_subresource subresource;
+   subresource.face = face;
+   subresource.level = level;
+   return subresource;
+}
+
+#endif
diff --git a/src/gallium/auxiliary/util/u_debug.c b/src/gallium/auxiliary/util/u_debug.c
index e997cfa8a38..dd044973f96 100644
--- a/src/gallium/auxiliary/util/u_debug.c
+++ b/src/gallium/auxiliary/util/u_debug.c
@@ -425,7 +425,7 @@ void debug_dump_surface(struct pipe_context *pipe,
 			const char *prefix,
                         struct pipe_surface *surface)     
 {
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct pipe_transfer *transfer;
    void *data;
 
@@ -440,7 +440,7 @@ void debug_dump_surface(struct pipe_context *pipe,
     */
    texture = surface->texture;
 
-   transfer = pipe->get_tex_transfer(pipe, texture, surface->face,
+   transfer = pipe_get_transfer(pipe, texture, surface->face,
 				     surface->level, surface->zslice,
 				     PIPE_TRANSFER_READ, 0, 0, surface->width,
 				     surface->height);
@@ -452,20 +452,20 @@ void debug_dump_surface(struct pipe_context *pipe,
    debug_dump_image(prefix, 
                     texture->format,
                     util_format_get_blocksize(texture->format), 
-                    util_format_get_nblocksx(texture->format, transfer->width),
-                    util_format_get_nblocksy(texture->format, transfer->height),
+                    util_format_get_nblocksx(texture->format, surface->width),
+                    util_format_get_nblocksy(texture->format, surface->height),
                     transfer->stride,
                     data);
    
    pipe->transfer_unmap(pipe, transfer);
 error:
-   pipe->tex_transfer_destroy(pipe, transfer);
+   pipe->transfer_destroy(pipe, transfer);
 }
 
 
 void debug_dump_texture(struct pipe_context *pipe,
                         const char *prefix,
-                        struct pipe_texture *texture)
+                        struct pipe_resource *texture)
 {
    struct pipe_surface *surface;
    struct pipe_screen *screen;
@@ -477,7 +477,7 @@ void debug_dump_texture(struct pipe_context *pipe,
 
    /* XXX for now, just dump image for face=0, level=0 */
    surface = screen->get_tex_surface(screen, texture, 0, 0, 0,
-                                     PIPE_TEXTURE_USAGE_SAMPLER);
+                                     PIPE_BIND_SAMPLER_VIEW);
    if (surface) {
       debug_dump_surface(pipe, prefix, surface);
       screen->tex_surface_destroy(surface);
@@ -523,16 +523,16 @@ debug_dump_surface_bmp(struct pipe_context *pipe,
 {
 #ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT
    struct pipe_transfer *transfer;
-   struct pipe_texture *texture = surface->texture;
+   struct pipe_resource *texture = surface->texture;
 
-   transfer = pipe->get_tex_transfer(pipe, texture, surface->face,
-				     surface->level, surface->zslice,
-				     PIPE_TRANSFER_READ, 0, 0, surface->width,
-				     surface->height);
+   transfer = pipe_get_transfer(pipe, texture, surface->face,
+				surface->level, surface->zslice,
+				PIPE_TRANSFER_READ, 0, 0, surface->width,
+				surface->height);
 
    debug_dump_transfer_bmp(pipe, filename, transfer);
 
-   pipe->tex_transfer_destroy(pipe, transfer);
+   pipe->transfer_destroy(pipe, transfer);
 #endif
 }
 
@@ -547,17 +547,20 @@ debug_dump_transfer_bmp(struct pipe_context *pipe,
    if (!transfer)
       goto error1;
 
-   rgba = MALLOC(transfer->width*transfer->height*4*sizeof(float));
+   rgba = MALLOC(transfer->box.width *
+		 transfer->box.height *
+		 transfer->box.depth *
+		 4*sizeof(float));
    if(!rgba)
       goto error1;
 
    pipe_get_tile_rgba(pipe, transfer, 0, 0,
-                      transfer->width, transfer->height,
+                      transfer->box.width, transfer->box.height,
                       rgba);
 
    debug_dump_float_rgba_bmp(filename,
-                             transfer->width, transfer->height,
-                             rgba, transfer->width);
+                             transfer->box.width, transfer->box.height,
+                             rgba, transfer->box.width);
 
    FREE(rgba);
 error1:
diff --git a/src/gallium/auxiliary/util/u_debug.h b/src/gallium/auxiliary/util/u_debug.h
index 98addeb372e..b6d0b508e30 100644
--- a/src/gallium/auxiliary/util/u_debug.h
+++ b/src/gallium/auxiliary/util/u_debug.h
@@ -315,7 +315,7 @@ debug_memory_end(unsigned long beginning);
 struct pipe_context;
 struct pipe_surface;
 struct pipe_transfer;
-struct pipe_texture;
+struct pipe_resource;
 
 void debug_dump_image(const char *prefix,
                       unsigned format, unsigned cpp,
@@ -327,7 +327,7 @@ void debug_dump_surface(struct pipe_context *pipe,
                         struct pipe_surface *surface);   
 void debug_dump_texture(struct pipe_context *pipe,
 			const char *prefix,
-                        struct pipe_texture *texture);
+                        struct pipe_resource *texture);
 void debug_dump_surface_bmp(struct pipe_context *pipe,
                             const char *filename,
                             struct pipe_surface *surface);
diff --git a/src/gallium/auxiliary/util/u_dl.c b/src/gallium/auxiliary/util/u_dl.c
index 37ed789f955..220860ebf4b 100644
--- a/src/gallium/auxiliary/util/u_dl.c
+++ b/src/gallium/auxiliary/util/u_dl.c
@@ -78,3 +78,16 @@ util_dl_close(struct util_dl_library *library)
    (void)library;
 #endif
 }
+
+
+const char *
+util_dl_error(void)
+{
+#if defined(PIPE_OS_UNIX)
+   return dlerror();
+#elif defined(PIPE_OS_WINDOWS)
+   return "unknown error";
+#else
+   return "unknown error";
+#endif
+}
diff --git a/src/gallium/auxiliary/util/u_dl.h b/src/gallium/auxiliary/util/u_dl.h
index 85296c58af6..2853b447c61 100644
--- a/src/gallium/auxiliary/util/u_dl.h
+++ b/src/gallium/auxiliary/util/u_dl.h
@@ -70,4 +70,11 @@ void
 util_dl_close(struct util_dl_library *library);
 
 
+/**
+ * Return most recent error message.
+ */
+const char *
+util_dl_error(void);
+
+
 #endif /* U_DL_H_ */
diff --git a/src/gallium/auxiliary/util/u_draw_quad.c b/src/gallium/auxiliary/util/u_draw_quad.c
index 8c194102bfc..b37b48b5aef 100644
--- a/src/gallium/auxiliary/util/u_draw_quad.c
+++ b/src/gallium/auxiliary/util/u_draw_quad.c
@@ -30,6 +30,7 @@
 #include "pipe/p_defines.h"
 #include "util/u_inlines.h"
 #include "util/u_draw_quad.h"
+#include "util/u_memory.h"
 
 
 /**
@@ -38,7 +39,7 @@
  */
 void 
 util_draw_vertex_buffer(struct pipe_context *pipe,
-                        struct pipe_buffer *vbuf,
+                        struct pipe_resource *vbuf,
                         uint offset,
                         uint prim_type,
                         uint num_verts,
@@ -66,60 +67,63 @@ util_draw_vertex_buffer(struct pipe_context *pipe,
 
 /**
  * Draw screen-aligned textured quad.
- * Note: this function allocs/destroys a vertex buffer and isn't especially
- * efficient.
+ * Note: this isn't especially efficient.
  */
 void 
 util_draw_texquad(struct pipe_context *pipe,
                   float x0, float y0, float x1, float y1, float z)
 {
-   struct pipe_buffer *vbuf;
-   uint numAttribs = 2, vertexBytes, i, j;
-
-   vertexBytes = 4 * (4 * numAttribs * sizeof(float));
-
-   /* XXX create one-time */
-   vbuf = pipe_buffer_create(pipe->screen, 32,
-                             PIPE_BUFFER_USAGE_VERTEX, vertexBytes);
-   if (vbuf) {
-      float *v = (float *) pipe_buffer_map(pipe->screen, vbuf,
-                                           PIPE_BUFFER_USAGE_CPU_WRITE);
-      if (v) {
-         /*
-          * Load vertex buffer
-          */
-         for (i = j = 0; i < 4; i++) {
-            v[j + 2] = z;   /* z */
-            v[j + 3] = 1.0; /* w */
-            v[j + 6] = 0.0; /* r */
-            v[j + 7] = 1.0; /* q */
-            j += 8;
-         }
-
-         v[0] = x0;
-         v[1] = y0;
-         v[4] = 0.0; /*s*/
-         v[5] = 0.0; /*t*/
-
-         v[8] = x1;
-         v[9] = y0;
-         v[12] = 1.0;
-         v[13] = 0.0;
-
-         v[16] = x1;
-         v[17] = y1;
-         v[20] = 1.0;
-         v[21] = 1.0;
-
-         v[24] = x0;
-         v[25] = y1;
-         v[28] = 0.0;
-         v[29] = 1.0;
-
-         pipe_buffer_unmap(pipe->screen, vbuf);
-         util_draw_vertex_buffer(pipe, vbuf, 0, PIPE_PRIM_TRIANGLE_FAN, 4, 2);
-      }
-
-      pipe_buffer_reference(&vbuf, NULL);
+   uint numAttribs = 2, i, j;
+   uint vertexBytes = 4 * (4 * numAttribs * sizeof(float));
+   struct pipe_resource *vbuf = NULL;  
+   uint *v = NULL;
+
+   v = MALLOC(vertexBytes);
+   if (v == NULL)
+      goto out;
+
+   /*
+    * Load vertex buffer
+    */
+   for (i = j = 0; i < 4; i++) {
+      v[j + 2] = z;   /* z */
+      v[j + 3] = 1.0; /* w */
+      v[j + 6] = 0.0; /* r */
+      v[j + 7] = 1.0; /* q */
+      j += 8;
    }
+
+   v[0] = x0;
+   v[1] = y0;
+   v[4] = 0.0; /*s*/
+   v[5] = 0.0; /*t*/
+
+   v[8] = x1;
+   v[9] = y0;
+   v[12] = 1.0;
+   v[13] = 0.0;
+
+   v[16] = x1;
+   v[17] = y1;
+   v[20] = 1.0;
+   v[21] = 1.0;
+
+   v[24] = x0;
+   v[25] = y1;
+   v[28] = 0.0;
+   v[29] = 1.0;
+	 
+   vbuf = pipe_user_buffer_create(pipe->screen, v, vertexBytes,
+				  PIPE_BIND_VERTEX_BUFFER);
+   if (!vbuf) 
+      goto out;
+
+   util_draw_vertex_buffer(pipe, vbuf, 0, PIPE_PRIM_TRIANGLE_FAN, 4, 2);
+
+out:
+   if (vbuf)
+      pipe_resource_reference(&vbuf, NULL);
+   
+   if (v)
+      FREE(v);
 }
diff --git a/src/gallium/auxiliary/util/u_draw_quad.h b/src/gallium/auxiliary/util/u_draw_quad.h
index 00d3f5b7158..42eb1844289 100644
--- a/src/gallium/auxiliary/util/u_draw_quad.h
+++ b/src/gallium/auxiliary/util/u_draw_quad.h
@@ -33,11 +33,11 @@
 extern "C" {
 #endif
 
-struct pipe_buffer;
+struct pipe_resource;
 
 extern void 
 util_draw_vertex_buffer(struct pipe_context *pipe,
-                        struct pipe_buffer *vbuf, uint offset,
+                        struct pipe_resource *vbuf, uint offset,
                         uint num_attribs, uint num_verts, uint prim_type);
 
 
diff --git a/src/gallium/auxiliary/util/u_dump.h b/src/gallium/auxiliary/util/u_dump.h
index 379f18ef38b..bdc73ac47d2 100644
--- a/src/gallium/auxiliary/util/u_dump.h
+++ b/src/gallium/auxiliary/util/u_dump.h
@@ -92,7 +92,7 @@ util_dump_tex_filter(unsigned value, boolean shortened);
 
 void
 util_dump_template(struct os_stream *stream,
-                   const struct pipe_texture *templat);
+                   const struct pipe_resource *templat);
 
 void
 util_dump_rasterizer_state(struct os_stream *stream,
diff --git a/src/gallium/auxiliary/util/u_dump_state.c b/src/gallium/auxiliary/util/u_dump_state.c
index 52cf3ef4ce0..79fd38ef5c1 100644
--- a/src/gallium/auxiliary/util/u_dump_state.c
+++ b/src/gallium/auxiliary/util/u_dump_state.c
@@ -255,14 +255,14 @@ util_dump_enum_func(struct os_stream *stream, unsigned value)
 
 
 void
-util_dump_template(struct os_stream *stream, const struct pipe_texture *templat)
+util_dump_template(struct os_stream *stream, const struct pipe_resource *templat)
 {
    if(!templat) {
       util_dump_null(stream);
       return;
    }
 
-   util_dump_struct_begin(stream, "pipe_texture");
+   util_dump_struct_begin(stream, "pipe_resource");
 
    util_dump_member(stream, int, templat, target);
    util_dump_member(stream, format, templat, format);
@@ -280,7 +280,9 @@ util_dump_template(struct os_stream *stream, const struct pipe_texture *templat)
    util_dump_member_end(stream);
 
    util_dump_member(stream, uint, templat, last_level);
-   util_dump_member(stream, uint, templat, tex_usage);
+   util_dump_member(stream, uint, templat, _usage);
+   util_dump_member(stream, uint, templat, bind);
+   util_dump_member(stream, uint, templat, flags);
 
    util_dump_struct_end(stream);
 }
@@ -653,16 +655,13 @@ util_dump_transfer(struct os_stream *stream, const struct pipe_transfer *state)
 
    util_dump_struct_begin(stream, "pipe_transfer");
 
-   util_dump_member(stream, uint, state, width);
-   util_dump_member(stream, uint, state, height);
+   util_dump_member(stream, ptr, state, resource);
+//   util_dump_member(stream, uint, state, box);
 
    util_dump_member(stream, uint, state, stride);
-   util_dump_member(stream, uint, state, usage);
+   util_dump_member(stream, uint, state, slice_stride);
 
-   util_dump_member(stream, ptr, state, texture);
-   util_dump_member(stream, uint, state, face);
-   util_dump_member(stream, uint, state, level);
-   util_dump_member(stream, uint, state, zslice);
+//   util_dump_member(stream, ptr, state, data);
 
    util_dump_struct_end(stream);
 }
diff --git a/src/gallium/auxiliary/util/u_dynarray.h b/src/gallium/auxiliary/util/u_dynarray.h
new file mode 100644
index 00000000000..9d1c1713a7c
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_dynarray.h
@@ -0,0 +1,111 @@
+/**************************************************************************
+ *
+ * Copyright 2010 Luca Barbieri
+ *
+ * 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, sublicense, 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 NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) 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 U_DYNARRAY_H
+#define U_DYNARRAY_H
+
+#include "pipe/p_compiler.h"
+#include "util/u_memory.h"
+
+/* A zero-initialized version of this is guaranteed to represent an
+ * empty array.
+ *
+ * Also, size <= capacity and data != 0 if and only if capacity != 0
+ * capacity will always be the allocation size of data
+ */
+struct util_dynarray
+{
+   void *data;
+   unsigned size;
+   unsigned capacity;
+};
+
+static INLINE void
+util_dynarray_init(struct util_dynarray *buf)
+{
+   memset(buf, 0, sizeof(*buf));
+}
+
+static INLINE void
+util_dynarray_fini(struct util_dynarray *buf)
+{
+   if(buf->data)
+   {
+      FREE(buf->data);
+      util_dynarray_init(buf);
+   }
+}
+
+/* use util_dynarray_trim to reduce the allocated storage */
+static INLINE void *
+util_dynarray_resize(struct util_dynarray *buf, unsigned newsize)
+{
+   char *p;
+   if(newsize > buf->capacity)
+   {
+      unsigned newcap = buf->capacity << 1;
+      if(newsize > newcap)
+	      newcap = newsize;
+      buf->data = REALLOC(buf->data, buf->capacity, newcap);
+      buf->capacity = newcap;
+   }
+
+   p = (char *)buf->data + buf->size;
+   buf->size = newsize;
+   return p;
+}
+
+static INLINE void *
+util_dynarray_grow(struct util_dynarray *buf, int diff)
+{
+   return util_dynarray_resize(buf, buf->size + diff);
+}
+
+static INLINE void
+util_dynarray_trim(struct util_dynarray *buf)
+{
+   if (buf->size != buf->capacity) {
+      if (buf->size) {
+         buf->data = REALLOC(buf->data, buf->capacity, buf->size);
+         buf->capacity = buf->size;
+      }
+      else {
+         FREE(buf->data);
+         buf->data = 0;
+         buf->capacity = 0;
+      }
+   }
+}
+
+#define util_dynarray_append(buf, type, v) do {type __v = (v); memcpy(util_dynarray_grow((buf), sizeof(type)), &__v, sizeof(type));} while(0)
+#define util_dynarray_top_ptr(buf, type) (type*)((char*)(buf)->data + (buf)->size - sizeof(type))
+#define util_dynarray_top(buf, type) *util_dynarray_top_ptr(buf, type)
+#define util_dynarray_pop_ptr(buf, type) (type*)((char*)(buf)->data + ((buf)->size -= sizeof(type)))
+#define util_dynarray_pop(buf, type) *util_dynarray_pop_ptr(buf, type)
+#define util_dynarray_contains(buf, type) ((buf)->size >= sizeof(type))
+
+#endif /* U_DYNARRAY_H */
+
diff --git a/src/gallium/auxiliary/util/u_format.c b/src/gallium/auxiliary/util/u_format.c
index 112490f3b41..c50c807eb89 100644
--- a/src/gallium/auxiliary/util/u_format.c
+++ b/src/gallium/auxiliary/util/u_format.c
@@ -32,9 +32,10 @@
  * @author Jose Fonseca <jfonseca@vmware.com>
  */
 
+#include "u_math.h"
+#include "u_memory.h"
+#include "u_rect.h"
 #include "u_format.h"
-#include "u_format_s3tc.h"
-#include "u_half.h"
 
 
 void
@@ -55,7 +56,7 @@ util_format_read_4f(enum pipe_format format,
    src_row = (const uint8_t *)src + y*src_stride + x*(format_desc->block.bits/8);
    dst_row = dst;
 
-   format_desc->unpack_float(dst_row, dst_stride, src_row, src_stride, w, h);
+   format_desc->unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, w, h);
 }
 
 
@@ -77,7 +78,7 @@ util_format_write_4f(enum pipe_format format,
    dst_row = (uint8_t *)dst + y*dst_stride + x*(format_desc->block.bits/8);
    src_row = src;
 
-   format_desc->pack_float(dst_row, dst_stride, src_row, src_stride, w, h);
+   format_desc->pack_rgba_float(dst_row, dst_stride, src_row, src_stride, w, h);
 }
 
 
@@ -96,7 +97,7 @@ util_format_read_4ub(enum pipe_format format, uint8_t *dst, unsigned dst_stride,
    src_row = (const uint8_t *)src + y*src_stride + x*(format_desc->block.bits/8);
    dst_row = dst;
 
-   format_desc->unpack_8unorm(dst_row, dst_stride, src_row, src_stride, w, h);
+   format_desc->unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, w, h);
 }
 
 
@@ -115,5 +116,171 @@ util_format_write_4ub(enum pipe_format format, const uint8_t *src, unsigned src_
    dst_row = (uint8_t *)dst + y*dst_stride + x*(format_desc->block.bits/8);
    src_row = src;
 
-   format_desc->pack_8unorm(dst_row, dst_stride, src_row, src_stride, w, h);
+   format_desc->pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, w, h);
+}
+
+
+static INLINE boolean
+util_format_fits_8unorm(const struct util_format_description *format_desc)
+{
+   unsigned chan;
+
+   switch (format_desc->layout) {
+
+   case UTIL_FORMAT_LAYOUT_S3TC:
+   case UTIL_FORMAT_LAYOUT_RGTC:
+      /*
+       * These are straight forward.
+       */
+
+      return TRUE;
+
+   case UTIL_FORMAT_LAYOUT_PLAIN:
+      /*
+       * For these we can find a generic rule.
+       */
+
+      for (chan = 0; chan < format_desc->nr_channels; ++chan) {
+         switch (format_desc->channel[chan].type) {
+         case UTIL_FORMAT_TYPE_VOID:
+            break;
+         case UTIL_FORMAT_TYPE_UNSIGNED:
+            if (!format_desc->channel[chan].normalized ||
+                format_desc->channel[chan].size > 8) {
+               return FALSE;
+            }
+            break;
+         default:
+            return FALSE;
+         }
+      }
+      return TRUE;
+
+   default:
+      /*
+       * Handle all others on a case by case basis.
+       */
+
+      switch (format_desc->format) {
+      case PIPE_FORMAT_R1_UNORM:
+      case PIPE_FORMAT_UYVY:
+      case PIPE_FORMAT_YUYV:
+      case PIPE_FORMAT_R8G8_B8G8_UNORM:
+      case PIPE_FORMAT_G8R8_G8B8_UNORM:
+         return TRUE;
+
+      default:
+         return FALSE;
+      }
+   }
+}
+
+
+void
+util_format_translate(enum pipe_format dst_format,
+                      void *dst, unsigned dst_stride,
+                      unsigned dst_x, unsigned dst_y,
+                      enum pipe_format src_format,
+                      const void *src, unsigned src_stride,
+                      unsigned src_x, unsigned src_y,
+                      unsigned width, unsigned height)
+{
+   const struct util_format_description *dst_format_desc;
+   const struct util_format_description *src_format_desc;
+   uint8_t *dst_row;
+   const uint8_t *src_row;
+   unsigned y_step;
+   unsigned dst_step;
+   unsigned src_step;
+
+   if (dst_format == src_format) {
+      /*
+       * Trivial case.
+       */
+
+      util_copy_rect(dst, dst_format, dst_stride,  dst_x, dst_y,
+                     width, height, src, (int)src_stride,
+                     src_x, src_y);
+      return;
+   }
+
+   dst_format_desc = util_format_description(dst_format);
+   src_format_desc = util_format_description(src_format);
+
+   assert(dst_x % dst_format_desc->block.width == 0);
+   assert(dst_y % dst_format_desc->block.height == 0);
+   assert(src_x % src_format_desc->block.width == 0);
+   assert(src_y % src_format_desc->block.height == 0);
+
+   dst_row = (uint8_t *)dst + dst_y*dst_stride + dst_x*(dst_format_desc->block.bits/8);
+   src_row = (const uint8_t *)src + src_y*src_stride + src_x*(src_format_desc->block.bits/8);
+
+   /*
+    * This works because all pixel formats have pixel blocks with power of two
+    * sizes.
+    */
+
+   y_step = MAX2(dst_format_desc->block.height, src_format_desc->block.height);
+   assert(y_step % dst_format_desc->block.height == 0);
+   assert(y_step % src_format_desc->block.height == 0);
+
+   dst_step = y_step / dst_format_desc->block.height * dst_stride;
+   src_step = y_step / src_format_desc->block.height * src_stride;
+
+   /*
+    * TODO: double formats will loose precision
+    * TODO: Add a special case for formats that are mere swizzles of each other
+    */
+
+   if (util_format_fits_8unorm(src_format_desc) ||
+       util_format_fits_8unorm(dst_format_desc)) {
+      unsigned tmp_stride;
+      uint8_t *tmp_row;
+
+      tmp_stride = width * 4 * sizeof *tmp_row;
+      tmp_row = MALLOC(y_step * tmp_stride);
+      if (!tmp_row)
+         return;
+
+      while (height >= y_step) {
+         src_format_desc->unpack_rgba_8unorm(tmp_row, tmp_stride, src_row, src_stride, width, y_step);
+         dst_format_desc->pack_rgba_8unorm(dst_row, dst_stride, tmp_row, tmp_stride, width, y_step);
+
+         dst_row += dst_step;
+         src_row += src_step;
+         height -= y_step;
+      }
+
+      if (height) {
+         src_format_desc->unpack_rgba_8unorm(tmp_row, tmp_stride, src_row, src_stride, width, height);
+         dst_format_desc->pack_rgba_8unorm(dst_row, dst_stride, tmp_row, tmp_stride, width, height);
+      }
+
+      FREE(tmp_row);
+   }
+   else {
+      unsigned tmp_stride;
+      float *tmp_row;
+
+      tmp_stride = width * 4 * sizeof *tmp_row;
+      tmp_row = MALLOC(y_step * tmp_stride);
+      if (!tmp_row)
+         return;
+
+      while (height >= y_step) {
+         src_format_desc->unpack_rgba_float(tmp_row, tmp_stride, src_row, src_stride, width, y_step);
+         dst_format_desc->pack_rgba_float(dst_row, dst_stride, tmp_row, tmp_stride, width, y_step);
+
+         dst_row += dst_step;
+         src_row += src_step;
+         height -= y_step;
+      }
+
+      if (height) {
+         src_format_desc->unpack_rgba_float(tmp_row, tmp_stride, src_row, src_stride, width, height);
+         dst_format_desc->pack_rgba_float(dst_row, dst_stride, tmp_row, tmp_stride, width, height);
+      }
+
+      FREE(tmp_row);
+   }
 }
diff --git a/src/gallium/auxiliary/util/u_format.csv b/src/gallium/auxiliary/util/u_format.csv
index 0cf539247e7..016e73c4a1d 100644
--- a/src/gallium/auxiliary/util/u_format.csv
+++ b/src/gallium/auxiliary/util/u_format.csv
@@ -67,16 +67,21 @@ PIPE_FORMAT_A8R8G8B8_UNORM        , plain, 1, 1, un8 , un8 , un8 , un8 , yzwx, r
 PIPE_FORMAT_X8R8G8B8_UNORM        , plain, 1, 1, x8  , un8 , un8 , un8 , yzw1, rgb
 PIPE_FORMAT_A8B8G8R8_UNORM        , plain, 1, 1, un8 , un8 , un8 , un8 , wzyx, rgb
 PIPE_FORMAT_X8B8G8R8_UNORM        , plain, 1, 1, x8  , un8 , un8 , un8 , wzy1, rgb
+# PIPE_FORMAT_R8G8B8A8_UNORM is below
+PIPE_FORMAT_R8G8B8X8_UNORM        , plain, 1, 1, un8 , un8 , un8 , x8  , xyz1, rgb
 PIPE_FORMAT_B5G5R5X1_UNORM        , plain, 1, 1, un5 , un5 , un5 , x1  , zyx1, rgb
 PIPE_FORMAT_B5G5R5A1_UNORM        , plain, 1, 1, un5 , un5 , un5 , un1 , zyxw, rgb
 PIPE_FORMAT_B4G4R4A4_UNORM        , plain, 1, 1, un4 , un4 , un4 , un4 , zyxw, rgb
+PIPE_FORMAT_B4G4R4X4_UNORM        , plain, 1, 1, un4 , un4 , un4 , x4  , zyx1, rgb
 PIPE_FORMAT_B5G6R5_UNORM          , plain, 1, 1, un5 , un6 , un5 ,     , zyx1, rgb
 PIPE_FORMAT_R10G10B10A2_UNORM     , plain, 1, 1, un10, un10, un10, un2 , xyzw, rgb
+PIPE_FORMAT_B10G10R10A2_UNORM     , plain, 1, 1, un10, un10, un10, un2 , zyxw, rgb
 
 # Luminance/Intensity/Alpha formats
 PIPE_FORMAT_L8_UNORM              , plain, 1, 1, un8 ,     ,     ,     , xxx1, rgb
 PIPE_FORMAT_A8_UNORM              , plain, 1, 1, un8 ,     ,     ,     , 000x, rgb
 PIPE_FORMAT_I8_UNORM              , plain, 1, 1, un8 ,     ,     ,     , xxxx, rgb
+PIPE_FORMAT_L4A4_UNORM            , plain, 1, 1, un4 , un4 ,     ,     , xxxy, rgb
 PIPE_FORMAT_L8A8_UNORM            , plain, 1, 1, un8 , un8 ,     ,     , xxxy, rgb
 PIPE_FORMAT_L16_UNORM             , plain, 1, 1, un16,     ,     ,     , xxx1, rgb
 
@@ -94,6 +99,7 @@ PIPE_FORMAT_X8R8G8B8_SRGB         , plain, 1, 1, x8  , un8 , un8 , un8 , yzw1, s
 
 # Mixed-sign formats (typically used for bump map textures)
 PIPE_FORMAT_R8SG8SB8UX8U_NORM     , plain, 1, 1, sn8 , sn8 , un8 , x8  , xyz1, rgb
+PIPE_FORMAT_R10SG10SB10SA2U_NORM  , plain, 1, 1, sn10, sn10, sn10, un2 , xyzw, rgb
 PIPE_FORMAT_R5SG5SB6U_NORM        , plain, 1, 1, sn5 , sn5 , un6 ,     , xyz1, rgb
 
 # Depth-stencil formats
@@ -111,8 +117,6 @@ PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED , plain, 1, 1, f32,  u8  , x24 ,     , xy__,
 # http://www.fourcc.org/yuv.php#UYVY
 PIPE_FORMAT_UYVY                 , subsampled, 2, 1, x32 ,     ,     ,     , xyz1, yuv
 # http://www.fourcc.org/yuv.php#YUYV (a.k.a http://www.fourcc.org/yuv.php#YUY2)
-# XXX: u_tile.c's ycbcr_get_tile_rgba actually interprets it as VYUY but the 
-# intent should be to match D3DFMT_YUY2
 PIPE_FORMAT_YUYV                 , subsampled, 2, 1, x32 ,     ,     ,     , xyz1, yuv
 # same subsampling but with rgb channels
 PIPE_FORMAT_R8G8_B8G8_UNORM      , subsampled, 2, 1, x32 ,     ,     ,     , xyz1, rgb
@@ -123,6 +127,8 @@ PIPE_FORMAT_R10G10B10A2_USCALED   , plain,      1,  1, u10 , u10 , u10 , u2  , x
 PIPE_FORMAT_R11G11B10_FLOAT       , plain,      1,  1, f11 , f11 , f10 ,     , xyz1, rgb
 PIPE_FORMAT_R9G9B9E5_FLOAT        , other,      1,  1, x32 ,     ,     ,     , xyz1, rgb
 PIPE_FORMAT_R1_UNORM              , other,      8,  1, x8  ,     ,     ,     , x001, rgb
+# A.k.a. D3DFMT_CxV8U8
+PIPE_FORMAT_R8G8Bx_SNORM          , other,      1,  1, sn8 , sn8 ,     ,     , xyz1, rgb
 
 # Compressed formats
 # - http://en.wikipedia.org/wiki/S3_Texture_Compression
@@ -173,10 +179,6 @@ PIPE_FORMAT_R32_SSCALED           , plain, 1, 1, s32 ,     ,     ,     , x001, r
 PIPE_FORMAT_R32G32_SSCALED        , plain, 1, 1, s32 , s32 ,     ,     , xy01, rgb
 PIPE_FORMAT_R32G32B32_SSCALED     , plain, 1, 1, s32 , s32 , s32 ,     , xyz1, rgb
 PIPE_FORMAT_R32G32B32A32_SSCALED  , plain, 1, 1, s32 , s32 , s32 , s32 , xyzw, rgb
-PIPE_FORMAT_R32_FIXED             , plain, 1, 1, h32 ,     ,     ,     , x001, rgb
-PIPE_FORMAT_R32G32_FIXED          , plain, 1, 1, h32 , h32 ,     ,     , xy01, rgb
-PIPE_FORMAT_R32G32B32_FIXED       , plain, 1, 1, h32 , h32 , h32 ,     , xyz1, rgb
-PIPE_FORMAT_R32G32B32A32_FIXED    , plain, 1, 1, h32 , h32 , h32 , h32 , xyzw, rgb
 PIPE_FORMAT_R16_FLOAT             , plain, 1, 1, f16 ,     ,     ,     , x001, rgb
 PIPE_FORMAT_R16G16_FLOAT          , plain, 1, 1, f16 , f16 ,     ,     , xy01, rgb
 PIPE_FORMAT_R16G16B16_FLOAT       , plain, 1, 1, f16 , f16 , f16 ,     , xyz1, rgb
@@ -213,3 +215,18 @@ PIPE_FORMAT_R8_SSCALED            , plain, 1, 1, s8  ,     ,     ,     , x001, r
 PIPE_FORMAT_R8G8_SSCALED          , plain, 1, 1, s8  , s8  ,     ,     , xy01, rgb
 PIPE_FORMAT_R8G8B8_SSCALED        , plain, 1, 1, s8  , s8  , s8  ,     , xyz1, rgb
 PIPE_FORMAT_R8G8B8A8_SSCALED      , plain, 1, 1, s8  , s8  , s8  , s8  , xyzw, rgb
+
+# GL-specific vertex buffer element formats
+# A.k.a. GL_FIXED
+PIPE_FORMAT_R32_FIXED             , plain, 1, 1, h32 ,     ,     ,     , x001, rgb
+PIPE_FORMAT_R32G32_FIXED          , plain, 1, 1, h32 , h32 ,     ,     , xy01, rgb
+PIPE_FORMAT_R32G32B32_FIXED       , plain, 1, 1, h32 , h32 , h32 ,     , xyz1, rgb
+PIPE_FORMAT_R32G32B32A32_FIXED    , plain, 1, 1, h32 , h32 , h32 , h32 , xyzw, rgb
+
+# D3D9-specific vertex buffer element formats
+# See also:
+# - http://msdn.microsoft.com/en-us/library/bb172533.aspx
+# A.k.a. D3DDECLTYPE_UDEC3
+PIPE_FORMAT_R10G10B10X2_USCALED   , plain, 1, 1, u10 , u10 , u10  , x2 , xyz1, rgb
+# A.k.a. D3DDECLTYPE_DEC3N
+PIPE_FORMAT_R10G10B10X2_SNORM     , plain, 1, 1, sn10, sn10, sn10 , x2 , xyz1, rgb
diff --git a/src/gallium/auxiliary/util/u_format.h b/src/gallium/auxiliary/util/u_format.h
index 2ac3abab23a..5e3dc694be6 100644
--- a/src/gallium/auxiliary/util/u_format.h
+++ b/src/gallium/auxiliary/util/u_format.h
@@ -32,7 +32,6 @@
 
 #include "pipe/p_format.h"
 #include "util/u_debug.h"
-#include "util/u_format_s3tc.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -169,13 +168,6 @@ struct util_format_description
    unsigned is_mixed:1;
 
    /**
-    * Whether the pack/unpack functions actually work.
-    *
-    * Call util_format_is_supported instead of using this directly.
-    */
-   unsigned is_supported:1;
-
-   /**
     * Input channel description.
     *
     * Only valid for UTIL_FORMAT_LAYOUT_PLAIN formats.
@@ -200,43 +192,114 @@ struct util_format_description
 
    /**
     * Unpack pixel blocks to R8G8B8A8_UNORM.
+    *
+    * Only defined for non-depth-stencil formats.
     */
    void
-   (*unpack_8unorm)(uint8_t *dst, unsigned dst_stride,
-                    const uint8_t *src, unsigned src_stride,
-                    unsigned width, unsigned height);
+   (*unpack_rgba_8unorm)(uint8_t *dst, unsigned dst_stride,
+                         const uint8_t *src, unsigned src_stride,
+                         unsigned width, unsigned height);
 
    /**
     * Pack pixel blocks from R8G8B8A8_UNORM.
+    *
+    * Only defined for non-depth-stencil formats.
     */
    void
-   (*pack_8unorm)(uint8_t *dst, unsigned dst_stride,
-                  const uint8_t *src, unsigned src_stride,
-                  unsigned width, unsigned height);
+   (*pack_rgba_8unorm)(uint8_t *dst, unsigned dst_stride,
+                       const uint8_t *src, unsigned src_stride,
+                       unsigned width, unsigned height);
 
    /**
     * Unpack pixel blocks to R32G32B32A32_FLOAT.
+    *
+    * Only defined for non-depth-stencil formats.
     */
    void
-   (*unpack_float)(float *dst, unsigned dst_stride,
-                   const uint8_t *src, unsigned src_stride,
-                   unsigned width, unsigned height);
+   (*unpack_rgba_float)(float *dst, unsigned dst_stride,
+                        const uint8_t *src, unsigned src_stride,
+                        unsigned width, unsigned height);
 
    /**
     * Pack pixel blocks from R32G32B32A32_FLOAT.
+    *
+    * Only defined for non-depth-stencil formats.
     */
    void
-   (*pack_float)(uint8_t *dst, unsigned dst_stride,
-                 const float *src, unsigned src_stride,
-                 unsigned width, unsigned height);
+   (*pack_rgba_float)(uint8_t *dst, unsigned dst_stride,
+                      const float *src, unsigned src_stride,
+                      unsigned width, unsigned height);
 
    /**
     * Fetch a single pixel (i, j) from a block.
+    *
+    * Only defined for non-depth-stencil formats.
+    */
+   void
+   (*fetch_rgba_float)(float *dst,
+                       const uint8_t *src,
+                       unsigned i, unsigned j);
+
+   /**
+    * Unpack pixels to Z32_UNORM.
+    *
+    * Only defined for depth formats.
+    */
+   void
+   (*unpack_z_32unorm)(uint32_t *dst, unsigned dst_stride,
+                       const uint8_t *src, unsigned src_stride,
+                       unsigned width, unsigned height);
+
+   /**
+    * Pack pixels from Z32_FLOAT.
+    *
+    * Only defined for depth formats.
+    */
+   void
+   (*pack_z_32unorm)(uint8_t *dst, unsigned dst_stride,
+                     const uint32_t *src, unsigned src_stride,
+                     unsigned width, unsigned height);
+
+   /**
+    * Unpack pixels to Z32_FLOAT.
+    *
+    * Only defined for depth formats.
+    */
+   void
+   (*unpack_z_float)(float *dst, unsigned dst_stride,
+                     const uint8_t *src, unsigned src_stride,
+                     unsigned width, unsigned height);
+
+   /**
+    * Pack pixels from Z32_FLOAT.
+    *
+    * Only defined for depth formats.
+    */
+   void
+   (*pack_z_float)(uint8_t *dst, unsigned dst_stride,
+                   const float *src, unsigned src_stride,
+                   unsigned width, unsigned height);
+
+   /**
+    * Unpack pixels to S8_USCALED.
+    *
+    * Only defined for stencil formats.
     */
    void
-   (*fetch_float)(float *dst,
-                  const uint8_t *src,
-                  unsigned i, unsigned j);
+   (*unpack_s_8uscaled)(uint8_t *dst, unsigned dst_stride,
+                        const uint8_t *src, unsigned src_stride,
+                        unsigned width, unsigned height);
+
+   /**
+    * Pack pixels from S8_USCALED.
+    *
+    * Only defined for stencil formats.
+    */
+   void
+   (*pack_s_8uscaled)(uint8_t *dst, unsigned dst_stride,
+                      const uint8_t *src, unsigned src_stride,
+                      unsigned width, unsigned height);
+
 };
 
 
@@ -514,20 +577,6 @@ util_format_get_nr_components(enum pipe_format format)
  * Format access functions.
  */
 
-static INLINE boolean
-util_format_is_supported(enum pipe_format format)
-{
-   const struct util_format_description *desc = util_format_description(format);
-
-   if(!desc)
-      return FALSE;
-
-   if(desc->layout == UTIL_FORMAT_LAYOUT_S3TC)
-      util_format_s3tc_init();
-
-   return desc->is_supported;
-}
-
 void
 util_format_read_4f(enum pipe_format format,
                     float *dst, unsigned dst_stride, 
@@ -552,6 +601,19 @@ util_format_write_4ub(enum pipe_format format,
                       void *dst, unsigned dst_stride, 
                       unsigned x, unsigned y, unsigned w, unsigned h);
 
+/*
+ * Generic format conversion;
+ */
+
+void
+util_format_translate(enum pipe_format dst_format,
+                      void *dst, unsigned dst_stride,
+                      unsigned dst_x, unsigned dst_y,
+                      enum pipe_format src_format,
+                      const void *src, unsigned src_stride,
+                      unsigned src_x, unsigned src_y,
+                      unsigned width, unsigned height);
+
 #ifdef __cplusplus
 } // extern "C" {
 #endif
diff --git a/src/gallium/auxiliary/util/u_format_other.c b/src/gallium/auxiliary/util/u_format_other.c
new file mode 100644
index 00000000000..723fa8c3bf9
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_format_other.c
@@ -0,0 +1,267 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.
+ * 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 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
+ * THE COPYRIGHT HOLDERS, AUTHORS 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.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ **************************************************************************/
+
+
+#include "u_math.h"
+#include "u_format_other.h"
+
+
+void
+util_format_r9g9b9e5_float_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                        const uint8_t *src_row, unsigned src_stride,
+                                        unsigned width, unsigned height)
+{
+
+}
+
+void
+util_format_r9g9b9e5_float_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                      const float *src_row, unsigned src_stride,
+                                      unsigned width, unsigned height)
+{
+
+}
+
+void
+util_format_r9g9b9e5_float_fetch_rgba_float(float *dst, const uint8_t *src,
+                                       unsigned i, unsigned j)
+{
+
+}
+
+
+void
+util_format_r9g9b9e5_float_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                         const uint8_t *src_row, unsigned src_stride,
+                                         unsigned width, unsigned height)
+{
+
+}
+
+
+void
+util_format_r9g9b9e5_float_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+
+}
+
+
+void
+util_format_r1_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                  const uint8_t *src_row, unsigned src_stride,
+                                  unsigned width, unsigned height)
+{
+
+}
+
+
+void
+util_format_r1_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                const float *src_row, unsigned src_stride,
+                                unsigned width, unsigned height)
+{
+
+}
+
+
+void
+util_format_r1_unorm_fetch_rgba_float(float *dst, const uint8_t *src,
+                                 unsigned i, unsigned j)
+{
+
+}
+
+
+void
+util_format_r1_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                   const uint8_t *src_row, unsigned src_stride,
+                                   unsigned width, unsigned height)
+{
+
+}
+
+
+void
+util_format_r1_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                 const uint8_t *src_row, unsigned src_stride,
+                                 unsigned width, unsigned height)
+{
+}
+
+
+/*
+ * PIPE_FORMAT_R8G8Bx_SNORM
+ *
+ * A.k.a. D3DFMT_CxV8U8
+ */
+
+
+void
+util_format_r8g8bx_snorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                      const uint8_t *src_row, unsigned src_stride,
+                                      unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for(y = 0; y < height; y += 1) {
+      float *dst = dst_row;
+      const uint16_t *src = (const uint16_t *)src_row;
+      for(x = 0; x < width; x += 1) {
+         uint16_t value = *src++;
+         int16_t r, g;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         r = ((int16_t)(value << 8)) >> 8;
+         g = ((int16_t)(value << 0)) >> 8;
+
+         dst[0] = (float)(r * (1.0f/0x7f)); /* r */
+         dst[1] = (float)(g * (1.0f/0x7f)); /* g */
+         dst[2] = sqrtf(1.0f - dst[0] * dst[0] - dst[1] * dst[1]); /* b */
+         dst[3] = 1.0f; /* a */
+         dst += 4;
+      }
+      src_row += src_stride;
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_r8g8bx_snorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; y += 1) {
+      uint8_t *dst = dst_row;
+      const uint16_t *src = (const uint16_t *)src_row;
+      for(x = 0; x < width; x += 1) {
+         uint16_t value = *src++;
+         int16_t r, g;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         r = ((int16_t)(value << 8)) >> 8;
+         g = ((int16_t)(value << 0)) >> 8;
+
+         dst[0] = (uint8_t)(((uint16_t)MAX2(r, 0)) * 0xff / 0x7f); /* r */
+         dst[1] = (uint8_t)(((uint16_t)MAX2(g, 0)) * 0xff / 0x7f); /* g */
+         dst[2] = (uint8_t)sqrtf(0x7f*0x7f - r * r - g * g) * 0xff / 0x7f; /* b */
+         dst[3] = 255; /* a */
+         dst += 4;
+      }
+      src_row += src_stride;
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_r8g8bx_snorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                    const float *src_row, unsigned src_stride,
+                                    unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; y += 1) {
+      const float *src = src_row;
+      uint16_t *dst = (uint16_t *)dst_row;
+      for(x = 0; x < width; x += 1) {
+         uint16_t value = 0;
+
+         value |= (uint16_t)(((int8_t)(CLAMP(src[0], -1, 1) * 0x7f)) & 0xff) ;
+         value |= (uint16_t)((((int8_t)(CLAMP(src[1], -1, 1) * 0x7f)) & 0xff) << 8) ;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 4;
+      }
+      dst_row += dst_stride;
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_r8g8bx_snorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                     const uint8_t *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for(y = 0; y < height; y += 1) {
+      const uint8_t *src = src_row;
+      uint16_t *dst = (uint16_t *)dst_row;
+      for(x = 0; x < width; x += 1) {
+         uint16_t value = 0;
+
+         value |= src[0] >> 1;
+         value |= (src[1] >> 1) << 8;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 4;
+      }
+      dst_row += dst_stride;
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_r8g8bx_snorm_fetch_rgba_float(float *dst, const uint8_t *src,
+                                     unsigned i, unsigned j)
+{
+   uint16_t value = *(const uint16_t *)src;
+   int16_t r, g;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+   value = util_bswap32(value);
+#endif
+
+   r = ((int16_t)(value << 8)) >> 8;
+   g = ((int16_t)(value << 0)) >> 8;
+
+   dst[0] = r * (1.0f/0x7f); /* r */
+   dst[1] = g * (1.0f/0x7f); /* g */
+   dst[2] = sqrtf(1.0f - dst[0] * dst[0] - dst[1] * dst[1]); /* b */
+   dst[3] = 1.0f; /* a */
+}
diff --git a/src/gallium/auxiliary/util/u_format_other.h b/src/gallium/auxiliary/util/u_format_other.h
new file mode 100644
index 00000000000..98c97be33fa
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_format_other.h
@@ -0,0 +1,108 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.
+ * 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 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
+ * THE COPYRIGHT HOLDERS, AUTHORS 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.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ **************************************************************************/
+
+
+#ifndef U_FORMAT_OTHER_H_
+#define U_FORMAT_OTHER_H_
+
+
+#include "pipe/p_compiler.h"
+
+
+void
+util_format_r9g9b9e5_float_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                        const uint8_t *src_row, unsigned src_stride,
+                                        unsigned width, unsigned height);
+
+void
+util_format_r9g9b9e5_float_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                      const float *src_row, unsigned src_stride,
+                                      unsigned width, unsigned height);
+
+void
+util_format_r9g9b9e5_float_fetch_rgba_float(float *dst, const uint8_t *src,
+                                       unsigned i, unsigned j);
+
+void
+util_format_r9g9b9e5_float_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                         const uint8_t *src_row, unsigned src_stride,
+                                         unsigned width, unsigned height);
+
+void
+util_format_r9g9b9e5_float_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height);
+
+void
+util_format_r1_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                  const uint8_t *src_row, unsigned src_stride,
+                                  unsigned width, unsigned height);
+
+void
+util_format_r1_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                const float *src_row, unsigned src_stride,
+                                unsigned width, unsigned height);
+
+void
+util_format_r1_unorm_fetch_rgba_float(float *dst, const uint8_t *src,
+                                 unsigned i, unsigned j);
+
+void
+util_format_r1_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                   const uint8_t *src_row, unsigned src_stride,
+                                   unsigned width, unsigned height);
+
+void
+util_format_r1_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                 const uint8_t *src_row, unsigned src_stride,
+                                 unsigned width, unsigned height);
+
+void
+util_format_r8g8bx_snorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                      const uint8_t *src_row, unsigned src_stride,
+                                      unsigned width, unsigned height);
+
+void
+util_format_r8g8bx_snorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                    const float *src_row, unsigned src_stride,
+                                    unsigned width, unsigned height);
+
+void
+util_format_r8g8bx_snorm_fetch_rgba_float(float *dst, const uint8_t *src,
+                                     unsigned i, unsigned j);
+
+void
+util_format_r8g8bx_snorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height);
+
+void
+util_format_r8g8bx_snorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                     const uint8_t *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height);
+
+#endif /* U_FORMAT_OTHER_H_ */
diff --git a/src/gallium/auxiliary/util/u_format_pack.py b/src/gallium/auxiliary/util/u_format_pack.py
index 390be0c3b20..0c1bbc84c17 100644
--- a/src/gallium/auxiliary/util/u_format_pack.py
+++ b/src/gallium/auxiliary/util/u_format_pack.py
@@ -3,7 +3,7 @@
 '''
 /**************************************************************************
  *
- * Copyright 2009 VMware, Inc.
+ * Copyright 2009-2010 VMware, Inc.
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -46,21 +46,32 @@ from u_format_parse import *
 def generate_format_type(format):
     '''Generate a structure that describes the format.'''
 
+    assert format.layout == PLAIN
+    
     print 'union util_format_%s {' % format.short_name()
-    if format.is_bitmask() or format.short_name() == "r11g11b10_float":
+    
+    if format.block_size() in (8, 16, 32, 64):
         print '   uint%u_t value;' % (format.block_size(),)
+
+    use_bitfields = False
+    for channel in format.channels:
+        if channel.size % 8 or not is_pot(channel.size):
+            use_bitfields = True
+
     print '   struct {'
     for channel in format.channels:
-        if (format.is_bitmask() or format.is_mixed()) and not format.is_array() or format.short_name() == "r11g11b10_float":
+        if use_bitfields:
             if channel.type == VOID:
                 if channel.size:
                     print '      unsigned %s:%u;' % (channel.name, channel.size)
             elif channel.type == UNSIGNED:
                 print '      unsigned %s:%u;' % (channel.name, channel.size)
-            elif channel.type == SIGNED:
+            elif channel.type in (SIGNED, FIXED):
                 print '      int %s:%u;' % (channel.name, channel.size)
             elif channel.type == FLOAT:
-                if channel.size == 32:
+                if channel.size == 64:
+                    print '      double %s;' % (channel.name)
+                elif channel.size == 32:
                     print '      float %s;' % (channel.name)
                 else:
                     print '      unsigned %s:%u;' % (channel.name, channel.size)
@@ -91,20 +102,6 @@ def generate_format_type(format):
     print
 
 
-def generate_srgb_tables():
-    print 'static ubyte srgb_to_linear[256] = {'
-    for i in range(256):
-        print '   %s,' % (int(math.pow((i / 255.0 + 0.055) / 1.055, 2.4) * 255))
-    print '};'
-    print
-    print 'static ubyte linear_to_srgb[256] = {'
-    print '   0,'
-    for i in range(1, 256):
-        print '   %s,' % (int((1.055 * math.pow(i / 255.0, 0.41666) - 0.055) * 255))
-    print '};'
-    print
-
-
 def bswap_format(format):
     '''Generate a structure that describes the format.'''
 
@@ -125,12 +122,10 @@ def is_format_supported(format):
 
     for i in range(4):
         channel = format.channels[i]
-        if channel.type not in (VOID, UNSIGNED, SIGNED, FLOAT):
+        if channel.type not in (VOID, UNSIGNED, SIGNED, FLOAT, FIXED):
+            return False
+        if channel.type == FLOAT and channel.size not in (16, 32, 64):
             return False
-
-    # We can only read a color from a depth/stencil format if the depth channel is present
-    if format.colorspace == 'zs' and format.swizzles[0] == SWIZZLE_NONE:
-        return False
 
     return True
 
@@ -147,7 +142,7 @@ def native_type(format):
             channel = format.channels[0]
             if channel.type in (UNSIGNED, VOID):
                 return 'uint%u_t' % channel.size
-            elif channel.type == SIGNED:
+            elif channel.type in (SIGNED, FIXED):
                 return 'int%u_t' % channel.size
             elif channel.type == FLOAT:
                 if channel.size == 16:
@@ -193,12 +188,35 @@ def get_one_shift(type):
     assert False
 
 
-def get_one(type):
+def value_to_native(type, value):
+    '''Get the value of unity for this type.'''
+    if type.type == FLOAT:
+        return value
+    if type.type == FIXED:
+        return int(value * (1 << (type.size/2)))
+    if not type.norm:
+        return int(value)
+    if type.type == UNSIGNED:
+        return int(value * ((1 << type.size) - 1))
+    if type.type == SIGNED:
+        return int(value * ((1 << (type.size - 1)) - 1))
+    assert False
+
+
+def native_to_constant(type, value):
     '''Get the value of unity for this type.'''
-    if type.type == 'FLOAT' or not type.norm:
-        return 1
+    if type.type == FLOAT:
+        if type.size <= 32:
+            return "%ff" % value 
+        else:
+            return "%ff" % value 
     else:
-        return (1 << get_one_shift(type)) - 1
+        return str(int(value))
+
+
+def get_one(type):
+    '''Get the value of unity for this type.'''
+    return value_to_native(type, 1)
 
 
 def clamp_expr(src_channel, dst_channel, dst_native_type, value):
@@ -212,22 +230,63 @@ def clamp_expr(src_channel, dst_channel, dst_native_type, value):
     src_max = src_channel.max()
     dst_min = dst_channel.min()
     dst_max = dst_channel.max()
+    
+    # Translate the destination range to the src native value
+    dst_min_native = value_to_native(src_channel, dst_min)
+    dst_max_native = value_to_native(src_channel, dst_max)
 
     if src_min < dst_min and src_max > dst_max:
-        return 'CLAMP(%s, %s, %s)' % (value, dst_min, dst_max)
+        return 'CLAMP(%s, %s, %s)' % (value, dst_min_native, dst_max_native)
 
     if src_max > dst_max:
-        return 'MIN2(%s, %s)' % (value, dst_max)
+        return 'MIN2(%s, %s)' % (value, dst_max_native)
         
     if src_min < dst_min:
-        return 'MAX2(%s, %s)' % (value, dst_min)
+        return 'MAX2(%s, %s)' % (value, dst_min_native)
 
     return value
 
 
-def conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=True):
+def conversion_expr(src_channel, 
+                    dst_channel, dst_native_type, 
+                    value, 
+                    clamp=True, 
+                    src_colorspace = RGB, 
+                    dst_colorspace = RGB):
     '''Generate the expression to convert a value between two types.'''
 
+    if src_colorspace != dst_colorspace:
+        if src_colorspace == SRGB:
+            assert src_channel.type == UNSIGNED
+            assert src_channel.norm
+            assert src_channel.size == 8
+            assert dst_colorspace == RGB
+            if dst_channel.type == FLOAT:
+                return 'util_format_srgb_8unorm_to_linear_float(%s)' % value
+            else:
+                assert dst_channel.type == UNSIGNED
+                assert dst_channel.norm
+                assert dst_channel.size == 8
+                return 'util_format_srgb_to_linear_8unorm(%s)' % value
+        elif dst_colorspace == SRGB:
+            assert dst_channel.type == UNSIGNED
+            assert dst_channel.norm
+            assert dst_channel.size == 8
+            assert src_colorspace == RGB
+            if src_channel.type == FLOAT:
+                return 'util_format_linear_float_to_srgb_8unorm(%s)' % value
+            else:
+                assert src_channel.type == UNSIGNED
+                assert src_channel.norm
+                assert src_channel.size == 8
+                return 'util_format_linear_to_srgb_8unorm(%s)' % value
+        elif src_colorspace == ZS:
+            pass
+        elif dst_colorspace == ZS:
+            pass
+        else:
+            assert 0
+
     if src_channel == dst_channel:
         return value
 
@@ -240,6 +299,13 @@ def conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=True
         value = 'util_half_to_float(%s)' % value
         src_size = 32
 
+    # Special case for float <-> ubytes for more accurate results
+    # Done before clamping since these functions already take care of that
+    if src_type == UNSIGNED and src_norm and src_size == 8 and dst_channel.type == FLOAT and dst_channel.size == 32:
+        return 'ubyte_to_float(%s)' % value
+    if src_type == FLOAT and src_size == 32 and dst_channel.type == UNSIGNED and dst_channel.norm and dst_channel.size == 8:
+        return 'float_to_ubyte(%s)' % value
+
     if clamp:
         if dst_channel.type != FLOAT or src_type != FLOAT:
             value = clamp_expr(src_channel, dst_channel, dst_native_type, value)
@@ -267,7 +333,7 @@ def conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=True
 
     # Promote to either float or double
     if src_type != FLOAT:
-        if src_norm:
+        if src_norm or src_type == FIXED:
             one = get_one(src_channel)
             if src_size <= 23:
                 value = '(%s * (1.0f/0x%x))' % (value, one)
@@ -291,7 +357,7 @@ def conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=True
 
     # Convert double or float to non-float
     if dst_channel.type != FLOAT:
-        if dst_channel.norm:
+        if dst_channel.norm or dst_channel.type == FIXED:
             dst_one = get_one(dst_channel)
             if dst_channel.size <= 23:
                 value = '(%s * 0x%x)' % (value, dst_one)
@@ -324,7 +390,7 @@ def generate_unpack_kernel(format, dst_channel, dst_native_type):
 
     if format.is_bitmask():
         depth = format.block_size()
-        print '         uint%u_t value = *(uint%u_t *)src;' % (depth, depth) 
+        print '         uint%u_t value = *(const uint%u_t *)src;' % (depth, depth) 
 
         # Declare the intermediate variables
         for i in range(format.nr_channels()):
@@ -373,8 +439,15 @@ def generate_unpack_kernel(format, dst_channel, dst_native_type):
             swizzle = format.swizzles[i]
             if swizzle < 4:
                 src_channel = format.channels[swizzle]
+                src_colorspace = format.colorspace
+                if src_colorspace == SRGB and i == 3:
+                    # Alpha channel is linear
+                    src_colorspace = RGB
                 value = src_channel.name 
-                value = conversion_expr(src_channel, dst_channel, dst_native_type, value)
+                value = conversion_expr(src_channel, 
+                                        dst_channel, dst_native_type, 
+                                        value,
+                                        src_colorspace = src_colorspace)
             elif swizzle == SWIZZLE_0:
                 value = '0'
             elif swizzle == SWIZZLE_1:
@@ -383,11 +456,6 @@ def generate_unpack_kernel(format, dst_channel, dst_native_type):
                 value = '0'
             else:
                 assert False
-            if format.colorspace == ZS:
-                if i == 3:
-                    value = get_one(dst_channel)
-                elif i >= 1:
-                    value = 'dst[0]'
             print '         dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i])
         
     else:
@@ -399,8 +467,15 @@ def generate_unpack_kernel(format, dst_channel, dst_native_type):
             swizzle = format.swizzles[i]
             if swizzle < 4:
                 src_channel = format.channels[swizzle]
+                src_colorspace = format.colorspace
+                if src_colorspace == SRGB and i == 3:
+                    # Alpha channel is linear
+                    src_colorspace = RGB
                 value = 'pixel.chan.%s' % src_channel.name 
-                value = conversion_expr(src_channel, dst_channel, dst_native_type, value)
+                value = conversion_expr(src_channel, 
+                                        dst_channel, dst_native_type, 
+                                        value,
+                                        src_colorspace = src_colorspace)
             elif swizzle == SWIZZLE_0:
                 value = '0'
             elif swizzle == SWIZZLE_1:
@@ -409,11 +484,6 @@ def generate_unpack_kernel(format, dst_channel, dst_native_type):
                 value = '0'
             else:
                 assert False
-            if format.colorspace == ZS:
-                if i == 3:
-                    value = get_one(dst_channel)
-                elif i >= 1:
-                    value = 'dst[0]'
             print '         dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i])
     
 
@@ -437,12 +507,14 @@ def generate_pack_kernel(format, src_channel, src_native_type):
             dst_channel = format.channels[i]
             if inv_swizzle[i] is not None:
                 value ='src[%u]' % inv_swizzle[i]
-                value = conversion_expr(src_channel, dst_channel, dst_native_type, value)
-                if format.colorspace == ZS:
-                    if i == 3:
-                        value = get_one(dst_channel)
-                    elif i >= 1:
-                        value = '0'
+                dst_colorspace = format.colorspace
+                if dst_colorspace == SRGB and inv_swizzle[i] == 3:
+                    # Alpha channel is linear
+                    dst_colorspace = RGB
+                value = conversion_expr(src_channel, 
+                                        dst_channel, dst_native_type, 
+                                        value,
+                                        dst_colorspace = dst_colorspace)
                 if dst_channel.type in (UNSIGNED, SIGNED):
                     if shift + dst_channel.size < depth:
                         value = '(%s) & 0x%x' % (value, (1 << dst_channel.size) - 1)
@@ -473,13 +545,15 @@ def generate_pack_kernel(format, src_channel, src_native_type):
             width = dst_channel.size
             if inv_swizzle[i] is None:
                 continue
+            dst_colorspace = format.colorspace
+            if dst_colorspace == SRGB and inv_swizzle[i] == 3:
+                # Alpha channel is linear
+                dst_colorspace = RGB
             value ='src[%u]' % inv_swizzle[i]
-            value = conversion_expr(src_channel, dst_channel, dst_native_type, value)
-            if format.colorspace == ZS:
-                if i == 3:
-                    value = get_one(dst_channel)
-                elif i >= 1:
-                    value = '0'
+            value = conversion_expr(src_channel, 
+                                    dst_channel, dst_native_type, 
+                                    value, 
+                                    dst_colorspace = dst_colorspace)
             print '         pixel.chan.%s = %s;' % (dst_channel.name, value)
     
         bswap_format(format)
@@ -560,34 +634,40 @@ def generate_format_fetch(format, dst_channel, dst_native_type, dst_suffix):
     print
 
 
+def is_format_hand_written(format):
+    return format.layout in ('s3tc', 'subsampled', 'other') or format.colorspace == ZS
+
+
 def generate(formats):
     print
     print '#include "pipe/p_compiler.h"'
     print '#include "u_math.h"'
-    print '#include "u_format.h"'
     print '#include "u_half.h"'
+    print '#include "u_format.h"'
+    print '#include "u_format_other.h"'
+    print '#include "u_format_srgb.h"'
+    print '#include "u_format_yuv.h"'
+    print '#include "u_format_zs.h"'
     print
 
     for format in formats:
-        if is_format_supported(format):
-            generate_format_type(format)
+        if not is_format_hand_written(format):
+            
+            if is_format_supported(format):
+                generate_format_type(format)
 
-    channel = Channel(FLOAT, False, 32)
-    native_type = 'float'
-    suffix = 'float'
+            channel = Channel(FLOAT, False, 32)
+            native_type = 'float'
+            suffix = 'rgba_float'
 
-    for format in formats:
-        if format.layout != 's3tc':
             generate_format_unpack(format, channel, native_type, suffix)
             generate_format_pack(format, channel, native_type, suffix)
             generate_format_fetch(format, channel, native_type, suffix)
 
-    channel = Channel(UNSIGNED, True, 8)
-    native_type = 'uint8_t'
-    suffix = '8unorm'
+            channel = Channel(UNSIGNED, True, 8)
+            native_type = 'uint8_t'
+            suffix = 'rgba_8unorm'
 
-    for format in formats:
-        if format.layout != 's3tc':
             generate_format_unpack(format, channel, native_type, suffix)
             generate_format_pack(format, channel, native_type, suffix)
 
diff --git a/src/gallium/auxiliary/util/u_format_parse.py b/src/gallium/auxiliary/util/u_format_parse.py
index 03dc62d3294..7076c676aaf 100755
--- a/src/gallium/auxiliary/util/u_format_parse.py
+++ b/src/gallium/auxiliary/util/u_format_parse.py
@@ -73,6 +73,8 @@ class Channel:
         '''Maximum representable number.'''
         if self.type == FLOAT:
             return VERY_LARGE
+        if self.type == FIXED:
+            return (1 << (self.size/2)) - 1
         if self.norm:
             return 1
         if self.type == UNSIGNED:
@@ -85,6 +87,8 @@ class Channel:
         '''Minimum representable number.'''
         if self.type == FLOAT:
             return -VERY_LARGE
+        if self.type == FIXED:
+            return -(1 << (self.size/2))
         if self.type == UNSIGNED:
             return 0
         if self.norm:
@@ -134,6 +138,8 @@ class Format:
         return nr_channels
 
     def is_array(self):
+        if self.layout != PLAIN:
+            return False
         ref_channel = self.channels[0]
         for channel in self.channels[1:]:
             if channel.size and (channel.size != ref_channel.size or channel.size % 8):
@@ -141,6 +147,8 @@ class Format:
         return True
 
     def is_mixed(self):
+        if self.layout != PLAIN:
+            return False
         ref_channel = self.channels[0]
         if ref_channel.type == VOID:
            ref_channel = self.channels[1]
@@ -156,18 +164,24 @@ class Format:
         return is_pot(self.block_size())
 
     def is_int(self):
+        if self.layout != PLAIN:
+            return False
         for channel in self.channels:
             if channel.type not in (VOID, UNSIGNED, SIGNED):
                 return False
         return True
 
     def is_float(self):
+        if self.layout != PLAIN:
+            return False
         for channel in self.channels:
             if channel.type not in (VOID, FLOAT):
                 return False
         return True
 
     def is_bitmask(self):
+        if self.layout != PLAIN:
+            return False
         if self.block_size() not in (8, 16, 32):
             return False
         for channel in self.channels:
diff --git a/src/gallium/auxiliary/util/u_format_s3tc.c b/src/gallium/auxiliary/util/u_format_s3tc.c
index d48551f23ba..79dee2b4238 100644
--- a/src/gallium/auxiliary/util/u_format_s3tc.c
+++ b/src/gallium/auxiliary/util/u_format_s3tc.c
@@ -30,63 +30,66 @@
 
 #if defined(_WIN32) || defined(WIN32)
 #define DXTN_LIBNAME "dxtn.dll"
+#elif defined(__APPLE__)
+#define DXTN_LIBNAME "libtxc_dxtn.dylib"
 #else
 #define DXTN_LIBNAME "libtxc_dxtn.so"
 #endif
 
+
 static void
-util_format_dxt1_rgb_fetch_stub( int src_stride,
-                             const uint8_t *src,
-                             int col, int row,
-                             uint8_t *dst )
+util_format_dxt1_rgb_fetch_stub(int src_stride,
+                                const uint8_t *src,
+                                int col, int row,
+                                uint8_t *dst)
 {
-   util_format_s3tc_init();
-   util_format_dxt1_rgb_fetch(src_stride, src, col, row, dst);
+   assert(0);
 }
 
+
 static void
-util_format_dxt1_rgba_fetch_stub( int src_stride,
-                             const uint8_t *src,
-                             int col, int row,
-                             uint8_t *dst )
+util_format_dxt1_rgba_fetch_stub(int src_stride,
+                                 const uint8_t *src,
+                                 int col, int row,
+                                 uint8_t *dst )
 {
-   util_format_s3tc_init();
-   util_format_dxt1_rgba_fetch(src_stride, src, col, row, dst);
+   assert(0);
 }
 
+
 static void
-util_format_dxt3_rgba_fetch_stub( int src_stride,
-                             const uint8_t *src,
-                             int col, int row,
-                             uint8_t *dst )
+util_format_dxt3_rgba_fetch_stub(int src_stride,
+                                 const uint8_t *src,
+                                 int col, int row,
+                                 uint8_t *dst )
 {
-   util_format_s3tc_init();
-   util_format_dxt3_rgba_fetch(src_stride, src, col, row, dst);
+   assert(0);
 }
 
+
 static void
-util_format_dxt5_rgba_fetch_stub( int src_stride,
-                             const uint8_t *src,
-                             int col, int row,
-                             uint8_t *dst )
+util_format_dxt5_rgba_fetch_stub(int src_stride,
+                                 const uint8_t *src,
+                                 int col, int row,
+                                 uint8_t *dst )
 {
-   util_format_s3tc_init();
-   util_format_dxt5_rgba_fetch(src_stride, src, col, row, dst);
+   assert(0);
 }
 
-static
-void util_format_dxtn_pack_stub( int src_comps,
-                            int width, int height,
-                            const uint8_t *src,
-                            enum util_format_dxtn dst_format,
-                            uint8_t *dst,
-                            int dst_stride)
+
+static void
+util_format_dxtn_pack_stub(int src_comps,
+                           int width, int height,
+                           const uint8_t *src,
+                           enum util_format_dxtn dst_format,
+                           uint8_t *dst,
+                           int dst_stride)
 {
-   util_format_s3tc_init();
-   util_format_dxtn_pack_stub(src_comps, width, height, src, dst_format, dst, dst_stride);
+   assert(0);
 }
 
-boolean util_format_s3tc_inited = FALSE;
+
+boolean util_format_s3tc_enabled = FALSE;
 
 util_format_dxtn_fetch_t util_format_dxt1_rgb_fetch = util_format_dxt1_rgb_fetch_stub;
 util_format_dxtn_fetch_t util_format_dxt1_rgba_fetch = util_format_dxt1_rgba_fetch_stub;
@@ -95,68 +98,61 @@ util_format_dxtn_fetch_t util_format_dxt5_rgba_fetch = util_format_dxt5_rgba_fet
 
 util_format_dxtn_pack_t util_format_dxtn_pack = util_format_dxtn_pack_stub;
 
-static void
-nop(void)
-{}
-
-#define is_nop(f) ((void*)(f) == (void*)nop)
-
-static util_dl_proc
-get_proc_address_or_nop(struct util_dl_library *library,
-                         const char *procname)
-{
-   if(library) {
-      util_dl_proc proc = util_dl_get_proc_address(library, procname);
-      if(proc)
-         return proc;
-   }
-   return (util_dl_proc)nop;
-}
 
 void
-util_format_s3tc_do_init(void)
+util_format_s3tc_init(void)
 {
-   struct util_dl_library *library;
+   static boolean first_time = TRUE;
+   struct util_dl_library *library = NULL;
+   util_dl_proc fetch_2d_texel_rgb_dxt1;
+   util_dl_proc fetch_2d_texel_rgba_dxt1;
+   util_dl_proc fetch_2d_texel_rgba_dxt3;
+   util_dl_proc fetch_2d_texel_rgba_dxt5;
+   util_dl_proc tx_compress_dxtn;
+
+   if (!first_time)
+      return;
+   first_time = FALSE;
+
+   if (util_format_s3tc_enabled)
+      return;
 
    library = util_dl_open(DXTN_LIBNAME);
-   util_format_dxt1_rgb_fetch = (util_format_dxtn_fetch_t)
-      get_proc_address_or_nop(library, "fetch_2d_texel_rgb_dxt1");
-   util_format_dxt1_rgba_fetch = (util_format_dxtn_fetch_t)
-      get_proc_address_or_nop(library, "fetch_2d_texel_rgba_dxt1");
-   util_format_dxt3_rgba_fetch = (util_format_dxtn_fetch_t)
-      get_proc_address_or_nop(library, "fetch_2d_texel_rgba_dxt3");
-   util_format_dxt5_rgba_fetch = (util_format_dxtn_fetch_t)
-      get_proc_address_or_nop(library, "fetch_2d_texel_rgba_dxt5");
-   util_format_dxtn_pack = (util_format_dxtn_pack_t)
-      get_proc_address_or_nop(library, "tx_compress_dxtn");
-
-   if (!library)
+   if (!library) {
       debug_printf("couldn't open " DXTN_LIBNAME ", software DXTn "
-         "compression/decompression unavailable\n");
-   else {
-      if (!is_nop(util_format_dxt1_rgb_fetch) &&
-         !is_nop(util_format_dxt1_rgba_fetch) &&
-         !is_nop(util_format_dxt3_rgba_fetch) &&
-         !is_nop(util_format_dxt5_rgba_fetch) &&
-         !is_nop(util_format_dxtn_pack)) {
-         debug_printf("software DXTn compression/decompression available\n");
-      } else
-         debug_printf("couldn't reference all symbols in "
-                 DXTN_LIBNAME ", software DXTn compression/decompression "
-                 "unavailable or partially available\n");
+         "compression/decompression unavailable");
+      return;
    }
 
-#define DO(n, a, A) \
-  ((struct util_format_description *)util_format_description(PIPE_FORMAT_DXT##n##_SRGB##A))->is_supported = \
-         ((struct util_format_description *)util_format_description(PIPE_FORMAT_DXT##n##_RGB##A))->is_supported = \
-               !is_nop(util_format_dxt##n##_rgb##a##_fetch);
-
-  DO(1,,);
-  DO(1,a,A);
-  DO(3,a,A);
-  DO(5,a,A);
+   fetch_2d_texel_rgb_dxt1 =
+         util_dl_get_proc_address(library, "fetch_2d_texel_rgb_dxt1");
+   fetch_2d_texel_rgba_dxt1 =
+         util_dl_get_proc_address(library, "fetch_2d_texel_rgba_dxt1");
+   fetch_2d_texel_rgba_dxt3 =
+         util_dl_get_proc_address(library, "fetch_2d_texel_rgba_dxt3");
+   fetch_2d_texel_rgba_dxt5 =
+         util_dl_get_proc_address(library, "fetch_2d_texel_rgba_dxt5");
+   tx_compress_dxtn =
+         util_dl_get_proc_address(library, "tx_compress_dxtn");
+
+   if (!util_format_dxt1_rgb_fetch ||
+       !util_format_dxt1_rgba_fetch ||
+       !util_format_dxt3_rgba_fetch ||
+       !util_format_dxt5_rgba_fetch ||
+       !util_format_dxtn_pack) {
+      debug_printf("couldn't reference all symbols in " DXTN_LIBNAME
+                   ", software DXTn compression/decompression "
+                   "unavailable");
+      util_dl_close(library);
+      return;
+   }
 
-#undef DO
+   util_format_dxt1_rgb_fetch = (util_format_dxtn_fetch_t)fetch_2d_texel_rgb_dxt1;
+   util_format_dxt1_rgba_fetch = (util_format_dxtn_fetch_t)fetch_2d_texel_rgba_dxt1;
+   util_format_dxt3_rgba_fetch = (util_format_dxtn_fetch_t)fetch_2d_texel_rgba_dxt3;
+   util_format_dxt5_rgba_fetch = (util_format_dxtn_fetch_t)fetch_2d_texel_rgba_dxt5;
+   util_format_dxtn_pack = (util_format_dxtn_pack_t)tx_compress_dxtn;
+   util_format_s3tc_enabled = TRUE;
 }
 
 
@@ -165,31 +161,31 @@ util_format_s3tc_do_init(void)
  */
 
 void
-util_format_dxt1_rgb_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt1_rgb_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 {
    util_format_dxt1_rgb_fetch(0, src, i, j, dst);
 }
 
 void
-util_format_dxt1_rgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt1_rgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 {
    util_format_dxt1_rgba_fetch(0, src, i, j, dst);
 }
 
 void
-util_format_dxt3_rgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt3_rgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 {
    util_format_dxt3_rgba_fetch(0, src, i, j, dst);
 }
 
 void
-util_format_dxt5_rgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt5_rgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 {
    util_format_dxt5_rgba_fetch(0, src, i, j, dst);
 }
 
 void
-util_format_dxt1_rgb_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt1_rgb_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 {
    uint8_t tmp[4];
    util_format_dxt1_rgb_fetch(0, src, i, j, tmp);
@@ -200,7 +196,7 @@ util_format_dxt1_rgb_fetch_float(float *dst, const uint8_t *src, unsigned i, uns
 }
 
 void
-util_format_dxt1_rgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt1_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 {
    uint8_t tmp[4];
    util_format_dxt1_rgba_fetch(0, src, i, j, tmp);
@@ -211,7 +207,7 @@ util_format_dxt1_rgba_fetch_float(float *dst, const uint8_t *src, unsigned i, un
 }
 
 void
-util_format_dxt3_rgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt3_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 {
    uint8_t tmp[4];
    util_format_dxt3_rgba_fetch(0, src, i, j, tmp);
@@ -222,7 +218,7 @@ util_format_dxt3_rgba_fetch_float(float *dst, const uint8_t *src, unsigned i, un
 }
 
 void
-util_format_dxt5_rgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt5_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 {
    uint8_t tmp[4];
    util_format_dxt5_rgba_fetch(0, src, i, j, tmp);
@@ -238,190 +234,174 @@ util_format_dxt5_rgba_fetch_float(float *dst, const uint8_t *src, unsigned i, un
  */
 
 void
-util_format_dxt1_rgb_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_rgb_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxt1_rgb_fetch)) {
-      unsigned x, y, i, j;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         for(x = 0; x < width; x += 4) {
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
-                  util_format_dxt1_rgb_fetch(0, src, i, j, dst);
-               }
+   unsigned x, y, i, j;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      for(x = 0; x < width; x += 4) {
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
+               util_format_dxt1_rgb_fetch(0, src, i, j, dst);
             }
-            src += 8;
          }
-         src_row += src_stride;
+         src += 8;
       }
+      src_row += src_stride;
    }
 }
 
 void
-util_format_dxt1_rgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_rgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxt1_rgba_fetch)) {
-      unsigned x, y, i, j;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         for(x = 0; x < width; x += 4) {
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
-                  util_format_dxt1_rgba_fetch(0, src, i, j, dst);
-               }
+   unsigned x, y, i, j;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      for(x = 0; x < width; x += 4) {
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
+               util_format_dxt1_rgba_fetch(0, src, i, j, dst);
             }
-            src += 8;
          }
-         src_row += src_stride;
+         src += 8;
       }
+      src_row += src_stride;
    }
 }
 
 void
-util_format_dxt3_rgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt3_rgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxt3_rgba_fetch)) {
-      unsigned x, y, i, j;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         for(x = 0; x < width; x += 4) {
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
-                  util_format_dxt3_rgba_fetch(0, src, i, j, dst);
-               }
+   unsigned x, y, i, j;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      for(x = 0; x < width; x += 4) {
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
+               util_format_dxt3_rgba_fetch(0, src, i, j, dst);
             }
-            src += 16;
          }
-         src_row += src_stride;
+         src += 16;
       }
+      src_row += src_stride;
    }
 }
 
 void
-util_format_dxt5_rgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt5_rgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (is_nop(util_format_dxt5_rgba_fetch)) {
-      unsigned x, y, i, j;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         for(x = 0; x < width; x += 4) {
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
-                  util_format_dxt5_rgba_fetch(0, src, i, j, dst);
-               }
+   unsigned x, y, i, j;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      for(x = 0; x < width; x += 4) {
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
+               util_format_dxt5_rgba_fetch(0, src, i, j, dst);
             }
-            src += 16;
          }
-         src_row += src_stride;
+         src += 16;
       }
+      src_row += src_stride;
    }
 }
 
 void
-util_format_dxt1_rgb_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_rgb_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (is_nop(util_format_dxt1_rgb_fetch)) {
-      unsigned x, y, i, j;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         for(x = 0; x < width; x += 4) {
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
-                  uint8_t tmp[4];
-                  util_format_dxt1_rgb_fetch(0, src, i, j, tmp);
-                  dst[0] = ubyte_to_float(tmp[0]);
-                  dst[1] = ubyte_to_float(tmp[1]);
-                  dst[2] = ubyte_to_float(tmp[2]);
-                  dst[3] = 1.0;
-               }
+   unsigned x, y, i, j;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      for(x = 0; x < width; x += 4) {
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
+               uint8_t tmp[4];
+               util_format_dxt1_rgb_fetch(0, src, i, j, tmp);
+               dst[0] = ubyte_to_float(tmp[0]);
+               dst[1] = ubyte_to_float(tmp[1]);
+               dst[2] = ubyte_to_float(tmp[2]);
+               dst[3] = 1.0;
             }
-            src += 8;
          }
-         src_row += src_stride;
+         src += 8;
       }
+      src_row += src_stride;
    }
 }
 
 void
-util_format_dxt1_rgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_rgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxt1_rgba_fetch)) {
-      unsigned x, y, i, j;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         for(x = 0; x < width; x += 4) {
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
-                  uint8_t tmp[4];
-                  util_format_dxt1_rgba_fetch(0, src, i, j, tmp);
-                  dst[0] = ubyte_to_float(tmp[0]);
-                  dst[1] = ubyte_to_float(tmp[1]);
-                  dst[2] = ubyte_to_float(tmp[2]);
-                  dst[3] = ubyte_to_float(tmp[3]);
-               }
+   unsigned x, y, i, j;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      for(x = 0; x < width; x += 4) {
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
+               uint8_t tmp[4];
+               util_format_dxt1_rgba_fetch(0, src, i, j, tmp);
+               dst[0] = ubyte_to_float(tmp[0]);
+               dst[1] = ubyte_to_float(tmp[1]);
+               dst[2] = ubyte_to_float(tmp[2]);
+               dst[3] = ubyte_to_float(tmp[3]);
             }
-            src += 8;
          }
-         src_row += src_stride;
+         src += 8;
       }
+      src_row += src_stride;
    }
 }
 
 void
-util_format_dxt3_rgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt3_rgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxt3_rgba_fetch)) {
-      unsigned x, y, i, j;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         for(x = 0; x < width; x += 4) {
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
-                  uint8_t tmp[4];
-                  util_format_dxt3_rgba_fetch(0, src, i, j, tmp);
-                  dst[0] = ubyte_to_float(tmp[0]);
-                  dst[1] = ubyte_to_float(tmp[1]);
-                  dst[2] = ubyte_to_float(tmp[2]);
-                  dst[3] = ubyte_to_float(tmp[3]);
-               }
+   unsigned x, y, i, j;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      for(x = 0; x < width; x += 4) {
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
+               uint8_t tmp[4];
+               util_format_dxt3_rgba_fetch(0, src, i, j, tmp);
+               dst[0] = ubyte_to_float(tmp[0]);
+               dst[1] = ubyte_to_float(tmp[1]);
+               dst[2] = ubyte_to_float(tmp[2]);
+               dst[3] = ubyte_to_float(tmp[3]);
             }
-            src += 16;
          }
-         src_row += src_stride;
+         src += 16;
       }
+      src_row += src_stride;
    }
 }
 
 void
-util_format_dxt5_rgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt5_rgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxt5_rgba_fetch)) {
-      unsigned x, y, i, j;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         for(x = 0; x < width; x += 4) {
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
-                  uint8_t tmp[4];
-                  util_format_dxt5_rgba_fetch(0, src, i, j, tmp);
-                  dst[0] = ubyte_to_float(tmp[0]);
-                  dst[1] = ubyte_to_float(tmp[1]);
-                  dst[2] = ubyte_to_float(tmp[2]);
-                  dst[3] = ubyte_to_float(tmp[3]);
-               }
+   unsigned x, y, i, j;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      for(x = 0; x < width; x += 4) {
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
+               uint8_t tmp[4];
+               util_format_dxt5_rgba_fetch(0, src, i, j, tmp);
+               dst[0] = ubyte_to_float(tmp[0]);
+               dst[1] = ubyte_to_float(tmp[1]);
+               dst[2] = ubyte_to_float(tmp[2]);
+               dst[3] = ubyte_to_float(tmp[3]);
             }
-            src += 16;
          }
-         src_row += src_stride;
+         src += 16;
       }
+      src_row += src_stride;
    }
 }
 
@@ -431,218 +411,202 @@ util_format_dxt5_rgba_unpack_float(float *dst_row, unsigned dst_stride, const ui
  */
 
 void
-util_format_dxt1_rgb_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
-{
-   if (!is_nop(util_format_dxtn_pack)) {
-      unsigned x, y, i, j, k;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         uint8_t *dst = dst_row;
-         for(x = 0; x < width; x += 4) {
-            uint8_t tmp[4][4][3];
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  for(k = 0; k < 3; ++k) {
-                     tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + i*4 + k];
-                  }
+util_format_dxt1_rgb_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+{
+   unsigned x, y, i, j, k;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      uint8_t *dst = dst_row;
+      for(x = 0; x < width; x += 4) {
+         uint8_t tmp[4][4][3];
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               for(k = 0; k < 3; ++k) {
+                  tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + i*4 + k];
                }
             }
-            util_format_dxtn_pack(3, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGB, dst, dst_stride);
-            src += 4*4;
-            dst += 8;
          }
-         src_row += src_stride;
-         dst_row += 4*dst_stride/sizeof(*dst_row);
+         util_format_dxtn_pack(3, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGB, dst, dst_stride);
+         src += 4*4;
+         dst += 8;
       }
+      src_row += src_stride;
+      dst_row += 4*dst_stride/sizeof(*dst_row);
    }
 }
 
 void
-util_format_dxt1_rgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_rgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxtn_pack)) {
-      unsigned x, y, i, j, k;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         uint8_t *dst = dst_row;
-         for(x = 0; x < width; x += 4) {
-            uint8_t tmp[4][4][4];
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  for(k = 0; k < 4; ++k) {
-                     tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + i*4 + k];
-                  }
+   unsigned x, y, i, j, k;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      uint8_t *dst = dst_row;
+      for(x = 0; x < width; x += 4) {
+         uint8_t tmp[4][4][4];
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               for(k = 0; k < 4; ++k) {
+                  tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + i*4 + k];
                }
             }
-            util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGBA, dst, dst_stride);
-            src += 4*4;
-            dst += 8;
          }
-         src_row += src_stride;
-         dst_row += 4*dst_stride/sizeof(*dst_row);
+         util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGBA, dst, dst_stride);
+         src += 4*4;
+         dst += 8;
       }
+      src_row += src_stride;
+      dst_row += 4*dst_stride/sizeof(*dst_row);
    }
 }
 
 void
-util_format_dxt3_rgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt3_rgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxtn_pack)) {
-      unsigned x, y, i, j, k;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         uint8_t *dst = dst_row;
-         for(x = 0; x < width; x += 4) {
-            uint8_t tmp[4][4][4];
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  for(k = 0; k < 4; ++k) {
-                     tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + i*4 + k];
-                  }
+   unsigned x, y, i, j, k;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      uint8_t *dst = dst_row;
+      for(x = 0; x < width; x += 4) {
+         uint8_t tmp[4][4][4];
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               for(k = 0; k < 4; ++k) {
+                  tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + i*4 + k];
                }
             }
-            util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT3_RGBA, dst, dst_stride);
-            src += 4*4;
-            dst += 16;
          }
-         src_row += src_stride;
-         dst_row += 4*dst_stride/sizeof(*dst_row);
+         util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT3_RGBA, dst, dst_stride);
+         src += 4*4;
+         dst += 16;
       }
+      src_row += src_stride;
+      dst_row += 4*dst_stride/sizeof(*dst_row);
    }
 }
 
 void
-util_format_dxt5_rgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt5_rgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxtn_pack)) {
-      unsigned x, y, i, j, k;
-      for(y = 0; y < height; y += 4) {
-         const uint8_t *src = src_row;
-         uint8_t *dst = dst_row;
-         for(x = 0; x < width; x += 4) {
-            uint8_t tmp[4][4][4];
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  for(k = 0; k < 4; ++k) {
-                     tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + i*4 + k];
-                  }
+   unsigned x, y, i, j, k;
+   for(y = 0; y < height; y += 4) {
+      const uint8_t *src = src_row;
+      uint8_t *dst = dst_row;
+      for(x = 0; x < width; x += 4) {
+         uint8_t tmp[4][4][4];
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               for(k = 0; k < 4; ++k) {
+                  tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + i*4 + k];
                }
             }
-            util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT5_RGBA, dst, dst_stride);
-            src += 4*4;
-            dst += 16;
          }
-         src_row += src_stride;
-         dst_row += 4*dst_stride/sizeof(*dst_row);
+         util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT5_RGBA, dst, dst_stride);
+         src += 4*4;
+         dst += 16;
       }
+      src_row += src_stride;
+      dst_row += 4*dst_stride/sizeof(*dst_row);
    }
 }
 
 void
-util_format_dxt1_rgb_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_rgb_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxtn_pack)) {
-      unsigned x, y, i, j, k;
-      for(y = 0; y < height; y += 4) {
-         const float *src = src_row;
-         uint8_t *dst = dst_row;
-         for(x = 0; x < width; x += 4) {
-            uint8_t tmp[4][4][3];
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  for(k = 0; k < 3; ++k) {
-                     tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + i*4 + k]);
-                  }
+   unsigned x, y, i, j, k;
+   for(y = 0; y < height; y += 4) {
+      const float *src = src_row;
+      uint8_t *dst = dst_row;
+      for(x = 0; x < width; x += 4) {
+         uint8_t tmp[4][4][3];
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               for(k = 0; k < 3; ++k) {
+                  tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + i*4 + k]);
                }
             }
-            util_format_dxtn_pack(3, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGB, dst, dst_stride);
-            src += 4*4;
-            dst += 8;
          }
-         src_row += src_stride;
-         dst_row += 4*dst_stride/sizeof(*dst_row);
+         util_format_dxtn_pack(3, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGB, dst, dst_stride);
+         src += 4*4;
+         dst += 8;
       }
+      src_row += src_stride;
+      dst_row += 4*dst_stride/sizeof(*dst_row);
    }
 }
 
 void
-util_format_dxt1_rgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_rgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxtn_pack)) {
-      unsigned x, y, i, j, k;
-      for(y = 0; y < height; y += 4) {
-         const float *src = src_row;
-         uint8_t *dst = dst_row;
-         for(x = 0; x < width; x += 4) {
-            uint8_t tmp[4][4][4];
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  for(k = 0; k < 4; ++k) {
-                     tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + i*4 + k]);
-                  }
+   unsigned x, y, i, j, k;
+   for(y = 0; y < height; y += 4) {
+      const float *src = src_row;
+      uint8_t *dst = dst_row;
+      for(x = 0; x < width; x += 4) {
+         uint8_t tmp[4][4][4];
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               for(k = 0; k < 4; ++k) {
+                  tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + i*4 + k]);
                }
             }
-            util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGBA, dst, dst_stride);
-            src += 4*4;
-            dst += 8;
          }
-         src_row += src_stride;
-         dst_row += 4*dst_stride/sizeof(*dst_row);
+         util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGBA, dst, dst_stride);
+         src += 4*4;
+         dst += 8;
       }
+      src_row += src_stride;
+      dst_row += 4*dst_stride/sizeof(*dst_row);
    }
 }
 
 void
-util_format_dxt3_rgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt3_rgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxtn_pack)) {
-      unsigned x, y, i, j, k;
-      for(y = 0; y < height; y += 4) {
-         const float *src = src_row;
-         uint8_t *dst = dst_row;
-         for(x = 0; x < width; x += 4) {
-            uint8_t tmp[4][4][4];
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  for(k = 0; k < 4; ++k) {
-                     tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + i*4 + k]);
-                  }
+   unsigned x, y, i, j, k;
+   for(y = 0; y < height; y += 4) {
+      const float *src = src_row;
+      uint8_t *dst = dst_row;
+      for(x = 0; x < width; x += 4) {
+         uint8_t tmp[4][4][4];
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               for(k = 0; k < 4; ++k) {
+                  tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + i*4 + k]);
                }
             }
-            util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT3_RGBA, dst, dst_stride);
-            src += 4*4;
-            dst += 16;
          }
-         src_row += src_stride;
-         dst_row += 4*dst_stride/sizeof(*dst_row);
+         util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT3_RGBA, dst, dst_stride);
+         src += 4*4;
+         dst += 16;
       }
+      src_row += src_stride;
+      dst_row += 4*dst_stride/sizeof(*dst_row);
    }
 }
 
 void
-util_format_dxt5_rgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt5_rgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   if (!is_nop(util_format_dxtn_pack)) {
-      unsigned x, y, i, j, k;
-      for(y = 0; y < height; y += 4) {
-         const float *src = src_row;
-         uint8_t *dst = dst_row;
-         for(x = 0; x < width; x += 4) {
-            uint8_t tmp[4][4][4];
-            for(j = 0; j < 4; ++j) {
-               for(i = 0; i < 4; ++i) {
-                  for(k = 0; k < 4; ++k) {
-                     tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + i*4 + k]);
-                  }
+   unsigned x, y, i, j, k;
+   for(y = 0; y < height; y += 4) {
+      const float *src = src_row;
+      uint8_t *dst = dst_row;
+      for(x = 0; x < width; x += 4) {
+         uint8_t tmp[4][4][4];
+         for(j = 0; j < 4; ++j) {
+            for(i = 0; i < 4; ++i) {
+               for(k = 0; k < 4; ++k) {
+                  tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + i*4 + k]);
                }
             }
-            util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT5_RGBA, dst, dst_stride);
-            src += 4*4;
-            dst += 16;
          }
-         src_row += src_stride;
-         dst_row += 4*dst_stride/sizeof(*dst_row);
+         util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT5_RGBA, dst, dst_stride);
+         src += 4*4;
+         dst += 16;
       }
+      src_row += src_stride;
+      dst_row += 4*dst_stride/sizeof(*dst_row);
    }
 }
 
@@ -654,146 +618,146 @@ util_format_dxt5_rgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const fl
  */
 
 void
-util_format_dxt1_srgb_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_srgb_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt1_rgb_unpack_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt1_rgb_unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt1_srgb_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_srgb_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt1_rgb_pack_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt1_rgb_pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt1_srgb_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt1_srgb_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 {
-   util_format_dxt1_rgb_fetch_8unorm(dst, src, i, j);
+   util_format_dxt1_rgb_fetch_rgba_8unorm(dst, src, i, j);
 }
 
 void
-util_format_dxt1_srgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_srgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt1_rgba_unpack_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt1_rgba_unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt1_srgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_srgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt1_rgba_pack_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt1_rgba_pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt1_srgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt1_srgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 {
-   util_format_dxt1_rgba_fetch_8unorm(dst, src, i, j);
+   util_format_dxt1_rgba_fetch_rgba_8unorm(dst, src, i, j);
 }
 
 void
-util_format_dxt3_srgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt3_srgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt3_rgba_unpack_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt3_rgba_unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt3_srgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt3_srgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt3_rgba_pack_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt3_rgba_pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt3_srgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt3_srgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 {
-   util_format_dxt3_rgba_fetch_8unorm(dst, src, i, j);
+   util_format_dxt3_rgba_fetch_rgba_8unorm(dst, src, i, j);
 }
 
 void
-util_format_dxt5_srgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt5_srgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt5_rgba_unpack_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt5_rgba_unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt5_srgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt5_srgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt5_rgba_pack_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt5_rgba_pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt5_srgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt5_srgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 {
-   util_format_dxt5_rgba_fetch_8unorm(dst, src, i, j);
+   util_format_dxt5_rgba_fetch_rgba_8unorm(dst, src, i, j);
 }
 
 void
-util_format_dxt1_srgb_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_srgb_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt1_rgb_unpack_float(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt1_rgb_unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt1_srgb_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_srgb_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt1_rgb_pack_float(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt1_rgb_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt1_srgb_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt1_srgb_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 {
-   util_format_dxt1_rgb_fetch_float(dst, src, i, j);
+   util_format_dxt1_rgb_fetch_rgba_float(dst, src, i, j);
 }
 
 void
-util_format_dxt1_srgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_srgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt1_rgba_unpack_float(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt1_rgba_unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt1_srgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt1_srgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt1_rgba_pack_float(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt1_rgba_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt1_srgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt1_srgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 {
-   util_format_dxt1_rgba_fetch_float(dst, src, i, j);
+   util_format_dxt1_rgba_fetch_rgba_float(dst, src, i, j);
 }
 
 void
-util_format_dxt3_srgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt3_srgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt3_rgba_unpack_float(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt3_rgba_unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt3_srgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt3_srgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt3_rgba_pack_float(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt3_rgba_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt3_srgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt3_srgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 {
-   util_format_dxt3_rgba_fetch_float(dst, src, i, j);
+   util_format_dxt3_rgba_fetch_rgba_float(dst, src, i, j);
 }
 
 void
-util_format_dxt5_srgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt5_srgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt5_rgba_unpack_float(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt5_rgba_unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt5_srgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
+util_format_dxt5_srgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 {
-   util_format_dxt5_rgba_pack_float(dst_row, dst_stride, src_row, src_stride, width, height);
+   util_format_dxt5_rgba_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 }
 
 void
-util_format_dxt5_srgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
+util_format_dxt5_srgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 {
-   util_format_dxt5_rgba_fetch_float(dst, src, i, j);
+   util_format_dxt5_rgba_fetch_rgba_float(dst, src, i, j);
 }
 
diff --git a/src/gallium/auxiliary/util/u_format_s3tc.h b/src/gallium/auxiliary/util/u_format_s3tc.h
index da14b9b93a6..97770abd422 100644
--- a/src/gallium/auxiliary/util/u_format_s3tc.h
+++ b/src/gallium/auxiliary/util/u_format_s3tc.h
@@ -31,7 +31,6 @@
 
 
 #include "pipe/p_compiler.h"
-#include "util/u_inline_init.h"
 
 
 enum util_format_dxtn {
@@ -66,153 +65,154 @@ extern util_format_dxtn_fetch_t util_format_dxt5_rgba_fetch;
 extern util_format_dxtn_pack_t util_format_dxtn_pack;
 
 
-UTIL_INLINE_INIT(util_format_s3tc)
+void
+util_format_s3tc_init(void);
 
 
 void
-util_format_dxt1_rgb_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_rgb_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_rgb_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_rgb_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_rgb_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt1_rgb_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt1_rgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_rgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_rgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_rgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_rgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt1_rgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt3_rgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt3_rgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt3_rgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt3_rgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt3_rgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt3_rgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt5_rgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt5_rgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt5_rgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt5_rgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt5_rgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt5_rgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt1_srgb_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_srgb_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_srgb_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_srgb_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_srgb_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt1_srgb_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt1_srgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_srgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_srgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_srgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_srgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt1_srgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt3_srgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt3_srgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt3_srgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt3_srgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt3_srgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt3_srgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt5_srgba_unpack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt5_srgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt5_srgba_pack_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt5_srgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt5_srgba_fetch_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt5_srgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j);
 
 
 void
-util_format_dxt1_rgb_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_rgb_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_rgb_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_rgb_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_rgb_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt1_rgb_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt1_rgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_rgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_rgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_rgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_rgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt1_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt3_rgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt3_rgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt3_rgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt3_rgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt3_rgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt3_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt5_rgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt5_rgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt5_rgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt5_rgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt5_rgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt5_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt1_srgb_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_srgb_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_srgb_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_srgb_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_srgb_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt1_srgb_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt1_srgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_srgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_srgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt1_srgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt1_srgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt1_srgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt3_srgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt3_srgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt3_srgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt3_srgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt3_srgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt3_srgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
 
 void
-util_format_dxt5_srgba_unpack_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt5_srgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt5_srgba_pack_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+util_format_dxt5_srgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
 
 void
-util_format_dxt5_srgba_fetch_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
+util_format_dxt5_srgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j);
 
 
 #endif /* U_FORMAT_S3TC_H_ */
diff --git a/src/gallium/auxiliary/util/u_format_srgb.h b/src/gallium/auxiliary/util/u_format_srgb.h
new file mode 100644
index 00000000000..43213fbeb3e
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_format_srgb.h
@@ -0,0 +1,106 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.
+ * 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 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
+ * THE COPYRIGHT HOLDERS, AUTHORS 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.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * SRGB translation.
+ *
+ * @author Brian Paul <brianp@vmware.com>
+ * @author Michal Krol <michal@vmware.com>
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+
+#ifndef U_FORMAT_SRGB_H_
+#define U_FORMAT_SRGB_H_
+
+
+#include "pipe/p_compiler.h"
+#include "u_math.h"
+
+
+extern const float
+util_format_srgb_8unorm_to_linear_float_table[256];
+
+extern const uint8_t
+util_format_srgb_to_linear_8unorm_table[256];
+
+extern const uint8_t
+util_format_linear_to_srgb_8unorm_table[256];
+
+
+/**
+ * Convert a unclamped linear float to srgb value in the [0,255].
+ * XXX this hasn't been tested (render to srgb surface).
+ * XXX this needs optimization.
+ */
+static INLINE uint8_t
+util_format_linear_float_to_srgb_8unorm(float x)
+{
+   if (x >= 1.0f)
+      return 255;
+   else if (x >= 0.0031308f)
+      return float_to_ubyte(1.055f * powf(x, 0.41666f) - 0.055f);
+   else if (x > 0.0f)
+      return float_to_ubyte(12.92f * x);
+   else
+      return 0;
+}
+
+
+/**
+ * Convert an 8-bit sRGB value from non-linear space to a
+ * linear RGB value in [0, 1].
+ * Implemented with a 256-entry lookup table.
+ */
+static INLINE float
+util_format_srgb_8unorm_to_linear_float(uint8_t x)
+{
+   return util_format_srgb_8unorm_to_linear_float_table[x];
+}
+
+
+/**
+ * Convert a 8bit normalized value from linear to srgb.
+ */
+static INLINE uint8_t
+util_format_linear_to_srgb_8unorm(uint8_t x)
+{
+   return util_format_linear_to_srgb_8unorm_table[x];
+}
+
+
+/**
+ * Convert a 8bit normalized value from srgb to linear.
+ */
+static INLINE uint8_t
+util_format_srgb_to_linear_8unorm(uint8_t x)
+{
+   return util_format_srgb_to_linear_8unorm_table[x];
+}
+
+
+#endif /* U_FORMAT_SRGB_H_ */
diff --git a/src/gallium/auxiliary/util/u_format_srgb.py b/src/gallium/auxiliary/util/u_format_srgb.py
new file mode 100644
index 00000000000..a4c76dc00b3
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_format_srgb.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+
+'''
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.
+ * 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 VMWARE 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.
+ *
+ **************************************************************************/
+
+/**
+ * @file
+ * SRGB translation.
+ *
+ * @author Brian Paul <brianp@vmware.com>
+ * @author Michal Krol <michal@vmware.com>
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+'''
+
+
+import sys
+import math
+
+
+def srgb_to_linear(x):
+    if x <= 0.04045:
+        return x / 12.92
+    else:
+        return math.pow((x + 0.055) / 1.055, 2.4)
+
+
+def linear_to_srgb(x):
+    if x >= 0.0031308:
+        return 1.055 * math.pow(x, 0.41666) - 0.055
+    else:
+        return 12.92 * x
+
+def generate_srgb_tables():
+    print 'const float'
+    print 'util_format_srgb_8unorm_to_linear_float_table[256] = {'
+    for j in range(0, 256, 4):
+        print '   ',
+        for i in range(j, j + 4):
+            print '%.7e,' % (srgb_to_linear(i / 255.0),),
+        print
+    print '};'
+    print
+    print 'const uint8_t'
+    print 'util_format_srgb_to_linear_8unorm_table[256] = {'
+    for j in range(0, 256, 16):
+        print '   ',
+        for i in range(j, j + 16):
+            print '%3u,' % (int(srgb_to_linear(i / 255.0) * 255.0 + 0.5),),
+        print
+    print '};'
+    print
+    print 'const uint8_t'
+    print 'util_format_linear_to_srgb_8unorm_table[256] = {'
+    for j in range(0, 256, 16):
+        print '   ',
+        for i in range(j, j + 16):
+            print '%3u,' % (int(linear_to_srgb(i / 255.0) * 255.0 + 0.5),),
+        print
+    print '};'
+    print
+
+
+def main():
+    print '/* This file is autogenerated by u_format_srgb.py. Do not edit directly. */'
+    print
+    # This will print the copyright message on the top of this file
+    print __doc__.strip()
+    print
+    print '#include "u_format_srgb.h"'
+    print
+    generate_srgb_tables()    
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/auxiliary/util/u_format_table.py b/src/gallium/auxiliary/util/u_format_table.py
index 2c0c9bffeed..ae9a5981973 100755
--- a/src/gallium/auxiliary/util/u_format_table.py
+++ b/src/gallium/auxiliary/util/u_format_table.py
@@ -92,7 +92,7 @@ def write_format_table(formats):
     u_format_pack.generate(formats)
     
     for format in formats:
-        print 'struct util_format_description'
+        print 'const struct util_format_description'
         print 'util_format_%s_description = {' % (format.short_name(),)
         print "   %s," % (format.name,)
         print "   \"%s\"," % (format.name,)
@@ -103,7 +103,6 @@ def write_format_table(formats):
         print "   %s,\t/* is_array */" % (bool_map(format.is_array()),)
         print "   %s,\t/* is_bitmask */" % (bool_map(format.is_bitmask()),)
         print "   %s,\t/* is_mixed */" % (bool_map(format.is_mixed()),)
-        print "   %s,\t/* is_supported */" % ("TRUE" if u_format_pack.is_format_supported(format) else "FALSE",)
         print "   {"
         for i in range(4):
             channel = format.channels[i]
@@ -130,11 +129,34 @@ def write_format_table(formats):
             print "      %s%s\t/* %s */" % (swizzle_map[swizzle], sep, comment)
         print "   },"
         print "   %s," % (colorspace_map(format.colorspace),)
-        print "   &util_format_%s_unpack_8unorm," % format.short_name() 
-        print "   &util_format_%s_pack_8unorm," % format.short_name() 
-        print "   &util_format_%s_unpack_float," % format.short_name() 
-        print "   &util_format_%s_pack_float," % format.short_name() 
-        print "   &util_format_%s_fetch_float" % format.short_name() 
+        if format.colorspace != ZS:
+            print "   &util_format_%s_unpack_rgba_8unorm," % format.short_name() 
+            print "   &util_format_%s_pack_rgba_8unorm," % format.short_name() 
+            print "   &util_format_%s_unpack_rgba_float," % format.short_name() 
+            print "   &util_format_%s_pack_rgba_float," % format.short_name() 
+            print "   &util_format_%s_fetch_rgba_float," % format.short_name()
+        else:
+            print "   NULL, /* unpack_rgba_8unorm */" 
+            print "   NULL, /* pack_rgba_8unorm */" 
+            print "   NULL, /* unpack_rgba_float */" 
+            print "   NULL, /* pack_rgba_float */" 
+            print "   NULL, /* fetch_rgba_float */" 
+        if format.colorspace == ZS and format.swizzles[0] != SWIZZLE_NONE:
+            print "   &util_format_%s_unpack_z_32unorm," % format.short_name() 
+            print "   &util_format_%s_pack_z_32unorm," % format.short_name() 
+            print "   &util_format_%s_unpack_z_float," % format.short_name() 
+            print "   &util_format_%s_pack_z_float," % format.short_name() 
+        else:
+            print "   NULL, /* unpack_z_32unorm */" 
+            print "   NULL, /* pack_z_32unorm */" 
+            print "   NULL, /* unpack_z_float */" 
+            print "   NULL, /* pack_z_float */" 
+        if format.colorspace == ZS and format.swizzles[1] != SWIZZLE_NONE:
+            print "   &util_format_%s_unpack_s_8uscaled," % format.short_name() 
+            print "   &util_format_%s_pack_s_8uscaled" % format.short_name() 
+        else:
+            print "   NULL, /* unpack_s_8uscaled */" 
+            print "   NULL /* pack_s_8uscaled */" 
         print "};"
         print
         
@@ -150,7 +172,6 @@ def write_format_table(formats):
         print "   case %s:" % format.name
         print "      return &util_format_%s_description;" % (format.short_name(),)
     print "   default:"
-    print "      assert(0);"
     print "      return NULL;"
     print "   }"
     print "}"
diff --git a/src/gallium/auxiliary/util/u_format_tests.c b/src/gallium/auxiliary/util/u_format_tests.c
index 0f81dcb79bc..b1df6c49c42 100644
--- a/src/gallium/auxiliary/util/u_format_tests.c
+++ b/src/gallium/auxiliary/util/u_format_tests.c
@@ -56,6 +56,12 @@
        {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}, \
        {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}}
 
+#define UNPACKED_2x1(r0, g0, b0, a0, r1, g1, b1, a1) \
+      {{{r0, g0, b0, a0}, {r1, g1, b1, a1}, {0, 0, 0, 0}, {0, 0, 0, 0}}, \
+       {{ 0,  0,  0,  0}, { 0,  0,  0,  0}, {0, 0, 0, 0}, {0, 0, 0, 0}}, \
+       {{ 0,  0,  0,  0}, { 0,  0,  0,  0}, {0, 0, 0, 0}, {0, 0, 0, 0}}, \
+       {{ 0,  0,  0,  0}, { 0,  0,  0,  0}, {0, 0, 0, 0}, {0, 0, 0, 0}}}
+
 
 /**
  * Test cases.
@@ -116,6 +122,13 @@ util_format_test_cases[] =
    {PIPE_FORMAT_X8B8G8R8_UNORM, PACKED_1x32(0xffffff00), PACKED_1x32(0xff000000), UNPACKED_1x1(1.0, 0.0, 0.0, 1.0)},
    {PIPE_FORMAT_X8B8G8R8_UNORM, PACKED_1x32(0xffffff00), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
 
+   {PIPE_FORMAT_R8G8B8X8_UNORM, PACKED_1x32(0x00ffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8X8_UNORM, PACKED_1x32(0x00ffffff), PACKED_1x32(0x000000ff), UNPACKED_1x1(1.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8X8_UNORM, PACKED_1x32(0x00ffffff), PACKED_1x32(0x0000ff00), UNPACKED_1x1(0.0, 1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8X8_UNORM, PACKED_1x32(0x00ffffff), PACKED_1x32(0x00ff0000), UNPACKED_1x1(0.0, 0.0, 1.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8X8_UNORM, PACKED_1x32(0x00ffffff), PACKED_1x32(0xff000000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8X8_UNORM, PACKED_1x32(0x00ffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
    {PIPE_FORMAT_R10G10B10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
    {PIPE_FORMAT_R10G10B10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x000003ff), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
    {PIPE_FORMAT_R10G10B10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x000ffc00), UNPACKED_1x1(0.0, 1.0, 0.0, 0.0)},
@@ -123,6 +136,13 @@ util_format_test_cases[] =
    {PIPE_FORMAT_R10G10B10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0xc0000000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
    {PIPE_FORMAT_R10G10B10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
 
+   {PIPE_FORMAT_B10G10R10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_B10G10R10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x000003ff), UNPACKED_1x1(0.0, 0.0, 1.0, 0.0)},
+   {PIPE_FORMAT_B10G10R10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x000ffc00), UNPACKED_1x1(0.0, 1.0, 0.0, 0.0)},
+   {PIPE_FORMAT_B10G10R10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x3ff00000), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_B10G10R10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0xc0000000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_B10G10R10A2_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
    /*
     * 16-bit rendertarget formats
     */
@@ -140,6 +160,12 @@ util_format_test_cases[] =
    {PIPE_FORMAT_B5G5R5A1_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0x8000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
    {PIPE_FORMAT_B5G5R5A1_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0xffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
 
+   {PIPE_FORMAT_B4G4R4X4_UNORM, PACKED_1x16(0x0fff), PACKED_1x16(0x0000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_B4G4R4X4_UNORM, PACKED_1x16(0x0fff), PACKED_1x16(0x000f), UNPACKED_1x1(0.0, 0.0, 1.0, 1.0)},
+   {PIPE_FORMAT_B4G4R4X4_UNORM, PACKED_1x16(0x0fff), PACKED_1x16(0x00f0), UNPACKED_1x1(0.0, 1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_B4G4R4X4_UNORM, PACKED_1x16(0x0fff), PACKED_1x16(0x0f00), UNPACKED_1x1(1.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_B4G4R4X4_UNORM, PACKED_1x16(0x0fff), PACKED_1x16(0x0fff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
    {PIPE_FORMAT_B4G4R4A4_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0x0000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
    {PIPE_FORMAT_B4G4R4A4_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0x000f), UNPACKED_1x1(0.0, 0.0, 1.0, 0.0)},
    {PIPE_FORMAT_B4G4R4A4_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0x00f0), UNPACKED_1x1(0.0, 1.0, 0.0, 0.0)},
@@ -166,6 +192,11 @@ util_format_test_cases[] =
    {PIPE_FORMAT_I8_UNORM, PACKED_1x8(0xff), PACKED_1x8(0x00), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
    {PIPE_FORMAT_I8_UNORM, PACKED_1x8(0xff), PACKED_1x8(0xff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
 
+   {PIPE_FORMAT_L4A4_UNORM, PACKED_1x8(0xff), PACKED_1x8(0x00), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_L4A4_UNORM, PACKED_1x8(0xff), PACKED_1x8(0x0f), UNPACKED_1x1(1.0, 1.0, 1.0, 0.0)},
+   {PIPE_FORMAT_L4A4_UNORM, PACKED_1x8(0xff), PACKED_1x8(0xf0), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_L4A4_UNORM, PACKED_1x8(0xff), PACKED_1x8(0xff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
    {PIPE_FORMAT_L8A8_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0x0000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
    {PIPE_FORMAT_L8A8_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0x00ff), UNPACKED_1x1(1.0, 1.0, 1.0, 0.0)},
    {PIPE_FORMAT_L8A8_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0xff00), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
@@ -175,9 +206,100 @@ util_format_test_cases[] =
    {PIPE_FORMAT_L16_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0xffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
 
    /*
-    * TODO: SRGB formats
+    * SRGB formats
     */
 
+   {PIPE_FORMAT_L8_SRGB, PACKED_1x8(0xff), PACKED_1x8(0x00), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_L8_SRGB, PACKED_1x8(0xff), PACKED_1x8(0xbc), UNPACKED_1x1(0.502886458033, 0.502886458033, 0.502886458033, 1.0)},
+   {PIPE_FORMAT_L8_SRGB, PACKED_1x8(0xff), PACKED_1x8(0xff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_L8A8_SRGB, PACKED_1x16(0xffff), PACKED_1x16(0x0000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_L8A8_SRGB, PACKED_1x16(0xffff), PACKED_1x16(0x00bc), UNPACKED_1x1(0.502886458033, 0.502886458033, 0.502886458033, 0.0)},
+   {PIPE_FORMAT_L8A8_SRGB, PACKED_1x16(0xffff), PACKED_1x16(0x00ff), UNPACKED_1x1(1.0, 1.0, 1.0, 0.0)},
+   {PIPE_FORMAT_L8A8_SRGB, PACKED_1x16(0xffff), PACKED_1x16(0xcc00), UNPACKED_1x1(0.0, 0.0, 0.0, 0.8)},
+   {PIPE_FORMAT_L8A8_SRGB, PACKED_1x16(0xffff), PACKED_1x16(0xff00), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_L8A8_SRGB, PACKED_1x16(0xffff), PACKED_1x16(0xffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_R8G8B8_SRGB, PACKED_3x8(0xff, 0xff, 0xff), PACKED_3x8(0x00, 0x00, 0x00), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8_SRGB, PACKED_3x8(0xff, 0xff, 0xff), PACKED_3x8(0xbc, 0x00, 0x00), UNPACKED_1x1(0.502886458033, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8_SRGB, PACKED_3x8(0xff, 0xff, 0xff), PACKED_3x8(0xff, 0x00, 0x00), UNPACKED_1x1(1.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8_SRGB, PACKED_3x8(0xff, 0xff, 0xff), PACKED_3x8(0x00, 0xbc, 0x00), UNPACKED_1x1(0.0, 0.502886458033, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8_SRGB, PACKED_3x8(0xff, 0xff, 0xff), PACKED_3x8(0x00, 0xff, 0x00), UNPACKED_1x1(0.0, 1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8_SRGB, PACKED_3x8(0xff, 0xff, 0xff), PACKED_3x8(0x00, 0x00, 0xbc), UNPACKED_1x1(0.0, 0.0, 0.502886458033, 1.0)},
+   {PIPE_FORMAT_R8G8B8_SRGB, PACKED_3x8(0xff, 0xff, 0xff), PACKED_3x8(0x00, 0x00, 0xff), UNPACKED_1x1(0.0, 0.0, 1.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8_SRGB, PACKED_3x8(0xff, 0xff, 0xff), PACKED_3x8(0xff, 0xff, 0xff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0x00, 0x00), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0xbc, 0x00, 0x00, 0x00), UNPACKED_1x1(0.502886458033, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0xff, 0x00, 0x00, 0x00), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0xbc, 0x00, 0x00), UNPACKED_1x1(0.0, 0.502886458033, 0.0, 0.0)},
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0xff, 0x00, 0x00), UNPACKED_1x1(0.0, 1.0, 0.0, 0.0)},
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0xbc, 0x00), UNPACKED_1x1(0.0, 0.0, 0.502886458033, 0.0)},
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0xff, 0x00), UNPACKED_1x1(0.0, 0.0, 1.0, 0.0)},
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0x00, 0xcc), UNPACKED_1x1(0.0, 0.0, 0.0, 0.8)},
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0x00, 0xff), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8B8A8_SRGB, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0xff, 0xff, 0xff, 0xff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x000000bc), UNPACKED_1x1(0.0, 0.0, 0.502886458033, 0.0)},
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x000000ff), UNPACKED_1x1(0.0, 0.0, 1.0, 0.0)},
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x0000bc00), UNPACKED_1x1(0.0, 0.502886458033, 0.0, 0.0)},
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x0000ff00), UNPACKED_1x1(0.0, 1.0, 0.0, 0.0)},
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x00bc0000), UNPACKED_1x1(0.502886458033, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x00ff0000), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0xcc000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.8)},
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0xff000000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_B8G8R8A8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_B8G8R8X8_SRGB, PACKED_1x32(0x00ffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_B8G8R8X8_SRGB, PACKED_1x32(0x00ffffff), PACKED_1x32(0x000000bc), UNPACKED_1x1(0.0, 0.0, 0.502886458033, 1.0)},
+   {PIPE_FORMAT_B8G8R8X8_SRGB, PACKED_1x32(0x00ffffff), PACKED_1x32(0x000000ff), UNPACKED_1x1(0.0, 0.0, 1.0, 1.0)},
+   {PIPE_FORMAT_B8G8R8X8_SRGB, PACKED_1x32(0x00ffffff), PACKED_1x32(0x0000bc00), UNPACKED_1x1(0.0, 0.502886458033, 0.0, 1.0)},
+   {PIPE_FORMAT_B8G8R8X8_SRGB, PACKED_1x32(0x00ffffff), PACKED_1x32(0x0000ff00), UNPACKED_1x1(0.0, 1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_B8G8R8X8_SRGB, PACKED_1x32(0x00ffffff), PACKED_1x32(0x00bc0000), UNPACKED_1x1(0.502886458033, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_B8G8R8X8_SRGB, PACKED_1x32(0x00ffffff), PACKED_1x32(0x00ff0000), UNPACKED_1x1(1.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_B8G8R8X8_SRGB, PACKED_1x32(0x00ffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x000000cc), UNPACKED_1x1(0.0, 0.0, 0.0, 0.8)},
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x000000ff), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x0000bc00), UNPACKED_1x1(0.502886458033, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x0000ff00), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x00bc0000), UNPACKED_1x1(0.0, 0.502886458033, 0.0, 0.0)},
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x00ff0000), UNPACKED_1x1(0.0, 1.0, 0.0, 0.0)},
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0xbc000000), UNPACKED_1x1(0.0, 0.0, 0.502886458033, 0.0)},
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0xff000000), UNPACKED_1x1(0.0, 0.0, 1.0, 0.0)},
+   {PIPE_FORMAT_A8R8G8B8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_X8R8G8B8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_X8R8G8B8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x0000bc00), UNPACKED_1x1(0.502886458033, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_X8R8G8B8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x0000ff00), UNPACKED_1x1(1.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_X8R8G8B8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x00bc0000), UNPACKED_1x1(0.0, 0.502886458033, 0.0, 1.0)},
+   {PIPE_FORMAT_X8R8G8B8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x00ff0000), UNPACKED_1x1(0.0, 1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_X8R8G8B8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0xbc000000), UNPACKED_1x1(0.0, 0.0, 0.502886458033, 1.0)},
+   {PIPE_FORMAT_X8R8G8B8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0xff000000), UNPACKED_1x1(0.0, 0.0, 1.0, 1.0)},
+   {PIPE_FORMAT_X8R8G8B8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x000000cc), UNPACKED_1x1(0.0, 0.0, 0.0, 0.8)},
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x000000ff), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x0000bc00), UNPACKED_1x1(0.0, 0.0, 0.502886458033, 0.0)},
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x0000ff00), UNPACKED_1x1(0.0, 0.0, 1.0, 0.0)},
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x00bc0000), UNPACKED_1x1(0.0, 0.502886458033, 0.0, 0.0)},
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0x00ff0000), UNPACKED_1x1(0.0, 1.0, 0.0, 0.0)},
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0xbc000000), UNPACKED_1x1(0.502886458033, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0xff000000), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_A8B8G8R8_SRGB, PACKED_1x32(0xffffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_X8B8G8R8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_X8B8G8R8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x0000bc00), UNPACKED_1x1(0.0, 0.0, 0.502886458033, 1.0)},
+   {PIPE_FORMAT_X8B8G8R8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x0000ff00), UNPACKED_1x1(0.0, 0.0, 1.0, 1.0)},
+   {PIPE_FORMAT_X8B8G8R8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x00bc0000), UNPACKED_1x1(0.0, 0.502886458033, 0.0, 1.0)},
+   {PIPE_FORMAT_X8B8G8R8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0x00ff0000), UNPACKED_1x1(0.0, 1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_X8B8G8R8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0xbc000000), UNPACKED_1x1(0.502886458033, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_X8B8G8R8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0xff000000), UNPACKED_1x1(1.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_X8B8G8R8_SRGB, PACKED_1x32(0xffffff00), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 1.0, 1.0, 1.0)},
+
    /*
     * Mixed-signed formats
     */
@@ -189,6 +311,15 @@ util_format_test_cases[] =
    {PIPE_FORMAT_R8SG8SB8UX8U_NORM, PACKED_4x8(0xff, 0xff, 0xff, 0x00), PACKED_4x8(0x00, 0x81, 0x00, 0x00), UNPACKED_1x1( 0.0, -1.0, 0.0, 1.0)},
    {PIPE_FORMAT_R8SG8SB8UX8U_NORM, PACKED_4x8(0xff, 0xff, 0xff, 0x00), PACKED_4x8(0x00, 0x00, 0xff, 0x00), UNPACKED_1x1( 0.0,  0.0, 1.0, 1.0)},
 
+   {PIPE_FORMAT_R10SG10SB10SA2U_NORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1( 0.0,  0.0,  0.0, 0.0)},
+   {PIPE_FORMAT_R10SG10SB10SA2U_NORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x000001ff), UNPACKED_1x1( 1.0,  0.0,  0.0, 0.0)},
+   {PIPE_FORMAT_R10SG10SB10SA2U_NORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000201), UNPACKED_1x1(-1.0,  0.0,  0.0, 0.0)},
+   {PIPE_FORMAT_R10SG10SB10SA2U_NORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x0007fc00), UNPACKED_1x1( 0.0,  1.0,  0.0, 0.0)},
+   {PIPE_FORMAT_R10SG10SB10SA2U_NORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x00080400), UNPACKED_1x1( 0.0, -1.0,  0.0, 0.0)},
+   {PIPE_FORMAT_R10SG10SB10SA2U_NORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x1ff00000), UNPACKED_1x1( 0.0,  0.0,  1.0, 0.0)},
+   {PIPE_FORMAT_R10SG10SB10SA2U_NORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x20100000), UNPACKED_1x1( 0.0,  0.0, -1.0, 0.0)},
+   {PIPE_FORMAT_R10SG10SB10SA2U_NORM, PACKED_1x32(0xffffffff), PACKED_1x32(0xc0000000), UNPACKED_1x1( 0.0,  0.0,  0.0, 1.0)},
+
    {PIPE_FORMAT_R5SG5SB6U_NORM, PACKED_1x16(0xffff), PACKED_1x16(0x0000), UNPACKED_1x1( 0.0,  0.0, 0.0, 1.0)},
    {PIPE_FORMAT_R5SG5SB6U_NORM, PACKED_1x16(0xffff), PACKED_1x16(0x000f), UNPACKED_1x1( 1.0,  0.0, 0.0, 1.0)},
    {PIPE_FORMAT_R5SG5SB6U_NORM, PACKED_1x16(0xffff), PACKED_1x16(0x0011), UNPACKED_1x1(-1.0,  0.0, 0.0, 1.0)},
@@ -196,13 +327,76 @@ util_format_test_cases[] =
    {PIPE_FORMAT_R5SG5SB6U_NORM, PACKED_1x16(0xffff), PACKED_1x16(0x0220), UNPACKED_1x1( 0.0, -1.0, 0.0, 1.0)},
    {PIPE_FORMAT_R5SG5SB6U_NORM, PACKED_1x16(0xffff), PACKED_1x16(0xfc00), UNPACKED_1x1( 0.0,  0.0, 1.0, 1.0)},
 
+   {PIPE_FORMAT_R8G8Bx_SNORM, PACKED_2x8(0xff, 0xff), PACKED_2x8(0x00, 0x00), UNPACKED_1x1( 0.0,  0.0, 1.0, 1.0)},
+   {PIPE_FORMAT_R8G8Bx_SNORM, PACKED_2x8(0xff, 0xff), PACKED_2x8(0x7f, 0x00), UNPACKED_1x1( 1.0,  0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8Bx_SNORM, PACKED_2x8(0xff, 0xff), PACKED_2x8(0x81, 0x00), UNPACKED_1x1(-1.0,  0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8Bx_SNORM, PACKED_2x8(0xff, 0xff), PACKED_2x8(0x00, 0x7f), UNPACKED_1x1( 0.0,  1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8Bx_SNORM, PACKED_2x8(0xff, 0xff), PACKED_2x8(0x00, 0x81), UNPACKED_1x1( 0.0, -1.0, 0.0, 1.0)},
+
+   /*
+    * Depth-stencil formats
+    */
+
+   {PIPE_FORMAT_S8_USCALED, PACKED_1x8(0xff), PACKED_1x8(0x00), UNPACKED_1x1(0.0,   0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_S8_USCALED, PACKED_1x8(0xff), PACKED_1x8(0xff), UNPACKED_1x1(0.0, 255.0, 0.0, 0.0)},
+
+   {PIPE_FORMAT_Z16_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0x0000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_Z16_UNORM, PACKED_1x16(0xffff), PACKED_1x16(0xffff), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+
+   {PIPE_FORMAT_Z32_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_Z32_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+
+   {PIPE_FORMAT_Z32_FLOAT, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_Z32_FLOAT, PACKED_1x32(0xffffffff), PACKED_1x32(0x3f800000), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+
+   {PIPE_FORMAT_Z24_UNORM_S8_USCALED, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0,   0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_Z24_UNORM_S8_USCALED, PACKED_1x32(0xffffffff), PACKED_1x32(0x00ffffff), UNPACKED_1x1(1.0,   0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_Z24_UNORM_S8_USCALED, PACKED_1x32(0xffffffff), PACKED_1x32(0xff000000), UNPACKED_1x1(0.0, 255.0, 0.0, 0.0)},
+   {PIPE_FORMAT_Z24_UNORM_S8_USCALED, PACKED_1x32(0xffffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 255.0, 0.0, 0.0)},
+
+   {PIPE_FORMAT_S8_USCALED_Z24_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0,   0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_S8_USCALED_Z24_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0xffffff00), UNPACKED_1x1(1.0,   0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_S8_USCALED_Z24_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0x000000ff), UNPACKED_1x1(0.0, 255.0, 0.0, 0.0)},
+   {PIPE_FORMAT_S8_USCALED_Z24_UNORM, PACKED_1x32(0xffffffff), PACKED_1x32(0xffffffff), UNPACKED_1x1(1.0, 255.0, 0.0, 0.0)},
+
+   {PIPE_FORMAT_Z24X8_UNORM, PACKED_1x32(0x00ffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_Z24X8_UNORM, PACKED_1x32(0x00ffffff), PACKED_1x32(0x00ffffff), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+
+   {PIPE_FORMAT_X8Z24_UNORM, PACKED_1x32(0xffffff00), PACKED_1x32(0x00000000), UNPACKED_1x1(0.0, 0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_X8Z24_UNORM, PACKED_1x32(0xffffff00), PACKED_1x32(0xffffff00), UNPACKED_1x1(1.0, 0.0, 0.0, 0.0)},
+
+   {PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED, PACKED_2x32(0xffffffff, 0x000000ff), PACKED_2x32(0x00000000, 0x00000000), UNPACKED_1x1( 0.0,   0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED, PACKED_2x32(0xffffffff, 0x000000ff), PACKED_2x32(0x3f800000, 0x00000000), UNPACKED_1x1( 1.0,   0.0, 0.0, 0.0)},
+   {PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED, PACKED_2x32(0xffffffff, 0x000000ff), PACKED_2x32(0x00000000, 0x000000ff), UNPACKED_1x1( 0.0, 255.0, 0.0, 0.0)},
+
    /*
-    * TODO: Depth-stencil formats
+    * YUV formats
     */
 
+   {PIPE_FORMAT_R8G8_B8G8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0x00, 0x00), UNPACKED_2x1(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8_B8G8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0xff, 0x00, 0x00, 0x00), UNPACKED_2x1(1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8_B8G8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0xff, 0x00, 0x00), UNPACKED_2x1(0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8_B8G8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0xff, 0x00), UNPACKED_2x1(0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0)},
+   {PIPE_FORMAT_R8G8_B8G8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0x00, 0xff), UNPACKED_2x1(0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R8G8_B8G8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0xff, 0xff, 0xff, 0xff), UNPACKED_2x1(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_G8R8_G8B8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0x00, 0x00), UNPACKED_2x1(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_G8R8_G8B8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0xff, 0x00, 0x00, 0x00), UNPACKED_2x1(0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_G8R8_G8B8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0xff, 0x00, 0x00), UNPACKED_2x1(1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_G8R8_G8B8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0xff, 0x00), UNPACKED_2x1(0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_G8R8_G8B8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x00, 0x00, 0x00, 0xff), UNPACKED_2x1(0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0)},
+   {PIPE_FORMAT_G8R8_G8B8_UNORM, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0xff, 0xff, 0xff, 0xff), UNPACKED_2x1(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0)},
+
    /*
-    * TODO: YUV formats
+    * TODO: Exercise the UV channels as well.
     */
+   {PIPE_FORMAT_UYVY, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x80, 0x10, 0x80, 0x10), UNPACKED_2x1(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_UYVY, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x80, 0xeb, 0x80, 0x10), UNPACKED_2x1(1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_UYVY, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x80, 0x10, 0x80, 0xeb), UNPACKED_2x1(0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0)},
+
+   {PIPE_FORMAT_YUYV, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x10, 0x80, 0x10, 0x80), UNPACKED_2x1(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_YUYV, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0xeb, 0x80, 0x10, 0x80), UNPACKED_2x1(1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_YUYV, PACKED_4x8(0xff, 0xff, 0xff, 0xff), PACKED_4x8(0x10, 0x80, 0xeb, 0x80), UNPACKED_2x1(0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0)},
 
    /*
     * Compressed formats
@@ -712,6 +906,64 @@ util_format_test_cases[] =
    {PIPE_FORMAT_R16G16B16A16_FLOAT, PACKED_4x16(0xffff, 0xffff, 0xffff, 0xffff), PACKED_4x16(0x0000, 0x0000, 0x0000, 0x3c00), UNPACKED_1x1( 0.0,  0.0,  0.0,  1.0)},
    {PIPE_FORMAT_R16G16B16A16_FLOAT, PACKED_4x16(0xffff, 0xffff, 0xffff, 0xffff), PACKED_4x16(0x0000, 0x0000, 0x0000, 0xbc00), UNPACKED_1x1( 0.0,  0.0,  0.0, -1.0)},
    {PIPE_FORMAT_R16G16B16A16_FLOAT, PACKED_4x16(0xffff, 0xffff, 0xffff, 0xffff), PACKED_4x16(0x3c00, 0x3c00, 0x3c00, 0x3c00), UNPACKED_1x1( 1.0,  1.0,  1.0,  1.0)},
+
+   /*
+    * 32-bit fixed point formats
+    */
+
+   {PIPE_FORMAT_R32_FIXED, PACKED_1x32(0xffffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(  0.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R32_FIXED, PACKED_1x32(0xffffffff), PACKED_1x32(0x00010000), UNPACKED_1x1(  1.0, 0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R32_FIXED, PACKED_1x32(0xffffffff), PACKED_1x32(0xffff0000), UNPACKED_1x1( -1.0, 0.0, 0.0, 1.0)},
+
+   {PIPE_FORMAT_R32G32_FIXED, PACKED_2x32(0xffffffff, 0xffffffff), PACKED_2x32(0x00000000, 0x00000000), UNPACKED_1x1( 0.0,  0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R32G32_FIXED, PACKED_2x32(0xffffffff, 0xffffffff), PACKED_2x32(0x00010000, 0x00000000), UNPACKED_1x1( 1.0,  0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R32G32_FIXED, PACKED_2x32(0xffffffff, 0xffffffff), PACKED_2x32(0xffff0000, 0x00000000), UNPACKED_1x1(-1.0,  0.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R32G32_FIXED, PACKED_2x32(0xffffffff, 0xffffffff), PACKED_2x32(0x00000000, 0x00010000), UNPACKED_1x1( 0.0,  1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R32G32_FIXED, PACKED_2x32(0xffffffff, 0xffffffff), PACKED_2x32(0x00000000, 0xffff0000), UNPACKED_1x1( 0.0, -1.0, 0.0, 1.0)},
+   {PIPE_FORMAT_R32G32_FIXED, PACKED_2x32(0xffffffff, 0xffffffff), PACKED_2x32(0x00010000, 0x00010000), UNPACKED_1x1( 1.0,  1.0, 0.0, 1.0)},
+
+   {PIPE_FORMAT_R32G32B32_FIXED, PACKED_3x32(0xffffffff, 0xffffffff, 0xffffffff), PACKED_3x32(0x00000000, 0x00000000, 0x00000000), UNPACKED_1x1( 0.0,  0.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R32G32B32_FIXED, PACKED_3x32(0xffffffff, 0xffffffff, 0xffffffff), PACKED_3x32(0x00010000, 0x00000000, 0x00000000), UNPACKED_1x1( 1.0,  0.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R32G32B32_FIXED, PACKED_3x32(0xffffffff, 0xffffffff, 0xffffffff), PACKED_3x32(0xffff0000, 0x00000000, 0x00000000), UNPACKED_1x1(-1.0,  0.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R32G32B32_FIXED, PACKED_3x32(0xffffffff, 0xffffffff, 0xffffffff), PACKED_3x32(0x00000000, 0x00010000, 0x00000000), UNPACKED_1x1( 0.0,  1.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R32G32B32_FIXED, PACKED_3x32(0xffffffff, 0xffffffff, 0xffffffff), PACKED_3x32(0x00000000, 0xffff0000, 0x00000000), UNPACKED_1x1( 0.0, -1.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R32G32B32_FIXED, PACKED_3x32(0xffffffff, 0xffffffff, 0xffffffff), PACKED_3x32(0x00000000, 0x00000000, 0x00010000), UNPACKED_1x1( 0.0,  0.0,  1.0, 1.0)},
+   {PIPE_FORMAT_R32G32B32_FIXED, PACKED_3x32(0xffffffff, 0xffffffff, 0xffffffff), PACKED_3x32(0x00000000, 0x00000000, 0xffff0000), UNPACKED_1x1( 0.0,  0.0, -1.0, 1.0)},
+   {PIPE_FORMAT_R32G32B32_FIXED, PACKED_3x32(0xffffffff, 0xffffffff, 0xffffffff), PACKED_3x32(0x00010000, 0x00010000, 0x00010000), UNPACKED_1x1( 1.0,  1.0,  1.0, 1.0)},
+
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0x00000000, 0x00000000, 0x00000000, 0x00000000), UNPACKED_1x1( 0.0,  0.0,  0.0,  0.0)},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0x00010000, 0x00000000, 0x00000000, 0x00000000), UNPACKED_1x1( 1.0,  0.0,  0.0,  0.0)},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0xffff0000, 0x00000000, 0x00000000, 0x00000000), UNPACKED_1x1(-1.0,  0.0,  0.0,  0.0)},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0x00000000, 0x00010000, 0x00000000, 0x00000000), UNPACKED_1x1( 0.0,  1.0,  0.0,  0.0)},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0x00000000, 0xffff0000, 0x00000000, 0x00000000), UNPACKED_1x1( 0.0, -1.0,  0.0,  0.0)},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0x00000000, 0x00000000, 0x00010000, 0x00000000), UNPACKED_1x1( 0.0,  0.0,  1.0,  0.0)},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0x00000000, 0x00000000, 0xffff0000, 0x00000000), UNPACKED_1x1( 0.0,  0.0, -1.0,  0.0)},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0x00000000, 0x00000000, 0x00000000, 0x00010000), UNPACKED_1x1( 0.0,  0.0,  0.0,  1.0)},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0x00000000, 0x00000000, 0x00000000, 0xffff0000), UNPACKED_1x1( 0.0,  0.0,  0.0, -1.0)},
+   {PIPE_FORMAT_R32G32B32A32_FIXED, PACKED_4x32(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff), PACKED_4x32(0x00010000, 0x00010000, 0x00010000, 0x00010000), UNPACKED_1x1( 1.0,  1.0,  1.0,  1.0)},
+
+   /*
+    * D3D9 specific vertex formats
+    */
+
+   {PIPE_FORMAT_R10G10B10X2_USCALED, PACKED_1x32(0x3fffffff), PACKED_1x32(0x00000000), UNPACKED_1x1(   0.0,    0.0,    0.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_USCALED, PACKED_1x32(0x3fffffff), PACKED_1x32(0x000003ff), UNPACKED_1x1(1023.0,    0.0,    0.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_USCALED, PACKED_1x32(0x3fffffff), PACKED_1x32(0x000ffc00), UNPACKED_1x1(   0.0, 1023.0,    0.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_USCALED, PACKED_1x32(0x3fffffff), PACKED_1x32(0x3ff00000), UNPACKED_1x1(   0.0,    0.0, 1023.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_USCALED, PACKED_1x32(0x3fffffff), PACKED_1x32(0x3fffffff), UNPACKED_1x1(1023.0, 1023.0, 1023.0, 1.0)},
+
+   {PIPE_FORMAT_R10G10B10X2_SNORM, PACKED_1x32(0x3fffffff), PACKED_1x32(0x00000000), UNPACKED_1x1( 0.0,  0.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_SNORM, PACKED_1x32(0x3fffffff), PACKED_1x32(0x000001ff), UNPACKED_1x1( 1.0,  0.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_SNORM, PACKED_1x32(0x3fffffff), PACKED_1x32(0x00000201), UNPACKED_1x1(-1.0,  0.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_SNORM, PACKED_1x32(0x3fffffff), PACKED_1x32(0x0007fc00), UNPACKED_1x1( 0.0,  1.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_SNORM, PACKED_1x32(0x3fffffff), PACKED_1x32(0x00080400), UNPACKED_1x1( 0.0, -1.0,  0.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_SNORM, PACKED_1x32(0x3fffffff), PACKED_1x32(0x1ff00000), UNPACKED_1x1( 0.0,  0.0,  1.0, 1.0)},
+   {PIPE_FORMAT_R10G10B10X2_SNORM, PACKED_1x32(0x3fffffff), PACKED_1x32(0x20100000), UNPACKED_1x1( 0.0,  0.0, -1.0, 1.0)},
+
+   /*
+    * Special formats that not fit anywhere else
+    */
+
 };
 
 
diff --git a/src/gallium/auxiliary/util/u_format_yuv.c b/src/gallium/auxiliary/util/u_format_yuv.c
new file mode 100644
index 00000000000..ab8bf29c97b
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_format_yuv.c
@@ -0,0 +1,1047 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.
+ * 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 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
+ * THE COPYRIGHT HOLDERS, AUTHORS 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.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ **************************************************************************/
+
+
+/**
+ * @file
+ * YUV and RGB subsampled formats conversion.
+ *
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ */
+
+
+#include "util/u_format_yuv.h"
+
+
+void
+util_format_r8g8_b8g8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                         const uint8_t *src_row, unsigned src_stride,
+                                         unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      float *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      uint32_t value;
+      float r, g0, g1, b;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         value = *src++;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         r  = ubyte_to_float((value >>  0) & 0xff);
+         g0 = ubyte_to_float((value >>  8) & 0xff);
+         b  = ubyte_to_float((value >> 16) & 0xff);
+         g1 = ubyte_to_float((value >> 24) & 0xff);
+
+         dst[0] = r;    /* r */
+         dst[1] = g0;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 1.0f; /* a */
+         dst += 4;
+
+         dst[0] = r;    /* r */
+         dst[1] = g1;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 1.0f; /* a */
+         dst += 4;
+      }
+
+      if (x < width) {
+         value = *src;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         r  = ubyte_to_float((value >>  0) & 0xff);
+         g0 = ubyte_to_float((value >>  8) & 0xff);
+         b  = ubyte_to_float((value >> 16) & 0xff);
+         g1 = ubyte_to_float((value >> 24) & 0xff);
+
+         dst[0] = r;    /* r */
+         dst[1] = g0;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 1.0f; /* a */
+      }
+
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_r8g8_b8g8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                          const uint8_t *src_row, unsigned src_stride,
+                                          unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      uint8_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      uint32_t value;
+      uint8_t r, g0, g1, b;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         value = *src++;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         r  = (value >>  0) & 0xff;
+         g0 = (value >>  8) & 0xff;
+         b  = (value >> 16) & 0xff;
+         g1 = (value >> 24) & 0xff;
+
+         dst[0] = r;    /* r */
+         dst[1] = g0;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 0xff; /* a */
+         dst += 4;
+
+         dst[0] = r;    /* r */
+         dst[1] = g1;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 0xff; /* a */
+         dst += 4;
+      }
+
+      if (x < width) {
+         value = *src;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         r  = (value >>  0) & 0xff;
+         g0 = (value >>  8) & 0xff;
+         b  = (value >> 16) & 0xff;
+         g1 = (value >> 24) & 0xff;
+
+         dst[0] = r;    /* r */
+         dst[1] = g0;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 0xff; /* a */
+      }
+
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_r8g8_b8g8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                       const float *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      const float *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      float r, g0, g1, b;
+      uint32_t value;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         r  = 0.5f*(src[0] + src[4]);
+         g0 = src[1];
+         g1 = src[5];
+         b  = 0.5f*(src[2] + src[6]);
+
+         value  = float_to_ubyte(r);
+         value |= float_to_ubyte(g0) <<  8;
+         value |= float_to_ubyte(b)  << 16;
+         value |= float_to_ubyte(g1) << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 8;
+      }
+
+      if (x < width) {
+         r  = src[0];
+         g0 = src[1];
+         g1 = 0;
+         b  = src[2];
+
+         value  = float_to_ubyte(r);
+         value |= float_to_ubyte(g0) <<  8;
+         value |= float_to_ubyte(b)  << 16;
+         value |= float_to_ubyte(g1) << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst = value;
+      }
+
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_r8g8_b8g8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                        const uint8_t *src_row, unsigned src_stride,
+                                        unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      const uint8_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      uint32_t r, g0, g1, b;
+      uint32_t value;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         r  = (src[0] + src[4] + 1) >> 1;
+         g0 = src[1];
+         g1 = src[5];
+         b  = (src[2] + src[6] + 1) >> 1;
+
+         value  = r;
+         value |= g0 <<  8;
+         value |= b  << 16;
+         value |= g1 << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 8;
+      }
+
+      if (x < width) {
+         r  = src[0];
+         g0 = src[1];
+         g1 = 0;
+         b  = src[2];
+
+         value  = r;
+         value |= g0 <<  8;
+         value |= b  << 16;
+         value |= g1 << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst = value;
+      }
+
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_r8g8_b8g8_unorm_fetch_rgba_float(float *dst, const uint8_t *src,
+                                        unsigned i, unsigned j)
+{
+   assert(i < 2);
+   assert(j < 1);
+
+   dst[0] = ubyte_to_float(src[0]);             /* r */
+   dst[1] = ubyte_to_float(src[1 + 2*i]);       /* g */
+   dst[2] = ubyte_to_float(src[2]);             /* b */
+   dst[3] = 1.0f;                               /* a */
+}
+
+
+void
+util_format_g8r8_g8b8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                         const uint8_t *src_row, unsigned src_stride,
+                                         unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      float *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      uint32_t value;
+      float r, g0, g1, b;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         value = *src++;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         g0 = ubyte_to_float((value >>  0) & 0xff);
+         r  = ubyte_to_float((value >>  8) & 0xff);
+         g1 = ubyte_to_float((value >> 16) & 0xff);
+         b  = ubyte_to_float((value >> 24) & 0xff);
+
+         dst[0] = r;    /* r */
+         dst[1] = g0;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 1.0f; /* a */
+         dst += 4;
+
+         dst[0] = r;    /* r */
+         dst[1] = g1;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 1.0f; /* a */
+         dst += 4;
+      }
+
+      if (x < width) {
+         value = *src;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         g0 = ubyte_to_float((value >>  0) & 0xff);
+         r  = ubyte_to_float((value >>  8) & 0xff);
+         g1 = ubyte_to_float((value >> 16) & 0xff);
+         b  = ubyte_to_float((value >> 24) & 0xff);
+
+         dst[0] = r;    /* r */
+         dst[1] = g0;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 1.0f; /* a */
+      }
+
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_g8r8_g8b8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                          const uint8_t *src_row, unsigned src_stride,
+                                          unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      uint8_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      uint32_t value;
+      uint8_t r, g0, g1, b;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         value = *src++;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         g0 = (value >>  0) & 0xff;
+         r  = (value >>  8) & 0xff;
+         g1 = (value >> 16) & 0xff;
+         b  = (value >> 24) & 0xff;
+
+         dst[0] = r;    /* r */
+         dst[1] = g0;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 0xff; /* a */
+         dst += 4;
+
+         dst[0] = r;    /* r */
+         dst[1] = g1;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 0xff; /* a */
+         dst += 4;
+      }
+
+      if (x < width) {
+         value = *src;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         g0 = (value >>  0) & 0xff;
+         r  = (value >>  8) & 0xff;
+         g1 = (value >> 16) & 0xff;
+         b  = (value >> 24) & 0xff;
+
+         dst[0] = r;    /* r */
+         dst[1] = g0;   /* g */
+         dst[2] = b;    /* b */
+         dst[3] = 0xff; /* a */
+      }
+
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_g8r8_g8b8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                       const float *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      const float *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      float r, g0, g1, b;
+      uint32_t value;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         r  = 0.5f*(src[0] + src[4]);
+         g0 = src[1];
+         g1 = src[5];
+         b  = 0.5f*(src[2] + src[6]);
+
+         value  = float_to_ubyte(g0);
+         value |= float_to_ubyte(r)  <<  8;
+         value |= float_to_ubyte(g1) << 16;
+         value |= float_to_ubyte(b)  << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 8;
+      }
+
+      if (x < width) {
+         r  = src[0];
+         g0 = src[1];
+         g1 = 0;
+         b  = src[2];
+
+         value  = float_to_ubyte(g0);
+         value |= float_to_ubyte(r)  <<  8;
+         value |= float_to_ubyte(g1) << 16;
+         value |= float_to_ubyte(b)  << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst = value;
+      }
+
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_g8r8_g8b8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                        const uint8_t *src_row, unsigned src_stride,
+                                        unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      const uint8_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      uint32_t r, g0, g1, b;
+      uint32_t value;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         r  = (src[0] + src[4] + 1) >> 1;
+         g0 = src[1];
+         g1 = src[5];
+         b  = (src[2] + src[6] + 1) >> 1;
+
+         value  = g0;
+         value |= r  <<  8;
+         value |= g1 << 16;
+         value |= b  << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 8;
+      }
+
+      if (x < width) {
+         r  = src[0];
+         g0 = src[1];
+         g1 = 0;
+         b  = src[2];
+
+         value  = g0;
+         value |= r  <<  8;
+         value |= g1 << 16;
+         value |= b  << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst = value;
+      }
+
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_g8r8_g8b8_unorm_fetch_rgba_float(float *dst, const uint8_t *src,
+                                        unsigned i, unsigned j)
+{
+   assert(i < 2);
+   assert(j < 1);
+
+   dst[0] = ubyte_to_float(src[1]);             /* r */
+   dst[1] = ubyte_to_float(src[0 + 2*i]);       /* g */
+   dst[2] = ubyte_to_float(src[3]);             /* b */
+   dst[3] = 1.0f;                               /* a */
+}
+
+
+void
+util_format_uyvy_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                              const uint8_t *src_row, unsigned src_stride,
+                              unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      float *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      uint32_t value;
+      uint8_t y0, y1, u, v;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         value = *src++;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         u  = (value >>  0) & 0xff;
+         y0 = (value >>  8) & 0xff;
+         v  = (value >> 16) & 0xff;
+         y1 = (value >> 24) & 0xff;
+
+         util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 1.0f; /* a */
+         dst += 4;
+
+         util_format_yuv_to_rgb_float(y1, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 1.0f; /* a */
+         dst += 4;
+      }
+
+      if (x < width) {
+         value = *src;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         u  = (value >>  0) & 0xff;
+         y0 = (value >>  8) & 0xff;
+         v  = (value >> 16) & 0xff;
+         y1 = (value >> 24) & 0xff;
+
+         util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 1.0f; /* a */
+      }
+
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_uyvy_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                               const uint8_t *src_row, unsigned src_stride,
+                               unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      uint8_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      uint32_t value;
+      uint8_t y0, y1, u, v;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         value = *src++;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         u  = (value >>  0) & 0xff;
+         y0 = (value >>  8) & 0xff;
+         v  = (value >> 16) & 0xff;
+         y1 = (value >> 24) & 0xff;
+
+         util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 0xff; /* a */
+         dst += 4;
+
+         util_format_yuv_to_rgb_8unorm(y1, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 0xff; /* a */
+         dst += 4;
+      }
+
+      if (x < width) {
+         value = *src;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         u  = (value >>  0) & 0xff;
+         y0 = (value >>  8) & 0xff;
+         v  = (value >> 16) & 0xff;
+         y1 = (value >> 24) & 0xff;
+
+         util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 0xff; /* a */
+      }
+
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_uyvy_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                            const float *src_row, unsigned src_stride,
+                            unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      const float *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      uint8_t y0, y1, u, v;
+      uint32_t value;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         uint8_t y0, y1, u0, u1, v0, v1, u, v;
+
+         util_format_rgb_float_to_yuv(src[0], src[1], src[2],
+                                      &y0, &u0, &v0);
+         util_format_rgb_float_to_yuv(src[4], src[5], src[6],
+                                      &y1, &u1, &v1);
+
+         u = (u0 + u1 + 1) >> 1;
+         v = (v0 + v1 + 1) >> 1;
+
+         value  = u;
+         value |= y0 <<  8;
+         value |= v  << 16;
+         value |= y1 << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 8;
+      }
+
+      if (x < width) {
+         util_format_rgb_float_to_yuv(src[0], src[1], src[2],
+                                      &y0, &u, &v);
+         y1 = 0;
+
+         value  = u;
+         value |= y0 <<  8;
+         value |= v  << 16;
+         value |= y1 << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst = value;
+      }
+
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_uyvy_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                             const uint8_t *src_row, unsigned src_stride,
+                             unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      const uint8_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      uint8_t y0, y1, u, v;
+      uint32_t value;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         uint8_t y0, y1, u0, u1, v0, v1, u, v;
+
+         util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
+                                       &y0, &u0, &v0);
+         util_format_rgb_8unorm_to_yuv(src[4], src[5], src[6],
+                                       &y1, &u1, &v1);
+
+         u = (u0 + u1 + 1) >> 1;
+         v = (v0 + v1 + 1) >> 1;
+
+         value  = u;
+         value |= y0 <<  8;
+         value |= v  << 16;
+         value |= y1 << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 8;
+      }
+
+      if (x < width) {
+         util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
+                                       &y0, &u, &v);
+         y1 = 0;
+
+         value  = u;
+         value |= y0 <<  8;
+         value |= v  << 16;
+         value |= y1 << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst = value;
+      }
+
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_uyvy_fetch_rgba_float(float *dst, const uint8_t *src,
+                             unsigned i, unsigned j)
+{
+   uint8_t y, u, v;
+
+   assert(i < 2);
+   assert(j < 1);
+
+   y = src[1 + i*2];
+   u = src[0];
+   v = src[2];
+
+   util_format_yuv_to_rgb_float(y, u, v, &dst[0], &dst[1], &dst[2]);
+
+   dst[3] = 1.0f;
+}
+
+
+void
+util_format_yuyv_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                              const uint8_t *src_row, unsigned src_stride,
+                              unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      float *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      uint32_t value;
+      uint8_t y0, y1, u, v;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         value = *src++;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         y0 = (value >>  0) & 0xff;
+         u  = (value >>  8) & 0xff;
+         y1 = (value >> 16) & 0xff;
+         v  = (value >> 24) & 0xff;
+
+         util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 1.0f; /* a */
+         dst += 4;
+
+         util_format_yuv_to_rgb_float(y1, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 1.0f; /* a */
+         dst += 4;
+      }
+
+      if (x < width) {
+         value = *src;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         y0 = (value >>  0) & 0xff;
+         u  = (value >>  8) & 0xff;
+         y1 = (value >> 16) & 0xff;
+         v  = (value >> 24) & 0xff;
+
+         util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 1.0f; /* a */
+      }
+
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_yuyv_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                               const uint8_t *src_row, unsigned src_stride,
+                               unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      uint8_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      uint32_t value;
+      uint8_t y0, y1, u, v;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         value = *src++;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         y0 = (value >>  0) & 0xff;
+         u  = (value >>  8) & 0xff;
+         y1 = (value >> 16) & 0xff;
+         v  = (value >> 24) & 0xff;
+
+         util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 0xff; /* a */
+         dst += 4;
+
+         util_format_yuv_to_rgb_8unorm(y1, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 0xff; /* a */
+         dst += 4;
+      }
+
+      if (x < width) {
+         value = *src;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         y0 = (value >>  0) & 0xff;
+         u  = (value >>  8) & 0xff;
+         y1 = (value >> 16) & 0xff;
+         v  = (value >> 24) & 0xff;
+
+         util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
+         dst[3] = 0xff; /* a */
+      }
+
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+
+void
+util_format_yuyv_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                            const float *src_row, unsigned src_stride,
+                            unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      const float *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      uint8_t y0, y1, u, v;
+      uint32_t value;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         uint8_t y0, y1, u0, u1, v0, v1, u, v;
+
+         util_format_rgb_float_to_yuv(src[0], src[1], src[2],
+                                      &y0, &u0, &v0);
+         util_format_rgb_float_to_yuv(src[4], src[5], src[6],
+                                      &y1, &u1, &v1);
+
+         u = (u0 + u1 + 1) >> 1;
+         v = (v0 + v1 + 1) >> 1;
+
+         value  = y0;
+         value |= u  <<  8;
+         value |= y1 << 16;
+         value |= v  << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 8;
+      }
+
+      if (x < width) {
+         util_format_rgb_float_to_yuv(src[0], src[1], src[2],
+                                      &y0, &u, &v);
+         y1 = 0;
+
+         value  = y0;
+         value |= u  <<  8;
+         value |= y1 << 16;
+         value |= v  << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst = value;
+      }
+
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_yuyv_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                             const uint8_t *src_row, unsigned src_stride,
+                             unsigned width, unsigned height)
+{
+   unsigned x, y;
+
+   for (y = 0; y < height; y += 1) {
+      const uint8_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      uint8_t y0, y1, u, v;
+      uint32_t value;
+
+      for (x = 0; x + 1 < width; x += 2) {
+         uint8_t y0, y1, u0, u1, v0, v1, u, v;
+
+         util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
+                                       &y0, &u0, &v0);
+         util_format_rgb_8unorm_to_yuv(src[4], src[5], src[6],
+                                       &y1, &u1, &v1);
+
+         u = (u0 + u1 + 1) >> 1;
+         v = (v0 + v1 + 1) >> 1;
+
+         value  = y0;
+         value |= u  <<  8;
+         value |= y1 << 16;
+         value |= v  << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst++ = value;
+
+         src += 8;
+      }
+
+      if (x < width) {
+         util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
+                                       &y0, &u, &v);
+         y1 = 0;
+
+         value  = y0;
+         value |= u  <<  8;
+         value |= y1 << 16;
+         value |= v  << 24;
+
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+
+         *dst = value;
+      }
+
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+
+void
+util_format_yuyv_fetch_rgba_float(float *dst, const uint8_t *src,
+                             unsigned i, unsigned j)
+{
+   uint8_t y, u, v;
+
+   assert(i < 2);
+   assert(j < 1);
+
+   y = src[0 + i*2];
+   u = src[1];
+   v = src[3];
+
+   util_format_yuv_to_rgb_float(y, u, v, &dst[0], &dst[1], &dst[2]);
+
+   dst[3] = 1.0f;
+}
diff --git a/src/gallium/auxiliary/util/u_format_yuv.h b/src/gallium/auxiliary/util/u_format_yuv.h
new file mode 100644
index 00000000000..dc9632346d1
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_format_yuv.h
@@ -0,0 +1,223 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.
+ * 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 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
+ * THE COPYRIGHT HOLDERS, AUTHORS 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.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ **************************************************************************/
+
+
+/**
+ * @file
+ * YUV colorspace conversion.
+ *
+ * @author Brian Paul <brianp@vmware.com>
+ * @author Michal Krol <michal@vmware.com>
+ * @author Jose Fonseca <jfonseca@vmware.com>
+ *
+ * See also:
+ * - http://www.fourcc.org/fccyvrgb.php
+ * - http://msdn.microsoft.com/en-us/library/ms893078
+ * - http://en.wikipedia.org/wiki/YUV
+ */
+
+
+#ifndef U_FORMAT_YUV_H_
+#define U_FORMAT_YUV_H_
+
+
+#include "pipe/p_compiler.h"
+#include "u_math.h"
+
+
+/*
+ * TODO: Ensure we use consistent and right floating formulas, with enough
+ * precision in the coefficients.
+ */
+
+static INLINE void
+util_format_rgb_float_to_yuv(float r, float g, float b,
+                             uint8_t *y, uint8_t *u, uint8_t *v)
+{
+   const float _r = CLAMP(r, 0.0f, 1.0f);
+   const float _g = CLAMP(g, 0.0f, 1.0f);
+   const float _b = CLAMP(b, 0.0f, 1.0f);
+
+   const float scale = 255.0f;
+
+   const int _y = scale * ( (0.257f * _r) + (0.504f * _g) + (0.098f * _b));
+   const int _u = scale * (-(0.148f * _r) - (0.291f * _g) + (0.439f * _b));
+   const int _v = scale * ( (0.439f * _r) - (0.368f * _g) - (0.071f * _b));
+
+   *y = _y + 16; 
+   *u = _u + 128; 
+   *v = _v + 128; 
+}
+
+
+static INLINE void
+util_format_yuv_to_rgb_float(uint8_t y, uint8_t u, uint8_t v,
+                             float *r, float *g, float *b)
+{
+   const int _y = y - 16;
+   const int _u = u - 128;
+   const int _v = v - 128;
+
+   const float y_factor = 255.0f / 219.0f;
+
+   const float scale = 1.0f / 255.0f;
+
+   *r = scale * (y_factor * _y               + 1.596f * _v);
+   *g = scale * (y_factor * _y - 0.391f * _u - 0.813f * _v);
+   *b = scale * (y_factor * _y + 2.018f * _u              );
+}
+
+
+static INLINE void
+util_format_rgb_8unorm_to_yuv(uint8_t r, uint8_t g, uint8_t b,
+                	      uint8_t *y, uint8_t *u, uint8_t *v)
+{
+   *y = ((  66 * r + 129 * g +  25 * b + 128) >> 8) +  16;
+   *u = (( -38 * r -  74 * g + 112 * b + 128) >> 8) + 128;
+   *v = (( 112 * r -  94 * g -  18 * b + 128) >> 8) + 128;
+}
+
+
+static INLINE void
+util_format_yuv_to_rgb_8unorm(uint8_t y, uint8_t u, uint8_t v,
+                              uint8_t *r, uint8_t *g, uint8_t *b)
+{
+   const int _y = y - 16;
+   const int _u = u - 128;
+   const int _v = v - 128;
+
+   const int _r = (298 * _y            + 409 * _v + 128) >> 8;
+   const int _g = (298 * _y - 100 * _u - 208 * _v + 128) >> 8;
+   const int _b = (298 * _y + 516 * _u            + 128) >> 8;
+
+   *r = CLAMP(_r, 0, 255);
+   *g = CLAMP(_g, 0, 255);
+   *b = CLAMP(_b, 0, 255);
+}
+
+
+
+void
+util_format_uyvy_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                              const uint8_t *src_row, unsigned src_stride,
+                              unsigned width, unsigned height);
+
+void
+util_format_uyvy_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                               const uint8_t *src_row, unsigned src_stride,
+                               unsigned width, unsigned height);
+
+void
+util_format_uyvy_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                            const float *src_row, unsigned src_stride,
+                            unsigned width, unsigned height);
+
+void
+util_format_uyvy_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                             const uint8_t *src_row, unsigned src_stride,
+                             unsigned width, unsigned height);
+
+void
+util_format_uyvy_fetch_rgba_float(float *dst, const uint8_t *src,
+                             unsigned i, unsigned j);
+
+void
+util_format_yuyv_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                              const uint8_t *src_row, unsigned src_stride,
+                              unsigned width, unsigned height);
+
+void
+util_format_yuyv_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                               const uint8_t *src_row, unsigned src_stride,
+                               unsigned width, unsigned height);
+
+void
+util_format_yuyv_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                            const float *src_row, unsigned src_stride,
+                            unsigned width, unsigned height);
+
+void
+util_format_yuyv_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                             const uint8_t *src_row, unsigned src_stride,
+                             unsigned width, unsigned height);
+
+void
+util_format_yuyv_fetch_rgba_float(float *dst, const uint8_t *src,
+                             unsigned i, unsigned j);
+
+
+void
+util_format_r8g8_b8g8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                         const uint8_t *src_row, unsigned src_stride,
+                                         unsigned width, unsigned height);
+
+void
+util_format_r8g8_b8g8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                          const uint8_t *src_row, unsigned src_stride,
+                                          unsigned width, unsigned height);
+
+void
+util_format_r8g8_b8g8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                       const float *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height);
+
+void
+util_format_r8g8_b8g8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                        const uint8_t *src_row, unsigned src_stride,
+                                        unsigned width, unsigned height);
+
+void
+util_format_r8g8_b8g8_unorm_fetch_rgba_float(float *dst, const uint8_t *src,
+                                        unsigned i, unsigned j);
+
+void
+util_format_g8r8_g8b8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
+                                         const uint8_t *src_row, unsigned src_stride,
+                                         unsigned width, unsigned height);
+
+void
+util_format_g8r8_g8b8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                          const uint8_t *src_row, unsigned src_stride,
+                                          unsigned width, unsigned height);
+
+void
+util_format_g8r8_g8b8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
+                                       const float *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height);
+
+void
+util_format_g8r8_g8b8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
+                                        const uint8_t *src_row, unsigned src_stride,
+                                        unsigned width, unsigned height);
+
+void
+util_format_g8r8_g8b8_unorm_fetch_rgba_float(float *dst, const uint8_t *src,
+                                        unsigned i, unsigned j);
+
+
+
+#endif /* U_FORMAT_YUV_H_ */
diff --git a/src/gallium/auxiliary/util/u_format_zs.c b/src/gallium/auxiliary/util/u_format_zs.c
new file mode 100644
index 00000000000..792d69c214c
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_format_zs.c
@@ -0,0 +1,920 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.
+ * 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 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
+ * THE COPYRIGHT HOLDERS, AUTHORS 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.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ **************************************************************************/
+
+
+#include "u_debug.h"
+#include "u_math.h"
+#include "u_format_zs.h"
+
+
+/*
+ * z32_unorm conversion functions
+ */
+
+static INLINE uint16_t
+z32_unorm_to_z16_unorm(uint32_t z)
+{
+   /* z * 0xffff / 0xffffffff */
+   return z >> 16;
+}
+
+static INLINE uint32_t
+z16_unorm_to_z32_unorm(uint16_t z)
+{
+   /* z * 0xffffffff / 0xffff */
+   return (z << 16) | z;
+}
+
+static INLINE uint32_t
+z32_unorm_to_z24_unorm(uint32_t z)
+{
+   /* z * 0xffffff / 0xffffffff */
+   return z >> 8;
+}
+
+static INLINE uint32_t
+z24_unorm_to_z32_unorm(uint32_t z)
+{
+   /* z * 0xffffffff / 0xffffff */
+   return (z << 8) | (z >> 16);
+}
+
+
+/*
+ * z32_float conversion functions
+ */
+
+static INLINE uint16_t
+z32_float_to_z16_unorm(float z)
+{
+   const float scale = 0xffff;
+   return (uint16_t)(z * scale);
+}
+
+static INLINE float
+z16_unorm_to_z32_float(uint16_t z)
+{
+   const float scale = 1.0 / 0xffff;
+   return (float)(z * scale);
+}
+
+static INLINE uint32_t
+z32_float_to_z24_unorm(float z)
+{
+   const double scale = 0xffffff;
+   return (uint32_t)(z * scale) & 0xffffff;
+}
+
+static INLINE float
+z24_unorm_to_z32_float(uint32_t z)
+{
+   const double scale = 1.0 / 0xffffff;
+   return (float)(z * scale);
+}
+
+static INLINE uint32_t
+z32_float_to_z32_unorm(float z)
+{
+   const double scale = 0xffffffff;
+   return (uint32_t)(z * scale);
+}
+
+static INLINE float
+z32_unorm_to_z32_float(uint32_t z)
+{
+   const double scale = 1.0 / 0xffffffff;
+   return (float)(z * scale);
+}
+
+
+void
+util_format_s8_uscaled_unpack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride,
+                                         const uint8_t *src_row, unsigned src_stride,
+                                         unsigned width, unsigned height)
+{
+   unsigned y;
+   for(y = 0; y < height; ++y) {
+      memcpy(dst_row, src_row, width);
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_s8_uscaled_pack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned y;
+   for(y = 0; y < height; ++y) {
+      memcpy(dst_row, src_row, width);
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z16_unorm_unpack_z_float(float *dst_row, unsigned dst_stride,
+                                     const uint8_t *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      float *dst = dst_row;
+      const uint16_t *src = (const uint16_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint16_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap16(value);
+#endif
+         *dst++ = z16_unorm_to_z32_float(value);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z16_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride,
+                                   const float *src_row, unsigned src_stride,
+                                   unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const float *src = src_row;
+      uint16_t *dst = (uint16_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint16_t value;
+         value = z32_float_to_z16_unorm(*src++);
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap16(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z16_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint32_t *dst = dst_row;
+      const uint16_t *src = (const uint16_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint16_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap16(value);
+#endif
+         *dst++ = z16_unorm_to_z32_unorm(value);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z16_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride,
+                                     const uint32_t *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint32_t *src = src_row;
+      uint16_t *dst = (uint16_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint16_t value;
+         value = z32_unorm_to_z16_unorm(*src++);
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap16(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z32_unorm_unpack_z_float(float *dst_row, unsigned dst_stride,
+                                     const uint8_t *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      float *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = z32_unorm_to_z32_float(value);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z32_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride,
+                                   const float *src_row, unsigned src_stride,
+                                   unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const float *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value;
+         value = z32_float_to_z32_unorm(*src++);
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z32_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned y;
+   for(y = 0; y < height; ++y) {
+      memcpy(dst_row, src_row, width * 4);
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z32_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride,
+                                     const uint32_t *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height)
+{
+   unsigned y;
+   for(y = 0; y < height; ++y) {
+      memcpy(dst_row, src_row, width * 4);
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z32_float_unpack_z_float(float *dst_row, unsigned dst_stride,
+                                     const uint8_t *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height)
+{
+   unsigned y;
+   for(y = 0; y < height; ++y) {
+      memcpy(dst_row, src_row, width * 4);
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z32_float_pack_z_float(uint8_t *dst_row, unsigned dst_stride,
+                                   const float *src_row, unsigned src_stride,
+                                   unsigned width, unsigned height)
+{
+   unsigned y;
+   for(y = 0; y < height; ++y) {
+      memcpy(dst_row, src_row, width * 4);
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z32_float_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint32_t *dst = dst_row;
+      const float *src = (const float *)src_row;
+      for(x = 0; x < width; ++x) {
+         *dst++ = z32_float_to_z32_unorm(*src++);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z32_float_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride,
+                                     const uint32_t *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint32_t *src = src_row;
+      float *dst = (float *)dst_row;
+      for(x = 0; x < width; ++x) {
+         *dst++ = z32_unorm_to_z32_float(*src++);
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z24_unorm_s8_uscaled_unpack_z_float(float *dst_row, unsigned dst_stride,
+                                                const uint8_t *src_row, unsigned src_stride,
+                                                unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      float *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = z24_unorm_to_z32_float(value & 0xffffff);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z24_unorm_s8_uscaled_pack_z_float(uint8_t *dst_row, unsigned dst_stride,
+                                              const float *src_row, unsigned src_stride,
+                                              unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const float *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *dst;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         value &= 0xff000000;
+         value |= z32_float_to_z24_unorm(*src++);
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z24_unorm_s8_uscaled_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride,
+                                                  const uint8_t *src_row, unsigned src_stride,
+                                                  unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint32_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = z24_unorm_to_z32_unorm(value & 0xffffff);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z24_unorm_s8_uscaled_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride,
+                                                const uint32_t *src_row, unsigned src_stride,
+                                                unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint32_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value= *dst;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         value &= 0xff000000;
+         value |= z32_unorm_to_z24_unorm(*src++);
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z24_unorm_s8_uscaled_unpack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride,
+                                                   const uint8_t *src_row, unsigned src_stride,
+                                                   unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint8_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value >> 24;
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z24_unorm_s8_uscaled_pack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride,
+                                                 const uint8_t *src_row, unsigned src_stride,
+                                                 unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint8_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *dst;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         value &= 0x00ffffff;
+         value |= *src++ << 24;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_s8_uscaled_z24_unorm_unpack_z_float(float *dst_row, unsigned dst_stride,
+                                                const uint8_t *src_row, unsigned src_stride,
+                                                unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      float *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = z24_unorm_to_z32_float(value >> 8);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_s8_uscaled_z24_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride,
+                                              const float *src_row, unsigned src_stride,
+                                              unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const float *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *dst;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         value &= 0x000000ff;
+         value |= z32_float_to_z24_unorm(*src++) << 8;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_s8_uscaled_z24_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride,
+                                                  const uint8_t *src_row, unsigned src_stride,
+                                                  unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint32_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = z24_unorm_to_z32_unorm(value >> 8);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_s8_uscaled_z24_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride,
+                                                const uint32_t *src_row, unsigned src_stride,
+                                                unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint32_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *dst;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         value &= 0x000000ff;
+         value |= *src++ & 0xffffff00;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_s8_uscaled_z24_unorm_unpack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride,
+                                                   const uint8_t *src_row, unsigned src_stride,
+                                                   unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint8_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value & 0xff;
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_s8_uscaled_z24_unorm_pack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride,
+                                                 const uint8_t *src_row, unsigned src_stride,
+                                                 unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint8_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *dst;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         value &= 0xffffff00;
+         value |= *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z24x8_unorm_unpack_z_float(float *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      float *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = z24_unorm_to_z32_float(value & 0xffffff);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z24x8_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride,
+                                     const float *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const float *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value;
+         value = z32_float_to_z24_unorm(*src++);
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z24x8_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride,
+                                         const uint8_t *src_row, unsigned src_stride,
+                                         unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint32_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = z24_unorm_to_z32_unorm(value & 0xffffff);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z24x8_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride,
+                                       const uint32_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint32_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value;
+         value = z32_unorm_to_z24_unorm(*src++);
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_x8z24_unorm_unpack_z_float(float *dst_row, unsigned dst_stride,
+                                       const uint8_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      float *dst = dst_row;
+      const uint32_t *src = (uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = z24_unorm_to_z32_float(value >> 8);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_x8z24_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride,
+                                     const float *src_row, unsigned src_stride,
+                                     unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const float *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value;
+         value = z32_float_to_z24_unorm(*src++) << 8;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_x8z24_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride,
+                                         const uint8_t *src_row, unsigned src_stride,
+                                         unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint32_t *dst = dst_row;
+      const uint32_t *src = (const uint32_t *)src_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value = *src++;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = z24_unorm_to_z32_unorm(value >> 8);
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_x8z24_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride,
+                                       const uint32_t *src_row, unsigned src_stride,
+                                       unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint32_t *src = src_row;
+      uint32_t *dst = (uint32_t *)dst_row;
+      for(x = 0; x < width; ++x) {
+         uint32_t value;
+         value = z32_unorm_to_z24_unorm(*src++) << 8;
+#ifdef PIPE_ARCH_BIG_ENDIAN
+         value = util_bswap32(value);
+#endif
+         *dst++ = value;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z32_float_s8x24_uscaled_unpack_z_float(float *dst_row, unsigned dst_stride,
+                                                   const uint8_t *src_row, unsigned src_stride,
+                                                   unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      float *dst = dst_row;
+      const float *src = (const float *)src_row;
+      for(x = 0; x < width; ++x) {
+         *dst = *src;
+         src += 2;
+         dst += 1;
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z32_float_s8x24_uscaled_pack_z_float(uint8_t *dst_row, unsigned dst_stride,
+                                                 const float *src_row, unsigned src_stride,
+                                                 unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const float *src = src_row;
+      float *dst = (float *)dst_row;
+      for(x = 0; x < width; ++x) {
+         *dst = *src;
+         src += 1;
+         dst += 2;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z32_float_s8x24_uscaled_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride,
+                                                     const uint8_t *src_row, unsigned src_stride,
+                                                     unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint32_t *dst = dst_row;
+      const float *src = (const float *)src_row;
+      for(x = 0; x < width; ++x) {
+         *dst = z32_float_to_z32_unorm(*src);
+         src += 2;
+         dst += 1;
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z32_float_s8x24_uscaled_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride,
+                                                   const uint32_t *src_row, unsigned src_stride,
+                                                   unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint32_t *src = src_row;
+      float *dst = (float *)dst_row;
+      for(x = 0; x < width; ++x) {
+         *dst++ = z32_unorm_to_z32_float(*src++);
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
+void
+util_format_z32_float_s8x24_uscaled_unpack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride,
+                                                      const uint8_t *src_row, unsigned src_stride,
+                                                      unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      uint8_t *dst = dst_row;
+      const uint8_t *src = src_row + 4;
+      for(x = 0; x < width; ++x) {
+         *dst = *src;
+         src += 8;
+         dst += 1;
+      }
+      src_row += src_stride/sizeof(*src_row);
+      dst_row += dst_stride/sizeof(*dst_row);
+   }
+}
+
+void
+util_format_z32_float_s8x24_uscaled_pack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride,
+                                                    const uint8_t *src_row, unsigned src_stride,
+                                                    unsigned width, unsigned height)
+{
+   unsigned x, y;
+   for(y = 0; y < height; ++y) {
+      const uint8_t *src = src_row;
+      uint8_t *dst = dst_row + 4;
+      for(x = 0; x < width; ++x) {
+         *dst = *src;
+         src += 1;
+         dst += 8;
+      }
+      dst_row += dst_stride/sizeof(*dst_row);
+      src_row += src_stride/sizeof(*src_row);
+   }
+}
+
diff --git a/src/gallium/auxiliary/util/u_format_zs.h b/src/gallium/auxiliary/util/u_format_zs.h
new file mode 100644
index 00000000000..650db4b95fd
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_format_zs.h
@@ -0,0 +1,196 @@
+/**************************************************************************
+ *
+ * Copyright 2010 VMware, Inc.
+ * 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 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
+ * THE COPYRIGHT HOLDERS, AUTHORS 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.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ **************************************************************************/
+
+
+#ifndef U_FORMAT_ZS_H_
+#define U_FORMAT_ZS_H_
+
+
+#include "pipe/p_compiler.h"
+
+
+void
+util_format_s8_uscaled_unpack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_s8_uscaled_pack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z16_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z16_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z16_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z16_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, const uint32_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, const uint32_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_unpack_z_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_pack_z_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, const uint32_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24_unorm_s8_uscaled_unpack_z_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24_unorm_s8_uscaled_pack_z_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24_unorm_s8_uscaled_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24_unorm_s8_uscaled_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, const uint32_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24_unorm_s8_uscaled_unpack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24_unorm_s8_uscaled_pack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_s8_uscaled_z24_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_s8_uscaled_z24_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_s8_uscaled_z24_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_s8_uscaled_z24_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, const uint32_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_s8_uscaled_z24_unorm_unpack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_s8_uscaled_z24_unorm_pack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24x8_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24x8_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24x8_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z24x8_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, const uint32_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_x8z24_unorm_unpack_z_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_x8z24_unorm_pack_z_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_x8z24_unorm_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_x8z24_unorm_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, const uint32_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_s8x24_uscaled_unpack_z_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_s8x24_uscaled_pack_z_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_s8x24_uscaled_unpack_z_32unorm(uint32_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_s8x24_uscaled_pack_z_32unorm(uint8_t *dst_row, unsigned dst_stride, const uint32_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_s8x24_uscaled_unpack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+void
+util_format_z32_float_s8x24_uscaled_pack_s_8uscaled(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height);
+
+
+#endif /* U_FORMAT_ZS_H_ */
diff --git a/src/gallium/auxiliary/util/u_gen_mipmap.c b/src/gallium/auxiliary/util/u_gen_mipmap.c
index 509d38754f5..eee6030ddcc 100644
--- a/src/gallium/auxiliary/util/u_gen_mipmap.c
+++ b/src/gallium/auxiliary/util/u_gen_mipmap.c
@@ -67,7 +67,7 @@ struct gen_mipmap_state
    void *vs;
    void *fs2d, *fsCube;
 
-   struct pipe_buffer *vbuf;  /**< quad vertices */
+   struct pipe_resource *vbuf;  /**< quad vertices */
    unsigned vbuf_slot;
 
    float vertices[4][2][4];   /**< vertex/texcoords for quad */
@@ -1116,7 +1116,7 @@ reduce_3d(enum pipe_format pformat,
 
 static void
 make_1d_mipmap(struct gen_mipmap_state *ctx,
-               struct pipe_texture *pt,
+               struct pipe_resource *pt,
                uint face, uint baseLevel, uint lastLevel)
 {
    struct pipe_context *pipe = ctx->pipe;
@@ -1128,11 +1128,11 @@ make_1d_mipmap(struct gen_mipmap_state *ctx,
       struct pipe_transfer *srcTrans, *dstTrans;
       void *srcMap, *dstMap;
       
-      srcTrans = pipe->get_tex_transfer(pipe, pt, face, srcLevel, zslice,
+      srcTrans = pipe_get_transfer(pipe, pt, face, srcLevel, zslice,
                                           PIPE_TRANSFER_READ, 0, 0,
                                           u_minify(pt->width0, srcLevel),
                                           u_minify(pt->height0, srcLevel));
-      dstTrans = pipe->get_tex_transfer(pipe, pt, face, dstLevel, zslice,
+      dstTrans = pipe_get_transfer(pipe, pt, face, dstLevel, zslice,
                                           PIPE_TRANSFER_WRITE, 0, 0,
                                           u_minify(pt->width0, dstLevel),
                                           u_minify(pt->height0, dstLevel));
@@ -1141,21 +1141,21 @@ make_1d_mipmap(struct gen_mipmap_state *ctx,
       dstMap = (ubyte *) pipe->transfer_map(pipe, dstTrans);
 
       reduce_1d(pt->format,
-                srcTrans->width, srcMap,
-                dstTrans->width, dstMap);
+                srcTrans->box.width, srcMap,
+                dstTrans->box.width, dstMap);
 
       pipe->transfer_unmap(pipe, srcTrans);
       pipe->transfer_unmap(pipe, dstTrans);
 
-      pipe->tex_transfer_destroy(pipe, srcTrans);
-      pipe->tex_transfer_destroy(pipe, dstTrans);
+      pipe->transfer_destroy(pipe, srcTrans);
+      pipe->transfer_destroy(pipe, dstTrans);
    }
 }
 
 
 static void
 make_2d_mipmap(struct gen_mipmap_state *ctx,
-               struct pipe_texture *pt,
+               struct pipe_resource *pt,
                uint face, uint baseLevel, uint lastLevel)
 {
    struct pipe_context *pipe = ctx->pipe;
@@ -1170,36 +1170,36 @@ make_2d_mipmap(struct gen_mipmap_state *ctx,
       struct pipe_transfer *srcTrans, *dstTrans;
       ubyte *srcMap, *dstMap;
       
-      srcTrans = pipe->get_tex_transfer(pipe, pt, face, srcLevel, zslice,
-                                          PIPE_TRANSFER_READ, 0, 0,
-                                          u_minify(pt->width0, srcLevel),
-                                          u_minify(pt->height0, srcLevel));
-      dstTrans = pipe->get_tex_transfer(pipe, pt, face, dstLevel, zslice,
-                                          PIPE_TRANSFER_WRITE, 0, 0,
-                                          u_minify(pt->width0, dstLevel),
-                                          u_minify(pt->height0, dstLevel));
+      srcTrans = pipe_get_transfer(pipe, pt, face, srcLevel, zslice,
+				   PIPE_TRANSFER_READ, 0, 0,
+				   u_minify(pt->width0, srcLevel),
+				   u_minify(pt->height0, srcLevel));
+      dstTrans = pipe_get_transfer(pipe, pt, face, dstLevel, zslice,
+				   PIPE_TRANSFER_WRITE, 0, 0,
+				   u_minify(pt->width0, dstLevel),
+				   u_minify(pt->height0, dstLevel));
 
       srcMap = (ubyte *) pipe->transfer_map(pipe, srcTrans);
       dstMap = (ubyte *) pipe->transfer_map(pipe, dstTrans);
 
       reduce_2d(pt->format,
-                srcTrans->width, srcTrans->height,
+                srcTrans->box.width, srcTrans->box.height,
                 srcTrans->stride, srcMap,
-                dstTrans->width, dstTrans->height,
+                dstTrans->box.width, dstTrans->box.height,
                 dstTrans->stride, dstMap);
 
       pipe->transfer_unmap(pipe, srcTrans);
       pipe->transfer_unmap(pipe, dstTrans);
 
-      pipe->tex_transfer_destroy(pipe, srcTrans);
-      pipe->tex_transfer_destroy(pipe, dstTrans);
+      pipe->transfer_destroy(pipe, srcTrans);
+      pipe->transfer_destroy(pipe, dstTrans);
    }
 }
 
 
 static void
 make_3d_mipmap(struct gen_mipmap_state *ctx,
-               struct pipe_texture *pt,
+               struct pipe_resource *pt,
                uint face, uint baseLevel, uint lastLevel)
 {
 #if 0
@@ -1215,11 +1215,11 @@ make_3d_mipmap(struct gen_mipmap_state *ctx,
       struct pipe_transfer *srcTrans, *dstTrans;
       ubyte *srcMap, *dstMap;
       
-      srcTrans = pipe->get_tex_transfer(pipe, pt, face, srcLevel, zslice,
+      srcTrans = pipe->get_transfer(pipe, pt, face, srcLevel, zslice,
                                           PIPE_TRANSFER_READ, 0, 0,
                                           u_minify(pt->width0, srcLevel),
                                           u_minify(pt->height0, srcLevel));
-      dstTrans = pipe->get_tex_transfer(pipe, pt, face, dstLevel, zslice,
+      dstTrans = pipe->get_transfer(pipe, pt, face, dstLevel, zslice,
                                           PIPE_TRANSFER_WRITE, 0, 0,
                                           u_minify(pt->width0, dstLevel),
                                           u_minify(pt->height0, dstLevel));
@@ -1236,8 +1236,8 @@ make_3d_mipmap(struct gen_mipmap_state *ctx,
       pipe->transfer_unmap(pipe, srcTrans);
       pipe->transfer_unmap(pipe, dstTrans);
 
-      pipe->tex_transfer_destroy(pipe, srcTrans);
-      pipe->tex_transfer_destroy(pipe, dstTrans);
+      pipe->transfer_destroy(pipe, srcTrans);
+      pipe->transfer_destroy(pipe, dstTrans);
    }
 #else
    (void) reduce_3d;
@@ -1247,7 +1247,7 @@ make_3d_mipmap(struct gen_mipmap_state *ctx,
 
 static void
 fallback_gen_mipmap(struct gen_mipmap_state *ctx,
-                    struct pipe_texture *pt,
+                    struct pipe_resource *pt,
                     uint face, uint baseLevel, uint lastLevel)
 {
    switch (pt->target) {
@@ -1358,8 +1358,7 @@ get_next_slot(struct gen_mipmap_state *ctx)
 
    if (!ctx->vbuf) {
       ctx->vbuf = pipe_buffer_create(ctx->pipe->screen,
-                                     32,
-                                     PIPE_BUFFER_USAGE_VERTEX,
+                                     PIPE_BIND_VERTEX_BUFFER,
                                      max_slots * sizeof ctx->vertices);
    }
    
@@ -1420,7 +1419,7 @@ set_vertex_data(struct gen_mipmap_state *ctx,
 
    offset = get_next_slot( ctx );
 
-   pipe_buffer_write_nooverlap(ctx->pipe->screen, ctx->vbuf,
+   pipe_buffer_write_nooverlap(ctx->pipe, ctx->vbuf,
                                offset, sizeof(ctx->vertices), ctx->vertices);
 
    return offset;
@@ -1440,7 +1439,7 @@ util_destroy_gen_mipmap(struct gen_mipmap_state *ctx)
    pipe->delete_fs_state(pipe, ctx->fs2d);
    pipe->delete_fs_state(pipe, ctx->fsCube);
 
-   pipe_buffer_reference(&ctx->vbuf, NULL);
+   pipe_resource_reference(&ctx->vbuf, NULL);
 
    FREE(ctx);
 }
@@ -1452,7 +1451,7 @@ util_destroy_gen_mipmap(struct gen_mipmap_state *ctx)
  */
 void util_gen_mipmap_flush( struct gen_mipmap_state *ctx )
 {
-   pipe_buffer_reference(&ctx->vbuf, NULL);
+   pipe_resource_reference(&ctx->vbuf, NULL);
    ctx->vbuf_slot = 0;
 } 
 
@@ -1476,7 +1475,7 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
    struct pipe_context *pipe = ctx->pipe;
    struct pipe_screen *screen = pipe->screen;
    struct pipe_framebuffer_state fb;
-   struct pipe_texture *pt = psv->texture;
+   struct pipe_resource *pt = psv->texture;
    void *fs = (pt->target == PIPE_TEXTURE_CUBE) ? ctx->fsCube : ctx->fs2d;
    uint dstLevel;
    uint zslice = 0;
@@ -1495,7 +1494,7 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
 
    /* check if we can render in the texture's format */
    if (!screen->is_format_supported(screen, psv->format, PIPE_TEXTURE_2D,
-                                    PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
+                                    PIPE_BIND_RENDER_TARGET, 0)) {
       fallback_gen_mipmap(ctx, pt, face, baseLevel, lastLevel);
       return;
    }
@@ -1541,7 +1540,7 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
 
       struct pipe_surface *surf = 
          screen->get_tex_surface(screen, pt, face, dstLevel, zslice,
-                                 PIPE_BUFFER_USAGE_GPU_WRITE);
+                                 PIPE_BIND_RENDER_TARGET);
 
       /*
        * Setup framebuffer / dest surface
diff --git a/src/gallium/auxiliary/util/u_gen_mipmap.h b/src/gallium/auxiliary/util/u_gen_mipmap.h
index 35ac9daeaa2..a7502b9982b 100644
--- a/src/gallium/auxiliary/util/u_gen_mipmap.h
+++ b/src/gallium/auxiliary/util/u_gen_mipmap.h
@@ -37,7 +37,7 @@ extern "C" {
 
    
 struct pipe_context;
-struct pipe_texture;
+struct pipe_resource;
 struct cso_context;
 
 struct gen_mipmap_state;
diff --git a/src/gallium/auxiliary/util/u_half.h b/src/gallium/auxiliary/util/u_half.h
index a28b1fd1d93..ad030e90c67 100644
--- a/src/gallium/auxiliary/util/u_half.h
+++ b/src/gallium/auxiliary/util/u_half.h
@@ -1,3 +1,30 @@
+/**************************************************************************
+ *
+ * Copyright 2010 Luca Barbieri
+ *
+ * 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, sublicense, 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 NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) 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 U_HALF_H
 #define U_HALF_H
 
@@ -8,11 +35,11 @@
 extern "C" {
 #endif
 
-extern uint32_t util_half_to_float_mantissa_table[2048];
-extern uint32_t util_half_to_float_exponent_table[64];
-extern uint32_t util_half_to_float_offset_table[64];
-extern uint16_t util_float_to_half_base_table[512];
-extern uint8_t util_float_to_half_shift_table[512];
+extern const uint32_t util_half_to_float_mantissa_table[2048];
+extern const uint32_t util_half_to_float_exponent_table[64];
+extern const uint32_t util_half_to_float_offset_table[64];
+extern const uint16_t util_float_to_half_base_table[512];
+extern const uint8_t util_float_to_half_shift_table[512];
 
 /*
  * Note that if the half float is a signaling NaN, the x87 FPU will turn
@@ -26,28 +53,28 @@ extern uint8_t util_float_to_half_shift_table[512];
  */
 
 static INLINE uint32_t
-util_half_to_floatui(half h)
+util_half_to_floatui(uint16_t h)
 {
    unsigned exp = h >> 10;
    return util_half_to_float_mantissa_table[util_half_to_float_offset_table[exp] + (h & 0x3ff)] + util_half_to_float_exponent_table[exp];
 }
 
 static INLINE float
-util_half_to_float(half h)
+util_half_to_float(uint16_t h)
 {
    union fi r;
    r.ui = util_half_to_floatui(h);
    return r.f;
 }
 
-static INLINE half
+static INLINE uint16_t
 util_floatui_to_half(uint32_t v)
 {
    unsigned signexp = v >> 23;
    return util_float_to_half_base_table[signexp] + ((v & 0x007fffff) >> util_float_to_half_shift_table[signexp]);
 }
 
-static INLINE half
+static INLINE uint16_t
 util_float_to_half(float f)
 {
    union fi i;
diff --git a/src/gallium/auxiliary/util/u_half.py b/src/gallium/auxiliary/util/u_half.py
index a92f758750c..8007482e971 100644
--- a/src/gallium/auxiliary/util/u_half.py
+++ b/src/gallium/auxiliary/util/u_half.py
@@ -56,7 +56,7 @@ def begin(t, n, l):
 	table_index = 0
 	table_length = l
 	print
-	print t + " " + n + "[" + str(l) + "] = {"
+	print "const " + t + " " + n + "[" + str(l) + "] = {"
 
 def value(v):
 	global table_index
diff --git a/src/gallium/auxiliary/util/u_inline_init.h b/src/gallium/auxiliary/util/u_inline_init.h
deleted file mode 100644
index 2a1e775ed81..00000000000
--- a/src/gallium/auxiliary/util/u_inline_init.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef U_INLINE_INIT_H_
-#define U_INLINE_INIT_H_
-
-#define UTIL_INLINE_INIT(m) \
-   extern boolean m##_inited; \
-   extern void m##_do_init(void); \
-   static INLINE void m##_init(void) \
-   { \
-      if(!m##_inited) { \
-         m##_do_init(); \
-         m##_inited = TRUE; \
-      } \
-   }
-
-#endif /* U_INLINE_INIT_H_ */
diff --git a/src/gallium/auxiliary/util/u_inlines.h b/src/gallium/auxiliary/util/u_inlines.h
index e22ab188e11..c2f4f05990b 100644
--- a/src/gallium/auxiliary/util/u_inlines.h
+++ b/src/gallium/auxiliary/util/u_inlines.h
@@ -34,6 +34,7 @@
 #include "pipe/p_screen.h"
 #include "util/u_debug.h"
 #include "util/u_atomic.h"
+#include "util/u_box.h"
 
 
 #ifdef __cplusplus
@@ -87,18 +88,6 @@ pipe_reference(struct pipe_reference *ptr, struct pipe_reference *reference)
    return destroy;
 }
 
-static INLINE void
-pipe_buffer_reference(struct pipe_buffer **ptr, struct pipe_buffer *buf)
-{
-   struct pipe_buffer *old_buf;
-
-   assert(ptr);
-   old_buf = *ptr;
-
-   if (pipe_reference(&(*ptr)->reference, &buf->reference))
-      old_buf->screen->buffer_destroy(old_buf);
-   *ptr = buf;
-}
 
 static INLINE void
 pipe_surface_reference(struct pipe_surface **ptr, struct pipe_surface *surf)
@@ -110,16 +99,18 @@ pipe_surface_reference(struct pipe_surface **ptr, struct pipe_surface *surf)
    *ptr = surf;
 }
 
+
 static INLINE void
-pipe_texture_reference(struct pipe_texture **ptr, struct pipe_texture *tex)
+pipe_resource_reference(struct pipe_resource **ptr, struct pipe_resource *tex)
 {
-   struct pipe_texture *old_tex = *ptr;
+   struct pipe_resource *old_tex = *ptr;
 
    if (pipe_reference(&(*ptr)->reference, &tex->reference))
-      old_tex->screen->texture_destroy(old_tex);
+      old_tex->screen->resource_destroy(old_tex->screen, old_tex);
    *ptr = tex;
 }
 
+
 static INLINE void
 pipe_sampler_view_reference(struct pipe_sampler_view **ptr, struct pipe_sampler_view *view)
 {
@@ -135,91 +126,135 @@ pipe_sampler_view_reference(struct pipe_sampler_view **ptr, struct pipe_sampler_
  * Convenience wrappers for screen buffer functions.
  */
 
-static INLINE struct pipe_buffer *
+static INLINE struct pipe_resource *
 pipe_buffer_create( struct pipe_screen *screen,
-                    unsigned alignment, unsigned usage, unsigned size )
+		    unsigned bind,
+		    unsigned size )
 {
-   return screen->buffer_create(screen, alignment, usage, size);
+   struct pipe_resource buffer;
+   memset(&buffer, 0, sizeof buffer);
+   buffer.target = PIPE_BUFFER;
+   buffer.format = PIPE_FORMAT_R8_UNORM; /* want TYPELESS or similar */
+   buffer.bind = bind;
+   buffer._usage = PIPE_USAGE_DEFAULT;
+   buffer.flags = 0;
+   buffer.width0 = size;
+   buffer.height0 = 1;
+   buffer.depth0 = 1;
+   return screen->resource_create(screen, &buffer);
 }
 
-static INLINE struct pipe_buffer *
-pipe_user_buffer_create( struct pipe_screen *screen, void *ptr, unsigned size )
+
+static INLINE struct pipe_resource *
+pipe_user_buffer_create( struct pipe_screen *screen, void *ptr, unsigned size,
+			 unsigned usage )
 {
-   return screen->user_buffer_create(screen, ptr, size);
+   return screen->user_buffer_create(screen, ptr, size, usage);
 }
 
 static INLINE void *
-pipe_buffer_map(struct pipe_screen *screen,
-                struct pipe_buffer *buf,
-                unsigned usage)
+pipe_buffer_map_range(struct pipe_context *pipe,
+		      struct pipe_resource *buffer,
+		      unsigned offset,
+		      unsigned length,
+		      unsigned usage,
+		      struct pipe_transfer **transfer)
 {
-   if(screen->buffer_map_range) {
-      unsigned offset = 0;
-      unsigned length = buf->size;
-      return screen->buffer_map_range(screen, buf, offset, length, usage);
+   struct pipe_box box;
+   void *map;
+
+   assert(offset < buffer->width0);
+   assert(offset + length <= buffer->width0);
+   assert(length);
+   
+   u_box_1d(offset, length, &box);
+
+   *transfer = pipe->get_transfer( pipe,
+				   buffer,
+				   u_subresource(0, 0),
+				   usage,
+				   &box);
+   
+   if (*transfer == NULL)
+      return NULL;
+
+   map = pipe->transfer_map( pipe, *transfer );
+   if (map == NULL) {
+      pipe->transfer_destroy( pipe, *transfer );
+      return NULL;
    }
-   else
-      return screen->buffer_map(screen, buf, usage);
+
+   /* Match old screen->buffer_map_range() behaviour, return pointer
+    * to where the beginning of the buffer would be:
+    */
+   return (void *)((char *)map - offset);
 }
 
-static INLINE void
-pipe_buffer_unmap(struct pipe_screen *screen,
-                  struct pipe_buffer *buf)
+
+static INLINE void *
+pipe_buffer_map(struct pipe_context *pipe,
+                struct pipe_resource *buffer,
+                unsigned usage,
+		struct pipe_transfer **transfer)
 {
-   screen->buffer_unmap(screen, buf);
+   return pipe_buffer_map_range(pipe, buffer, 0, buffer->width0, usage, transfer);
 }
 
-static INLINE void *
-pipe_buffer_map_range(struct pipe_screen *screen,
-                struct pipe_buffer *buf,
-                unsigned offset,
-                unsigned length,
-                unsigned usage)
+
+static INLINE void
+pipe_buffer_unmap(struct pipe_context *pipe,
+                  struct pipe_resource *buf,
+		  struct pipe_transfer *transfer)
 {
-   assert(offset < buf->size);
-   assert(offset + length <= buf->size);
-   assert(length);
-   if(screen->buffer_map_range)
-      return screen->buffer_map_range(screen, buf, offset, length, usage);
-   else
-      return screen->buffer_map(screen, buf, usage);
+   if (transfer) {
+      pipe->transfer_unmap(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
+   }
 }
 
 static INLINE void
-pipe_buffer_flush_mapped_range(struct pipe_screen *screen,
-                               struct pipe_buffer *buf,
+pipe_buffer_flush_mapped_range(struct pipe_context *pipe,
+			       struct pipe_transfer *transfer,
                                unsigned offset,
                                unsigned length)
 {
-   assert(offset < buf->size);
-   assert(offset + length <= buf->size);
+   struct pipe_box box;
+   int transfer_offset;
+
    assert(length);
-   if(screen->buffer_flush_mapped_range)
-      screen->buffer_flush_mapped_range(screen, buf, offset, length);
+   assert(transfer->box.x <= offset);
+   assert(offset + length <= transfer->box.x + transfer->box.width);
+
+   /* Match old screen->buffer_flush_mapped_range() behaviour, where
+    * offset parameter is relative to the start of the buffer, not the
+    * mapped range.
+    */
+   transfer_offset = offset - transfer->box.x;
+   
+   u_box_1d(transfer_offset, length, &box);
+
+   pipe->transfer_flush_region(pipe, transfer, &box);
 }
 
 static INLINE void
-pipe_buffer_write(struct pipe_screen *screen,
-                  struct pipe_buffer *buf,
-                  unsigned offset, unsigned size,
+pipe_buffer_write(struct pipe_context *pipe,
+                  struct pipe_resource *buf,
+                  unsigned offset,
+		  unsigned size,
                   const void *data)
 {
-   void *map;
-   
-   assert(offset < buf->size);
-   assert(offset + size <= buf->size);
-   assert(size);
-
-   map = pipe_buffer_map_range(screen, buf, offset, size, 
-                               PIPE_BUFFER_USAGE_CPU_WRITE | 
-                               PIPE_BUFFER_USAGE_FLUSH_EXPLICIT |
-                               PIPE_BUFFER_USAGE_DISCARD);
-   assert(map);
-   if(map) {
-      memcpy((uint8_t *)map + offset, data, size);
-      pipe_buffer_flush_mapped_range(screen, buf, offset, size);
-      pipe_buffer_unmap(screen, buf);
-   }
+   struct pipe_box box;
+
+   u_box_1d(offset, size, &box);
+
+   pipe->transfer_inline_write( pipe,
+				buf,
+				u_subresource(0,0),
+				PIPE_TRANSFER_WRITE,
+				&box,
+				data,
+				size,
+				0);
 }
 
 /**
@@ -229,86 +264,87 @@ pipe_buffer_write(struct pipe_screen *screen,
  * been written before.
  */
 static INLINE void
-pipe_buffer_write_nooverlap(struct pipe_screen *screen,
-                            struct pipe_buffer *buf,
+pipe_buffer_write_nooverlap(struct pipe_context *pipe,
+                            struct pipe_resource *buf,
                             unsigned offset, unsigned size,
                             const void *data)
 {
-   void *map;
-
-   assert(offset < buf->size);
-   assert(offset + size <= buf->size);
-   assert(size);
-
-   map = pipe_buffer_map_range(screen, buf, offset, size,
-                               PIPE_BUFFER_USAGE_CPU_WRITE |
-                               PIPE_BUFFER_USAGE_FLUSH_EXPLICIT |
-                               PIPE_BUFFER_USAGE_DISCARD |
-                               PIPE_BUFFER_USAGE_UNSYNCHRONIZED);
-   assert(map);
-   if(map) {
-      memcpy((uint8_t *)map + offset, data, size);
-      pipe_buffer_flush_mapped_range(screen, buf, offset, size);
-      pipe_buffer_unmap(screen, buf);
-   }
+   struct pipe_box box;
+
+   u_box_1d(offset, size, &box);
+
+   pipe->transfer_inline_write(pipe, 
+			       buf,
+			       u_subresource(0,0),
+			       (PIPE_TRANSFER_WRITE |
+				PIPE_TRANSFER_NOOVERWRITE),
+			       &box,
+			       data,
+			       0, 0);
 }
 
 static INLINE void
-pipe_buffer_read(struct pipe_screen *screen,
-                 struct pipe_buffer *buf,
-                 unsigned offset, unsigned size,
+pipe_buffer_read(struct pipe_context *pipe,
+                 struct pipe_resource *buf,
+                 unsigned offset,
+		 unsigned size,
                  void *data)
 {
-   void *map;
-   
-   assert(offset < buf->size);
-   assert(offset + size <= buf->size);
-   assert(size);
-
-   map = pipe_buffer_map_range(screen, buf, offset, size, PIPE_BUFFER_USAGE_CPU_READ);
-   assert(map);
-   if(map) {
-      memcpy(data, (const uint8_t *)map + offset, size);
-      pipe_buffer_unmap(screen, buf);
-   }
+   struct pipe_transfer *src_transfer;
+   ubyte *map;
+
+   map = (ubyte *) pipe_buffer_map_range(pipe,
+					 buf,
+					 offset, size,
+					 PIPE_TRANSFER_READ,
+					 &src_transfer);
+
+   if (map)
+      memcpy(data, map + offset, size);
+
+   pipe_buffer_unmap(pipe, buf, src_transfer);
+}
+
+static INLINE struct pipe_transfer *
+pipe_get_transfer( struct pipe_context *context,
+		       struct pipe_resource *resource,
+		       unsigned face, unsigned level,
+		       unsigned zslice,
+		       enum pipe_transfer_usage usage,
+		       unsigned x, unsigned y,
+		       unsigned w, unsigned h)
+{
+   struct pipe_box box;
+   u_box_2d_zslice( x, y, zslice, w, h, &box );
+   return context->get_transfer( context,
+				 resource,
+				 u_subresource(face, level),
+				 usage,
+				 &box );
 }
 
 static INLINE void *
 pipe_transfer_map( struct pipe_context *context,
-                   struct pipe_transfer *transf )
+                   struct pipe_transfer *transfer )
 {
-   return context->transfer_map(context, transf);
+   return context->transfer_map( context, transfer );
 }
 
 static INLINE void
 pipe_transfer_unmap( struct pipe_context *context,
-                     struct pipe_transfer *transf )
+                     struct pipe_transfer *transfer )
 {
-   context->transfer_unmap(context, transf);
+   context->transfer_unmap( context, transfer );
 }
 
+
 static INLINE void
-pipe_transfer_destroy( struct pipe_context *context,
-                       struct pipe_transfer *transfer )
+pipe_transfer_destroy( struct pipe_context *context, 
+		       struct pipe_transfer *transfer )
 {
-   context->tex_transfer_destroy(context, transfer);
+   context->transfer_destroy(context, transfer);
 }
 
-static INLINE unsigned
-pipe_transfer_buffer_flags( struct pipe_transfer *transf )
-{
-   switch (transf->usage & PIPE_TRANSFER_READ_WRITE) {
-   case PIPE_TRANSFER_READ_WRITE:
-      return PIPE_BUFFER_USAGE_CPU_READ | PIPE_BUFFER_USAGE_CPU_WRITE;
-   case PIPE_TRANSFER_READ:
-      return PIPE_BUFFER_USAGE_CPU_READ;
-   case PIPE_TRANSFER_WRITE:
-      return PIPE_BUFFER_USAGE_CPU_WRITE;
-   default:
-      debug_assert(0);
-      return 0;
-   }
-}
 
 #ifdef __cplusplus
 }
diff --git a/src/gallium/auxiliary/util/u_pack_color.h b/src/gallium/auxiliary/util/u_pack_color.h
index ad4a06dc770..3ebef9fb749 100644
--- a/src/gallium/auxiliary/util/u_pack_color.h
+++ b/src/gallium/auxiliary/util/u_pack_color.h
@@ -37,6 +37,7 @@
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_format.h"
+#include "util/u_debug.h"
 #include "util/u_format.h"
 #include "util/u_math.h"
 
diff --git a/src/gallium/auxiliary/util/u_rect.c b/src/gallium/auxiliary/util/u_rect.c
index e73797f1b7e..098cdfd58b1 100644
--- a/src/gallium/auxiliary/util/u_rect.c
+++ b/src/gallium/auxiliary/util/u_rect.c
@@ -35,6 +35,7 @@
 #include "pipe/p_context.h"
 #include "pipe/p_screen.h"
 #include "util/u_format.h"
+#include "util/u_inlines.h"
 #include "util/u_rect.h"
 
 
@@ -181,21 +182,21 @@ util_surface_copy(struct pipe_context *pipe,
    src_format = src->texture->format;
    dst_format = dst->texture->format;
 
-   src_trans = pipe->get_tex_transfer(pipe,
-                                        src->texture,
-                                        src->face,
-                                        src->level,
-                                        src->zslice,
-                                        PIPE_TRANSFER_READ,
-                                        src_x, src_y, w, h);
-
-   dst_trans = pipe->get_tex_transfer(pipe,
-                                        dst->texture,
-                                        dst->face,
-                                        dst->level,
-                                        dst->zslice,
-                                        PIPE_TRANSFER_WRITE,
-                                        dst_x, dst_y, w, h);
+   src_trans = pipe_get_transfer(pipe,
+				 src->texture,
+				 src->face,
+				 src->level,
+				 src->zslice,
+				 PIPE_TRANSFER_READ,
+				 src_x, src_y, w, h);
+
+   dst_trans = pipe_get_transfer(pipe,
+				 dst->texture,
+				 dst->face,
+				 dst->level,
+				 dst->zslice,
+				 PIPE_TRANSFER_WRITE,
+				 dst_x, dst_y, w, h);
 
    assert(util_format_get_blocksize(dst_format) == util_format_get_blocksize(src_format));
    assert(util_format_get_blockwidth(dst_format) == util_format_get_blockwidth(src_format));
@@ -223,8 +224,8 @@ util_surface_copy(struct pipe_context *pipe,
    pipe->transfer_unmap(pipe, src_trans);
    pipe->transfer_unmap(pipe, dst_trans);
 
-   pipe->tex_transfer_destroy(pipe, src_trans);
-   pipe->tex_transfer_destroy(pipe, dst_trans);
+   pipe->transfer_destroy(pipe, src_trans);
+   pipe->transfer_destroy(pipe, dst_trans);
 }
 
 
@@ -248,13 +249,13 @@ util_surface_fill(struct pipe_context *pipe,
    assert(dst->texture);
    if (!dst->texture)
       return;
-   dst_trans = pipe->get_tex_transfer(pipe,
-                                        dst->texture,
-                                        dst->face,
-                                        dst->level,
-                                        dst->zslice,
-                                        PIPE_TRANSFER_WRITE,
-                                        dstx, dsty, width, height);
+   dst_trans = pipe_get_transfer(pipe,
+				 dst->texture,
+				 dst->face,
+				 dst->level,
+				 dst->zslice,
+				 PIPE_TRANSFER_WRITE,
+				 dstx, dsty, width, height);
 
    dst_map = pipe->transfer_map(pipe, dst_trans);
 
@@ -263,37 +264,38 @@ util_surface_fill(struct pipe_context *pipe,
    if (dst_map) {
       assert(dst_trans->stride > 0);
 
-      switch (util_format_get_blocksize(dst_trans->texture->format)) {
+      switch (util_format_get_blocksize(dst->texture->format)) {
       case 1:
       case 2:
       case 4:
-         util_fill_rect(dst_map, dst_trans->texture->format, dst_trans->stride,
+         util_fill_rect(dst_map, dst->texture->format,
+			dst_trans->stride,
                         0, 0, width, height, value);
          break;
       case 8:
-         {
-            /* expand the 4-byte clear value to an 8-byte value */
-            ushort *row = (ushort *) dst_map;
-            ushort val0 = UBYTE_TO_USHORT((value >>  0) & 0xff);
-            ushort val1 = UBYTE_TO_USHORT((value >>  8) & 0xff);
-            ushort val2 = UBYTE_TO_USHORT((value >> 16) & 0xff);
-            ushort val3 = UBYTE_TO_USHORT((value >> 24) & 0xff);
-            unsigned i, j;
-            val0 = (val0 << 8) | val0;
-            val1 = (val1 << 8) | val1;
-            val2 = (val2 << 8) | val2;
-            val3 = (val3 << 8) | val3;
-            for (i = 0; i < height; i++) {
-               for (j = 0; j < width; j++) {
-                  row[j*4+0] = val0;
-                  row[j*4+1] = val1;
-                  row[j*4+2] = val2;
-                  row[j*4+3] = val3;
-               }
-               row += dst_trans->stride/2;
-            }
-         }
-         break;
+      {
+	 /* expand the 4-byte clear value to an 8-byte value */
+	 ushort *row = (ushort *) dst_map;
+	 ushort val0 = UBYTE_TO_USHORT((value >>  0) & 0xff);
+	 ushort val1 = UBYTE_TO_USHORT((value >>  8) & 0xff);
+	 ushort val2 = UBYTE_TO_USHORT((value >> 16) & 0xff);
+	 ushort val3 = UBYTE_TO_USHORT((value >> 24) & 0xff);
+	 unsigned i, j;
+	 val0 = (val0 << 8) | val0;
+	 val1 = (val1 << 8) | val1;
+	 val2 = (val2 << 8) | val2;
+	 val3 = (val3 << 8) | val3;
+	 for (i = 0; i < height; i++) {
+	    for (j = 0; j < width; j++) {
+	       row[j*4+0] = val0;
+	       row[j*4+1] = val1;
+	       row[j*4+2] = val2;
+	       row[j*4+3] = val3;
+	    }
+	    row += dst_trans->stride/2;
+	 }
+      }
+      break;
       default:
          assert(0);
          break;
@@ -301,5 +303,5 @@ util_surface_fill(struct pipe_context *pipe,
    }
 
    pipe->transfer_unmap(pipe, dst_trans);
-   pipe->tex_transfer_destroy(pipe, dst_trans);
+   pipe->transfer_destroy(pipe, dst_trans);
 }
diff --git a/src/gallium/auxiliary/util/u_resource.c b/src/gallium/auxiliary/util/u_resource.c
new file mode 100644
index 00000000000..9e6474b83de
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_resource.c
@@ -0,0 +1,96 @@
+
+
+#include "util/u_inlines.h"
+#include "util/u_transfer.h"
+
+static INLINE struct u_resource *
+u_resource( struct pipe_resource *res )
+{
+   return (struct u_resource *)res;
+}
+
+boolean u_resource_get_handle_vtbl(struct pipe_screen *screen,
+			  struct pipe_resource *resource,
+			  struct winsys_handle *handle)
+{
+   struct u_resource *ur = u_resource(resource);
+   return ur->vtbl->resource_get_handle(screen, resource, handle);
+}
+
+void u_resource_destroy_vtbl(struct pipe_screen *screen,
+		    struct pipe_resource *resource)
+{
+   struct u_resource *ur = u_resource(resource);
+   ur->vtbl->resource_destroy(screen, resource);
+}
+
+unsigned u_is_resource_referenced_vtbl( struct pipe_context *pipe,
+					struct pipe_resource *resource,
+					unsigned face, unsigned level)
+{
+   struct u_resource *ur = u_resource(resource);
+   return ur->vtbl->is_resource_referenced(pipe, resource, face, level);
+}
+
+struct pipe_transfer *u_get_transfer_vtbl(struct pipe_context *context,
+					  struct pipe_resource *resource,
+					  struct pipe_subresource sr,
+					  enum pipe_transfer_usage usage,
+					  const struct pipe_box *box)
+{
+   struct u_resource *ur = u_resource(resource);
+   return ur->vtbl->get_transfer(context, resource, sr, usage, box);
+}
+
+void u_transfer_destroy_vtbl(struct pipe_context *pipe,
+			     struct pipe_transfer *transfer)
+{
+   struct u_resource *ur = u_resource(transfer->resource);
+   ur->vtbl->transfer_destroy(pipe, transfer);
+}
+
+void *u_transfer_map_vtbl( struct pipe_context *pipe,
+			   struct pipe_transfer *transfer )
+{
+   struct u_resource *ur = u_resource(transfer->resource);
+   return ur->vtbl->transfer_map(pipe, transfer);
+}
+
+void u_transfer_flush_region_vtbl( struct pipe_context *pipe,
+				   struct pipe_transfer *transfer,
+				   const struct pipe_box *box)
+{
+   struct u_resource *ur = u_resource(transfer->resource);
+   ur->vtbl->transfer_flush_region(pipe, transfer, box);
+}
+
+void u_transfer_unmap_vtbl( struct pipe_context *pipe,
+			    struct pipe_transfer *transfer )
+{
+   struct u_resource *ur = u_resource(transfer->resource);
+   ur->vtbl->transfer_unmap(pipe, transfer);
+}
+
+void u_transfer_inline_write_vtbl( struct pipe_context *pipe,
+				   struct pipe_resource *resource,
+				   struct pipe_subresource sr,
+				   unsigned usage,
+				   const struct pipe_box *box,
+				   const void *data,
+				   unsigned stride,
+				   unsigned slice_stride)
+{
+   struct u_resource *ur = u_resource(resource);
+   ur->vtbl->transfer_inline_write(pipe, 
+				   resource,
+				   sr,
+				   usage,
+				   box,
+				   data,
+				   stride,
+				   slice_stride);
+}
+
+
+
+
diff --git a/src/gallium/auxiliary/util/u_sampler.c b/src/gallium/auxiliary/util/u_sampler.c
index 4d8f861ce49..e77f562ea22 100644
--- a/src/gallium/auxiliary/util/u_sampler.c
+++ b/src/gallium/auxiliary/util/u_sampler.c
@@ -32,7 +32,7 @@
 
 static void
 default_template(struct pipe_sampler_view *view,
-                 const struct pipe_texture *texture,
+                 const struct pipe_resource *texture,
                  enum pipe_format format,
                  unsigned expand_green_blue)
 {
@@ -77,7 +77,7 @@ default_template(struct pipe_sampler_view *view,
 
 void
 u_sampler_view_default_template(struct pipe_sampler_view *view,
-                                const struct pipe_texture *texture,
+                                const struct pipe_resource *texture,
                                 enum pipe_format format)
 {
    /* Expand to (0, 0, 0, 1) */
@@ -89,7 +89,7 @@ u_sampler_view_default_template(struct pipe_sampler_view *view,
 
 void
 u_sampler_view_default_dx9_template(struct pipe_sampler_view *view,
-                                    const struct pipe_texture *texture,
+                                    const struct pipe_resource *texture,
                                     enum pipe_format format)
 {
    /* Expand to (1, 1, 1, 1) */
diff --git a/src/gallium/auxiliary/util/u_sampler.h b/src/gallium/auxiliary/util/u_sampler.h
index bdd061c851c..f3dad7417e0 100644
--- a/src/gallium/auxiliary/util/u_sampler.h
+++ b/src/gallium/auxiliary/util/u_sampler.h
@@ -41,12 +41,12 @@ extern "C" {
 
 void
 u_sampler_view_default_template(struct pipe_sampler_view *view,
-                                const struct pipe_texture *texture,
+                                const struct pipe_resource *texture,
                                 enum pipe_format format);
 
 void
 u_sampler_view_default_dx9_template(struct pipe_sampler_view *view,
-                                    const struct pipe_texture *texture,
+                                    const struct pipe_resource *texture,
                                     enum pipe_format format);
 
 
diff --git a/src/gallium/auxiliary/util/u_simple_screen.c b/src/gallium/auxiliary/util/u_simple_screen.c
deleted file mode 100644
index 9203cb6580c..00000000000
--- a/src/gallium/auxiliary/util/u_simple_screen.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.
- * 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.
- *
- **************************************************************************/
-
-#include "u_simple_screen.h"
-
-#include "pipe/p_screen.h"
-#include "pipe/p_state.h"
-#include "util/u_simple_screen.h"
-
-
-static struct pipe_buffer *
-pass_buffer_create(struct pipe_screen *screen,
-                   unsigned alignment,
-                   unsigned usage,
-                   unsigned size)
-{
-   struct pipe_buffer *buffer =
-      screen->winsys->buffer_create(screen->winsys, alignment, usage, size);
-
-   buffer->screen = screen;
-
-   return buffer;
-}
-
-static struct pipe_buffer *
-pass_user_buffer_create(struct pipe_screen *screen,
-                        void *ptr,
-                        unsigned bytes)
-{
-   struct pipe_buffer *buffer =
-      screen->winsys->user_buffer_create(screen->winsys, ptr, bytes);
-
-   buffer->screen = screen;
-
-   return buffer;
-}
-
-
-
-static void *
-pass_buffer_map(struct pipe_screen *screen,
-                struct pipe_buffer *buf,
-                unsigned usage)
-{
-   return screen->winsys->buffer_map(screen->winsys, buf, usage);
-}
-
-static void
-pass_buffer_unmap(struct pipe_screen *screen,
-                  struct pipe_buffer *buf)
-{
-   screen->winsys->buffer_unmap(screen->winsys, buf);
-}
-
-static void
-pass_buffer_destroy(struct pipe_buffer *buf)
-{
-   buf->screen->winsys->buffer_destroy(buf);
-}
-
-
-static void
-pass_flush_frontbuffer(struct pipe_screen *screen,
-                       struct pipe_surface *surf,
-                       void *context_private)
-{
-   screen->winsys->flush_frontbuffer(screen->winsys, surf, context_private);
-}
-
-static void
-pass_fence_reference(struct pipe_screen *screen,
-                     struct pipe_fence_handle **ptr,
-                     struct pipe_fence_handle *fence)
-{
-   screen->winsys->fence_reference(screen->winsys, ptr, fence);
-}
-
-static int
-pass_fence_signalled(struct pipe_screen *screen,
-                     struct pipe_fence_handle *fence,
-                     unsigned flag)
-{
-   return screen->winsys->fence_signalled(screen->winsys, fence, flag);
-}
-
-static int
-pass_fence_finish(struct pipe_screen *screen,
-                  struct pipe_fence_handle *fence,
-                  unsigned flag)
-{
-   return screen->winsys->fence_finish(screen->winsys, fence, flag);
-}
-
-void
-u_simple_screen_init(struct pipe_screen *screen)
-{
-   screen->buffer_create = pass_buffer_create;
-   screen->user_buffer_create = pass_user_buffer_create;
-
-   screen->buffer_map = pass_buffer_map;
-   screen->buffer_unmap = pass_buffer_unmap;
-   screen->buffer_destroy = pass_buffer_destroy;
-   screen->flush_frontbuffer = pass_flush_frontbuffer;
-   screen->fence_reference = pass_fence_reference;
-   screen->fence_signalled = pass_fence_signalled;
-   screen->fence_finish = pass_fence_finish;
-}
-
-const char *
-u_simple_screen_winsys_name(struct pipe_screen *screen)
-{
-   return screen->winsys->get_name(screen->winsys);
-}
diff --git a/src/gallium/auxiliary/util/u_simple_screen.h b/src/gallium/auxiliary/util/u_simple_screen.h
index bb3f5ba102f..b52232f025c 100644
--- a/src/gallium/auxiliary/util/u_simple_screen.h
+++ b/src/gallium/auxiliary/util/u_simple_screen.h
@@ -33,7 +33,7 @@
 struct pipe_screen;
 struct pipe_fence_handle;
 struct pipe_surface;
-struct pipe_buffer;
+struct pipe_resource;
 
 /**
  * Gallium3D drivers are (meant to be!) independent of both GL and the
@@ -53,11 +53,6 @@ struct pipe_winsys
    const char *(*get_name)( struct pipe_winsys *ws );
 
    /**
-    * Do any special operations to ensure buffer size is correct
-    */
-   void (*update_buffer)( struct pipe_winsys *ws,
-                          void *context_private );
-   /**
     * Do any special operations to ensure frontbuffer contents are
     * displayed, eg copy fake frontbuffer.
     */
@@ -73,14 +68,13 @@ struct pipe_winsys
     * window systems must then implement that interface (rather than the
     * other way around...).
     *
-    * usage is a bitmask of PIPE_BUFFER_USAGE_PIXEL/VERTEX/INDEX/CONSTANT. This
-    * usage argument is only an optimization hint, not a guarantee, therefore
-    * proper behavior must be observed in all circumstances.
+    * usage is a bitmask of PIPE_BIND_*.
+    * All possible usages must be present.
     *
     * alignment indicates the client's alignment requirements, eg for
     * SSE instructions.
     */
-   struct pipe_buffer *(*buffer_create)( struct pipe_winsys *ws,
+   struct pipe_resource *(*buffer_create)( struct pipe_winsys *ws,
                                          unsigned alignment,
                                          unsigned usage,
                                          unsigned size );
@@ -106,7 +100,7 @@ struct pipe_winsys
     * Note that ptr may be accessed at any time upto the time when the
     * buffer is destroyed, so the data must not be freed before then.
     */
-   struct pipe_buffer *(*user_buffer_create)(struct pipe_winsys *ws,
+   struct pipe_resource *(*user_buffer_create)(struct pipe_winsys *ws,
                                                     void *ptr,
                                                     unsigned bytes);
 
@@ -117,11 +111,11 @@ struct pipe_winsys
     * display targets) must be allocated with special characteristics, memory
     * pools, or obtained directly from the windowing system.
     *
-    * This callback is invoked by the pipe_screenwhen creating a texture marked
-    * with the PIPE_TEXTURE_USAGE_DISPLAY_TARGET flag  to get the underlying
+    * This callback is invoked by the pipe_screen when creating a texture marked
+    * with the PIPE_BIND_DISPLAY_TARGET flag  to get the underlying
     * buffer storage.
     */
-   struct pipe_buffer *(*surface_buffer_create)(struct pipe_winsys *ws,
+   struct pipe_resource *(*surface_buffer_create)(struct pipe_winsys *ws,
                                                 unsigned width, unsigned height,
                                                 enum pipe_format format,
                                                 unsigned usage,
@@ -134,13 +128,13 @@ struct pipe_winsys
     * flags is bitmask of PIPE_BUFFER_USAGE_CPU_READ/WRITE flags.
     */
    void *(*buffer_map)( struct pipe_winsys *ws,
-                        struct pipe_buffer *buf,
+                        struct pipe_resource *buf,
                         unsigned usage );
 
    void (*buffer_unmap)( struct pipe_winsys *ws,
-                         struct pipe_buffer *buf );
+                         struct pipe_resource *buf );
 
-   void (*buffer_destroy)( struct pipe_buffer *buf );
+   void (*buffer_destroy)( struct pipe_resource *buf );
 
 
    /** Set ptr = fence, with reference counting */
diff --git a/src/gallium/auxiliary/util/u_surface.c b/src/gallium/auxiliary/util/u_surface.c
index 33306bbc2a6..42440d0d673 100644
--- a/src/gallium/auxiliary/util/u_surface.c
+++ b/src/gallium/auxiliary/util/u_surface.c
@@ -50,7 +50,8 @@
 boolean
 util_create_rgba_surface(struct pipe_screen *screen,
                          uint width, uint height,
-                         struct pipe_texture **textureOut,
+			 uint bind,
+                         struct pipe_resource **textureOut,
                          struct pipe_surface **surfaceOut)
 {
    static const enum pipe_format rgbaFormats[] = {
@@ -60,15 +61,14 @@ util_create_rgba_surface(struct pipe_screen *screen,
       PIPE_FORMAT_NONE
    };
    const uint target = PIPE_TEXTURE_2D;
-   const uint usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
    enum pipe_format format = PIPE_FORMAT_NONE;
-   struct pipe_texture templ;
+   struct pipe_resource templ;
    uint i;
 
    /* Choose surface format */
    for (i = 0; rgbaFormats[i]; i++) {
       if (screen->is_format_supported(screen, rgbaFormats[i],
-                                      target, usage, 0)) {
+                                      target, bind, 0)) {
          format = rgbaFormats[i];
          break;
       }
@@ -84,16 +84,19 @@ util_create_rgba_surface(struct pipe_screen *screen,
    templ.width0 = width;
    templ.height0 = height;
    templ.depth0 = 1;
-   templ.tex_usage = usage;
+   templ.bind = bind;
 
-   *textureOut = screen->texture_create(screen, &templ);
+   *textureOut = screen->resource_create(screen, &templ);
    if (!*textureOut)
       return FALSE;
 
    /* create surface / view into texture */
-   *surfaceOut = screen->get_tex_surface(screen, *textureOut, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
+   *surfaceOut = screen->get_tex_surface(screen, 
+					 *textureOut,
+					 0, 0, 0,
+					 bind);
    if (!*surfaceOut) {
-      pipe_texture_reference(textureOut, NULL);
+      pipe_resource_reference(textureOut, NULL);
       return FALSE;
    }
 
@@ -105,11 +108,11 @@ util_create_rgba_surface(struct pipe_screen *screen,
  * Release the surface and texture from util_create_rgba_surface().
  */
 void
-util_destroy_rgba_surface(struct pipe_texture *texture,
+util_destroy_rgba_surface(struct pipe_resource *texture,
                           struct pipe_surface *surface)
 {
    pipe_surface_reference(&surface, NULL);
-   pipe_texture_reference(&texture, NULL);
+   pipe_resource_reference(&texture, NULL);
 }
 
 
diff --git a/src/gallium/auxiliary/util/u_surface.h b/src/gallium/auxiliary/util/u_surface.h
index 3c60df2c3e5..119fcd4ce8e 100644
--- a/src/gallium/auxiliary/util/u_surface.h
+++ b/src/gallium/auxiliary/util/u_surface.h
@@ -52,13 +52,13 @@ util_same_surface(const struct pipe_surface *s1, const struct pipe_surface *s2)
 
 extern boolean
 util_create_rgba_surface(struct pipe_screen *screen,
-                         uint width, uint height,
-                         struct pipe_texture **textureOut,
+                         uint width, uint height, uint bind,
+                         struct pipe_resource **textureOut,
                          struct pipe_surface **surfaceOut);
 
 
 extern void
-util_destroy_rgba_surface(struct pipe_texture *texture,
+util_destroy_rgba_surface(struct pipe_resource *texture,
                           struct pipe_surface *surface);
 
 
diff --git a/src/gallium/auxiliary/util/u_tile.c b/src/gallium/auxiliary/util/u_tile.c
index 43b45eb9260..fe327c302b7 100644
--- a/src/gallium/auxiliary/util/u_tile.c
+++ b/src/gallium/auxiliary/util/u_tile.c
@@ -53,9 +53,9 @@ pipe_get_tile_raw(struct pipe_context *pipe,
    const void *src;
 
    if (dst_stride == 0)
-      dst_stride = util_format_get_stride(pt->texture->format, w);
+      dst_stride = util_format_get_stride(pt->resource->format, w);
 
-   if (pipe_clip_tile(x, y, &w, &h, pt))
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
       return;
 
    src = pipe->transfer_map(pipe, pt);
@@ -63,7 +63,7 @@ pipe_get_tile_raw(struct pipe_context *pipe,
    if(!src)
       return;
 
-   util_copy_rect(dst, pt->texture->format, dst_stride, 0, 0, w, h, src, pt->stride, x, y);
+   util_copy_rect(dst, pt->resource->format, dst_stride, 0, 0, w, h, src, pt->stride, x, y);
 
    pipe->transfer_unmap(pipe, pt);
 }
@@ -79,12 +79,12 @@ pipe_put_tile_raw(struct pipe_context *pipe,
                   const void *src, int src_stride)
 {
    void *dst;
-   enum pipe_format format = pt->texture->format;
+   enum pipe_format format = pt->resource->format;
 
    if (src_stride == 0)
       src_stride = util_format_get_stride(format, w);
 
-   if (pipe_clip_tile(x, y, &w, &h, pt))
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
       return;
 
    dst = pipe->transfer_map(pipe, pt);
@@ -137,185 +137,6 @@ z16_get_tile_rgba(const ushort *src,
 
 
 
-/*** PIPE_FORMAT_A8B8G8R8_SRGB ***/
-
-/**
- * Convert an 8-bit sRGB value from non-linear space to a
- * linear RGB value in [0, 1].
- * Implemented with a 256-entry lookup table.
- */
-static INLINE float
-srgb_to_linear(ubyte cs8)
-{
-   static float table[256];
-   static boolean tableReady = FALSE;
-   if (!tableReady) {
-      /* compute lookup table now */
-      uint i;
-      for (i = 0; i < 256; i++) {
-         const float cs = ubyte_to_float(i);
-         if (cs <= 0.04045) {
-            table[i] = cs / 12.92f;
-         }
-         else {
-            table[i] = (float) powf((cs + 0.055) / 1.055, 2.4);
-         }
-      }
-      tableReady = TRUE;
-   }
-   return table[cs8];
-}
-
-
-/**
- * Convert linear float in [0,1] to an srgb ubyte value in [0,255].
- * XXX this hasn't been tested (render to srgb surface).
- * XXX this needs optimization.
- */
-static INLINE ubyte
-linear_to_srgb(float cl)
-{
-   if (cl >= 1.0F)
-      return 255;
-   else if (cl >= 0.0031308F)
-      return float_to_ubyte(1.055F * powf(cl, 0.41666F) - 0.055F);
-   else if (cl > 0.0F)
-      return float_to_ubyte(12.92F * cl);
-   else
-      return 0.0;
-}
-
-
-static void
-a8r8g8b8_srgb_get_tile_rgba(const unsigned *src,
-                            unsigned w, unsigned h,
-                            float *p,
-                            unsigned dst_stride)
-{
-   unsigned i, j;
-
-   for (i = 0; i < h; i++) {
-      float *pRow = p;
-      for (j = 0; j < w; j++, pRow += 4) {
-         const unsigned pixel = *src++;
-         pRow[0] = srgb_to_linear((pixel >> 16) & 0xff);
-         pRow[1] = srgb_to_linear((pixel >>  8) & 0xff);
-         pRow[2] = srgb_to_linear((pixel >>  0) & 0xff);
-         pRow[3] = ubyte_to_float((pixel >> 24) & 0xff);
-      }
-      p += dst_stride;
-   }
-}
-
-static void
-a8r8g8b8_srgb_put_tile_rgba(unsigned *dst,
-                            unsigned w, unsigned h,
-                            const float *p,
-                            unsigned src_stride)
-{
-   unsigned i, j;
-
-   for (i = 0; i < h; i++) {
-      const float *pRow = p;
-      for (j = 0; j < w; j++, pRow += 4) {
-         unsigned r, g, b, a;
-         r = linear_to_srgb(pRow[0]);
-         g = linear_to_srgb(pRow[1]);
-         b = linear_to_srgb(pRow[2]);
-         a = float_to_ubyte(pRow[3]);
-         *dst++ = (a << 24) | (r << 16) | (g << 8) | b;
-      }
-      p += src_stride;
-   }
-}
-
-
-/*** PIPE_FORMAT_L8A8_SRGB ***/
-
-static void
-a8l8_srgb_get_tile_rgba(const ushort *src,
-                        unsigned w, unsigned h,
-                        float *p,
-                        unsigned dst_stride)
-{
-   unsigned i, j;
-
-   for (i = 0; i < h; i++) {
-      float *pRow = p;
-      for (j = 0; j < w; j++, pRow += 4) {
-         ushort p = *src++;
-         pRow[0] =
-         pRow[1] =
-         pRow[2] = srgb_to_linear(p & 0xff);
-         pRow[3] = ubyte_to_float(p >> 8);
-      }
-      p += dst_stride;
-   }
-}
-
-static void
-a8l8_srgb_put_tile_rgba(ushort *dst,
-                        unsigned w, unsigned h,
-                        const float *p,
-                        unsigned src_stride)
-{
-   unsigned i, j;
-
-   for (i = 0; i < h; i++) {
-      const float *pRow = p;
-      for (j = 0; j < w; j++, pRow += 4) {
-         unsigned r, a;
-         r = linear_to_srgb(pRow[0]);
-         a = float_to_ubyte(pRow[3]);
-         *dst++ = (a << 8) | r;
-      }
-      p += src_stride;
-   }
-}
-
-
-/*** PIPE_FORMAT_L8_SRGB ***/
-
-static void
-l8_srgb_get_tile_rgba(const ubyte *src,
-                      unsigned w, unsigned h,
-                      float *p,
-                      unsigned dst_stride)
-{
-   unsigned i, j;
-
-   for (i = 0; i < h; i++) {
-      float *pRow = p;
-      for (j = 0; j < w; j++, src++, pRow += 4) {
-         pRow[0] =
-         pRow[1] =
-         pRow[2] = srgb_to_linear(*src);
-         pRow[3] = 1.0;
-      }
-      p += dst_stride;
-   }
-}
-
-static void
-l8_srgb_put_tile_rgba(ubyte *dst,
-                      unsigned w, unsigned h,
-                      const float *p,
-                      unsigned src_stride)
-{
-   unsigned i, j;
-
-   for (i = 0; i < h; i++) {
-      const float *pRow = p;
-      for (j = 0; j < w; j++, pRow += 4) {
-         unsigned r;
-         r = linear_to_srgb(pRow[0]);
-         *dst++ = (ubyte) r;
-      }
-      p += src_stride;
-   }
-}
-
-
 /*** PIPE_FORMAT_Z32_UNORM ***/
 
 /**
@@ -423,94 +244,6 @@ z32f_get_tile_rgba(const float *src,
 }
 
 
-/*** PIPE_FORMAT_UYVY / PIPE_FORMAT_YUYV ***/
-
-/**
- * Convert YCbCr (or YCrCb) to RGBA.
- */
-static void
-ycbcr_get_tile_rgba(const ushort *src,
-                    unsigned w, unsigned h,
-                    float *p,
-                    unsigned dst_stride,
-                    boolean rev)
-{
-   const float scale = 1.0f / 255.0f;
-   unsigned i, j;
-
-   for (i = 0; i < h; i++) {
-      float *pRow = p;
-      /* do two texels at a time */
-      for (j = 0; j < (w & ~1); j += 2, src += 2) {
-         const ushort t0 = src[0];
-         const ushort t1 = src[1];
-         const ubyte y0 = (t0 >> 8) & 0xff;  /* luminance */
-         const ubyte y1 = (t1 >> 8) & 0xff;  /* luminance */
-         ubyte cb, cr;
-         float r, g, b;
-
-         if (rev) {
-            cb = t1 & 0xff;         /* chroma U */
-            cr = t0 & 0xff;         /* chroma V */
-         }
-         else {
-            cb = t0 & 0xff;         /* chroma U */
-            cr = t1 & 0xff;         /* chroma V */
-         }
-
-         /* even pixel: y0,cr,cb */
-         r = 1.164f * (y0-16) + 1.596f * (cr-128);
-         g = 1.164f * (y0-16) - 0.813f * (cr-128) - 0.391f * (cb-128);
-         b = 1.164f * (y0-16) + 2.018f * (cb-128);
-         pRow[0] = r * scale;
-         pRow[1] = g * scale;
-         pRow[2] = b * scale;
-         pRow[3] = 1.0f;
-         pRow += 4;
-
-         /* odd pixel: use y1,cr,cb */
-         r = 1.164f * (y1-16) + 1.596f * (cr-128);
-         g = 1.164f * (y1-16) - 0.813f * (cr-128) - 0.391f * (cb-128);
-         b = 1.164f * (y1-16) + 2.018f * (cb-128);
-         pRow[0] = r * scale;
-         pRow[1] = g * scale;
-         pRow[2] = b * scale;
-         pRow[3] = 1.0f;
-         pRow += 4;
-
-      }
-      /* do the last texel */
-      if (w & 1) {
-         const ushort t0 = src[0];
-         const ushort t1 = src[1];
-         const ubyte y0 = (t0 >> 8) & 0xff;  /* luminance */
-         ubyte cb, cr;
-         float r, g, b;
-
-         if (rev) {
-            cb = t1 & 0xff;         /* chroma U */
-            cr = t0 & 0xff;         /* chroma V */
-         }
-         else {
-            cb = t0 & 0xff;         /* chroma U */
-            cr = t1 & 0xff;         /* chroma V */
-         }
-
-         /* even pixel: y0,cr,cb */
-         r = 1.164f * (y0-16) + 1.596f * (cr-128);
-         g = 1.164f * (y0-16) - 0.813f * (cr-128) - 0.391f * (cb-128);
-         b = 1.164f * (y0-16) + 2.018f * (cb-128);
-         pRow[0] = r * scale;
-         pRow[1] = g * scale;
-         pRow[2] = b * scale;
-         pRow[3] = 1.0f;
-         pRow += 4;
-      }
-      p += dst_stride;
-   }
-}
-
-
 void
 pipe_tile_raw_to_rgba(enum pipe_format format,
                       void *src,
@@ -518,15 +251,6 @@ pipe_tile_raw_to_rgba(enum pipe_format format,
                       float *dst, unsigned dst_stride)
 {
    switch (format) {
-   case PIPE_FORMAT_B8G8R8A8_SRGB:
-      a8r8g8b8_srgb_get_tile_rgba((unsigned *) src, w, h, dst, dst_stride);
-      break;
-   case PIPE_FORMAT_L8A8_SRGB:
-      a8l8_srgb_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
-      break;
-   case PIPE_FORMAT_L8_SRGB:
-      l8_srgb_get_tile_rgba((ubyte *) src, w, h, dst, dst_stride);
-      break;
    case PIPE_FORMAT_Z16_UNORM:
       z16_get_tile_rgba((ushort *) src, w, h, dst, dst_stride);
       break;
@@ -544,12 +268,6 @@ pipe_tile_raw_to_rgba(enum pipe_format format,
    case PIPE_FORMAT_Z32_FLOAT:
       z32f_get_tile_rgba((float *) src, w, h, dst, dst_stride);
       break;
-   case PIPE_FORMAT_UYVY:
-      ycbcr_get_tile_rgba((ushort *) src, w, h, dst, dst_stride, FALSE);
-      break;
-   case PIPE_FORMAT_YUYV:
-      ycbcr_get_tile_rgba((ushort *) src, w, h, dst, dst_stride, TRUE);
-      break;
    default:
       util_format_read_4f(format,
                           dst, dst_stride * sizeof(float),
@@ -567,9 +285,9 @@ pipe_get_tile_rgba(struct pipe_context *pipe,
 {
    unsigned dst_stride = w * 4;
    void *packed;
-   enum pipe_format format = pt->texture->format;
+   enum pipe_format format = pt->resource->format;
 
-   if (pipe_clip_tile(x, y, &w, &h, pt))
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
       return;
 
    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
@@ -604,10 +322,10 @@ pipe_get_tile_swizzle(struct pipe_context *pipe,
 {
    unsigned dst_stride = w * 4;
    void *packed;
-   uint i;
+   uint iy;
    float rgba01[6];
 
-   if (pipe_clip_tile(x, y, &w, &h, pt)) {
+   if (u_clip_tile(x, y, &w, &h, &pt->box)) {
       return;
    }
 
@@ -637,16 +355,22 @@ pipe_get_tile_swizzle(struct pipe_context *pipe,
    rgba01[PIPE_SWIZZLE_ZERO] = 0.0f;
    rgba01[PIPE_SWIZZLE_ONE] = 1.0f;
 
-   for (i = 0; i < w * h; i++) {
-      rgba01[PIPE_SWIZZLE_RED] = p[0];
-      rgba01[PIPE_SWIZZLE_GREEN] = p[1];
-      rgba01[PIPE_SWIZZLE_BLUE] = p[2];
-      rgba01[PIPE_SWIZZLE_ALPHA] = p[3];
+   for (iy = 0; iy < h; iy++) {
+      float *row = p;
+      uint ix;
+
+      for (ix = 0; ix < w; ix++) {
+         rgba01[PIPE_SWIZZLE_RED] = row[0];
+         rgba01[PIPE_SWIZZLE_GREEN] = row[1];
+         rgba01[PIPE_SWIZZLE_BLUE] = row[2];
+         rgba01[PIPE_SWIZZLE_ALPHA] = row[3];
 
-      *p++ = rgba01[swizzle_r];
-      *p++ = rgba01[swizzle_g];
-      *p++ = rgba01[swizzle_b];
-      *p++ = rgba01[swizzle_a];
+         *row++ = rgba01[swizzle_r];
+         *row++ = rgba01[swizzle_g];
+         *row++ = rgba01[swizzle_b];
+         *row++ = rgba01[swizzle_a];
+      }
+      p += dst_stride;
    }
 }
 
@@ -659,9 +383,9 @@ pipe_put_tile_rgba(struct pipe_context *pipe,
 {
    unsigned src_stride = w * 4;
    void *packed;
-   enum pipe_format format = pt->texture->format;
+   enum pipe_format format = pt->resource->format;
 
-   if (pipe_clip_tile(x, y, &w, &h, pt))
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
       return;
 
    packed = MALLOC(util_format_get_nblocks(format, w, h) * util_format_get_blocksize(format));
@@ -670,15 +394,6 @@ pipe_put_tile_rgba(struct pipe_context *pipe,
       return;
 
    switch (format) {
-   case PIPE_FORMAT_B8G8R8A8_SRGB:
-      a8r8g8b8_srgb_put_tile_rgba((unsigned *) packed, w, h, p, src_stride);
-      break;
-   case PIPE_FORMAT_L8A8_SRGB:
-      a8l8_srgb_put_tile_rgba((ushort *) packed, w, h, p, src_stride);
-      break;
-   case PIPE_FORMAT_L8_SRGB:
-      l8_srgb_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);
-      break;
    case PIPE_FORMAT_Z16_UNORM:
       /*z16_put_tile_rgba((ushort *) packed, w, h, p, src_stride);*/
       break;
@@ -719,9 +434,9 @@ pipe_get_tile_z(struct pipe_context *pipe,
    ubyte *map;
    uint *pDest = z;
    uint i, j;
-   enum pipe_format format = pt->texture->format;
+   enum pipe_format format = pt->resource->format;
 
-   if (pipe_clip_tile(x, y, &w, &h, pt))
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
       return;
 
    map = (ubyte *)pipe->transfer_map(pipe, pt);
@@ -804,9 +519,9 @@ pipe_put_tile_z(struct pipe_context *pipe,
    const uint *ptrc = zSrc;
    ubyte *map;
    uint i, j;
-   enum pipe_format format = pt->texture->format;
+   enum pipe_format format = pt->resource->format;
 
-   if (pipe_clip_tile(x, y, &w, &h, pt))
+   if (u_clip_tile(x, y, &w, &h, &pt->box))
       return;
 
    map = (ubyte *)pipe->transfer_map(pipe, pt);
@@ -829,7 +544,7 @@ pipe_put_tile_z(struct pipe_context *pipe,
    case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
       {
          uint *pDest = (uint *) (map + y * pt->stride + x*4);
-         assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);
+         //assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 32-bit Z to 24-bit Z, preserve stencil */
@@ -856,7 +571,7 @@ pipe_put_tile_z(struct pipe_context *pipe,
    case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
       {
          uint *pDest = (uint *) (map + y * pt->stride + x*4);
-         assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);
+         //assert((pt->usage & PIPE_TRANSFER_READ_WRITE) == PIPE_TRANSFER_READ_WRITE);
          for (i = 0; i < h; i++) {
             for (j = 0; j < w; j++) {
                /* convert 32-bit Z to 24-bit Z, preserve stencil */
diff --git a/src/gallium/auxiliary/util/u_tile.h b/src/gallium/auxiliary/util/u_tile.h
index 1d8ce7d8cbc..986eee07435 100644
--- a/src/gallium/auxiliary/util/u_tile.h
+++ b/src/gallium/auxiliary/util/u_tile.h
@@ -32,22 +32,24 @@
 
 struct pipe_transfer;
 
-
 /**
  * Clip tile against transfer dims.
+ *
+ * XXX: this only clips width and height!
+ *
  * \return TRUE if tile is totally clipped, FALSE otherwise
  */
 static INLINE boolean
-pipe_clip_tile(uint x, uint y, uint *w, uint *h, const struct pipe_transfer *pt)
+u_clip_tile(uint x, uint y, uint *w, uint *h, const struct pipe_box *box)
 {
-   if (x >= pt->width)
+   if (x >= box->width)
       return TRUE;
-   if (y >= pt->height)
+   if (y >= box->height)
       return TRUE;
-   if (x + *w > pt->width)
-      *w = pt->width - x;
-   if (y + *h > pt->height)
-      *h = pt->height - y;
+   if (x + *w > box->width)
+      *w = box->width - x;
+   if (y + *h > box->height)
+      *h = box->height - y;
    return FALSE;
 }
 
diff --git a/src/gallium/auxiliary/util/u_timed_winsys.c b/src/gallium/auxiliary/util/u_timed_winsys.c
deleted file mode 100644
index d88298bc14c..00000000000
--- a/src/gallium/auxiliary/util/u_timed_winsys.c
+++ /dev/null
@@ -1,312 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA
- * 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 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
- * THE COPYRIGHT HOLDERS, AUTHORS 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.
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- * 
- * 
- **************************************************************************/
-/*
- * Authors: Keith Whitwell <keithw-at-tungstengraphics-dot-com>
- */
-
-#include "pipe/p_state.h"
-#include "util/u_simple_screen.h"
-#include "u_timed_winsys.h"
-#include "util/u_memory.h"
-#include "os/os_time.h"
-
-
-struct timed_winsys {
-   struct pipe_winsys base;
-   struct pipe_winsys *backend;
-   uint64_t last_dump;
-   struct {
-      const char *name_key;
-      double total;
-      unsigned calls;
-   } funcs[13];
-};
-
-
-static struct timed_winsys *timed_winsys( struct pipe_winsys *winsys )
-{
-   return (struct timed_winsys *)winsys;
-}
-
-
-static void time_display( struct pipe_winsys *winsys )
-{
-   struct timed_winsys *tws = timed_winsys(winsys);
-   unsigned i;
-   double overall = 0;
-
-   for (i = 0; i < Elements(tws->funcs); i++) {
-      if (tws->funcs[i].name_key) {
-         debug_printf("*** %-25s %5.3fms (%d calls, avg %.3fms)\n", 
-                      tws->funcs[i].name_key,
-                      tws->funcs[i].total,
-                      tws->funcs[i].calls,
-                      tws->funcs[i].total / tws->funcs[i].calls);
-         overall += tws->funcs[i].total;
-         tws->funcs[i].calls = 0;
-         tws->funcs[i].total = 0;
-      }
-   }
-
-   debug_printf("*** %-25s %5.3fms\n", 
-                "OVERALL WINSYS",
-                overall);
-}
-
-static void time_finish( struct pipe_winsys *winsys,
-                         long long startval, 
-                         unsigned idx,
-                         const char *name ) 
-{
-   struct timed_winsys *tws = timed_winsys(winsys);
-   int64_t endval = os_time_get();
-   double elapsed = (endval - startval)/1000.0;
-
-   if (endval - startval > 1000LL) 
-      debug_printf("*** %s %.3f\n", name, elapsed );
-
-   assert( tws->funcs[idx].name_key == name ||
-           tws->funcs[idx].name_key == NULL);
-
-   tws->funcs[idx].name_key = name;
-   tws->funcs[idx].total += elapsed;
-   tws->funcs[idx].calls++;
-
-   if (endval - tws->last_dump > 10LL * 1000LL * 1000LL) {
-      time_display( winsys );
-      tws->last_dump = endval;
-   }
-}
-
-
-/* Pipe has no concept of pools, but the psb driver passes a flag that
- * can be mapped onto pools in the backend.
- */
-static struct pipe_buffer *
-timed_buffer_create(struct pipe_winsys *winsys, 
-                    unsigned alignment, 
-                    unsigned usage, 
-                    unsigned size )
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   struct pipe_buffer *buf =
-      backend->buffer_create( backend, alignment, usage, size );
-
-   time_finish(winsys, start, 0, __FUNCTION__);
-   
-   return buf;
-}
-
-
-
-
-static struct pipe_buffer *
-timed_user_buffer_create(struct pipe_winsys *winsys,
-                             void *data, 
-                             unsigned bytes) 
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   struct pipe_buffer *buf = backend->user_buffer_create( backend, data, bytes );
-
-   time_finish(winsys, start, 1, __FUNCTION__);
-   
-   return buf;
-}
-
-
-static void *
-timed_buffer_map(struct pipe_winsys *winsys,
-                     struct pipe_buffer *buf,
-                     unsigned flags)
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   void *map = backend->buffer_map( backend, buf, flags );
-
-   time_finish(winsys, start, 2, __FUNCTION__);
-   
-   return map;
-}
-
-
-static void
-timed_buffer_unmap(struct pipe_winsys *winsys,
-                       struct pipe_buffer *buf)
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   backend->buffer_unmap( backend, buf );
-
-   time_finish(winsys, start, 3, __FUNCTION__);
-}
-
-
-static void
-timed_buffer_destroy(struct pipe_buffer *buf)
-{
-   struct pipe_winsys *winsys = buf->screen->winsys;
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   backend->buffer_destroy( buf );
-
-   time_finish(winsys, start, 4, __FUNCTION__);
-}
-
-
-static void
-timed_flush_frontbuffer( struct pipe_winsys *winsys,
-                         struct pipe_surface *surf,
-                         void *context_private)
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   backend->flush_frontbuffer( backend, surf, context_private );
-
-   time_finish(winsys, start, 5, __FUNCTION__);
-}
-
-
-
-
-static struct pipe_buffer *
-timed_surface_buffer_create(struct pipe_winsys *winsys,
-                              unsigned width, unsigned height,
-                              enum pipe_format format, 
-                              unsigned usage,
-                              unsigned tex_usage,
-                              unsigned *stride)
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   struct pipe_buffer *ret = backend->surface_buffer_create( backend, width, height, 
-                                                             format, usage, tex_usage, stride );
-
-   time_finish(winsys, start, 7, __FUNCTION__);
-   
-   return ret;
-}
-
-
-static const char *
-timed_get_name( struct pipe_winsys *winsys )
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   const char *ret = backend->get_name( backend );
-
-   time_finish(winsys, start, 9, __FUNCTION__);
-   
-   return ret;
-}
-
-static void
-timed_fence_reference(struct pipe_winsys *winsys,
-                    struct pipe_fence_handle **ptr,
-                    struct pipe_fence_handle *fence)
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   backend->fence_reference( backend, ptr, fence );
-
-   time_finish(winsys, start, 10, __FUNCTION__);
-}
-
-
-static int
-timed_fence_signalled( struct pipe_winsys *winsys,
-                       struct pipe_fence_handle *fence,
-                       unsigned flag )
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   int ret = backend->fence_signalled( backend, fence, flag );
-
-   time_finish(winsys, start, 11, __FUNCTION__);
-   
-   return ret;
-}
-
-static int
-timed_fence_finish( struct pipe_winsys *winsys,
-                     struct pipe_fence_handle *fence,
-                     unsigned flag )
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   int64_t start = os_time_get();
-
-   int ret = backend->fence_finish( backend, fence, flag );
-
-   time_finish(winsys, start, 12, __FUNCTION__);
-   
-   return ret;
-}
-
-static void
-timed_winsys_destroy( struct pipe_winsys *winsys )
-{
-   struct pipe_winsys *backend = timed_winsys(winsys)->backend;
-   backend->destroy( backend );
-   FREE(winsys);
-}
-
-
-
-struct pipe_winsys *u_timed_winsys_create( struct pipe_winsys *backend )
-{
-   struct timed_winsys *ws = CALLOC_STRUCT(timed_winsys);
-   
-   ws->base.user_buffer_create = timed_user_buffer_create;
-   ws->base.buffer_map = timed_buffer_map;
-   ws->base.buffer_unmap = timed_buffer_unmap;
-   ws->base.buffer_destroy = timed_buffer_destroy;
-   ws->base.buffer_create = timed_buffer_create;
-   ws->base.surface_buffer_create = timed_surface_buffer_create;
-   ws->base.flush_frontbuffer = timed_flush_frontbuffer;
-   ws->base.get_name = timed_get_name;
-   ws->base.fence_reference = timed_fence_reference;
-   ws->base.fence_signalled = timed_fence_signalled;
-   ws->base.fence_finish = timed_fence_finish;
-   ws->base.destroy = timed_winsys_destroy;
-   
-   ws->backend = backend;
-
-   return &ws->base;
-}
-
diff --git a/src/gallium/auxiliary/util/u_timed_winsys.h b/src/gallium/auxiliary/util/u_timed_winsys.h
deleted file mode 100644
index 542365112d7..00000000000
--- a/src/gallium/auxiliary/util/u_timed_winsys.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA
- * 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 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
- * THE COPYRIGHT HOLDERS, AUTHORS 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.
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- * 
- * 
- **************************************************************************/
-/*
- * Authors: Keith Whitwell <keithw-at-tungstengraphics-dot-com>
- */
-
-
-#ifndef U_TIMED_WINSYS_H
-#define U_TIMED_WINSYS_H
-
-
-struct pipe_winsys;
-struct pipe_winsys *u_timed_winsys_create( struct pipe_winsys *backend );
-
-
-#endif
diff --git a/src/gallium/auxiliary/util/u_transfer.c b/src/gallium/auxiliary/util/u_transfer.c
new file mode 100644
index 00000000000..bedace3b1dc
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_transfer.c
@@ -0,0 +1,110 @@
+#include "pipe/p_context.h"
+#include "util/u_rect.h"
+#include "util/u_inlines.h"
+#include "util/u_transfer.h"
+#include "util/u_memory.h"
+
+/* One-shot transfer operation with data supplied in a user
+ * pointer.  XXX: strides??
+ */
+void u_default_transfer_inline_write( struct pipe_context *pipe,
+				      struct pipe_resource *resource,
+				      struct pipe_subresource sr,
+				      unsigned usage,
+				      const struct pipe_box *box,
+				      const void *data,
+				      unsigned stride,
+				      unsigned slice_stride)
+{
+   struct pipe_transfer *transfer = NULL;
+   uint8_t *map = NULL;
+
+   transfer = pipe->get_transfer(pipe, 
+				 resource,
+				 sr,
+				 usage,
+				 box );
+   if (transfer == NULL)
+      goto out;
+
+   map = pipe_transfer_map(pipe, transfer);
+   if (map == NULL)
+      goto out;
+
+   assert(box->depth == 1);	/* XXX: fix me */
+   
+   util_copy_rect(map,
+		  resource->format,
+		  transfer->stride, /* bytes? */
+		  0, 0,
+		  box->width,
+		  box->height,
+		  data,
+		  box->width,	/* bytes? texels? */
+		  0, 0);
+
+out:
+   if (map)
+      pipe_transfer_unmap(pipe, transfer);
+
+   if (transfer)
+      pipe_transfer_destroy(pipe, transfer);
+}
+
+
+boolean u_default_resource_get_handle(struct pipe_screen *screen,
+				      struct pipe_resource *resource,
+				      struct winsys_handle *handle)
+{
+   return FALSE;
+}
+
+
+
+void u_default_transfer_flush_region( struct pipe_context *pipe,
+				      struct pipe_transfer *transfer,
+				      const struct pipe_box *box)
+{
+   /* This is a no-op implementation, nothing to do.
+    */
+}
+
+unsigned u_default_is_resource_referenced( struct pipe_context *pipe,
+					   struct pipe_resource *resource,
+					unsigned face, unsigned level)
+{
+   return 0;
+}
+
+struct pipe_transfer * u_default_get_transfer(struct pipe_context *context,
+					      struct pipe_resource *resource,
+					      struct pipe_subresource sr,
+					      unsigned usage,
+					      const struct pipe_box *box)
+{
+   struct pipe_transfer *transfer = CALLOC_STRUCT(pipe_transfer);
+   if (transfer == NULL)
+      return NULL;
+
+   transfer->resource = resource;
+   transfer->sr = sr;
+   transfer->usage = usage;
+   transfer->box = *box;
+
+   /* Note strides are zero, this is ok for buffers, but not for
+    * textures 2d & higher at least. 
+    */
+   return transfer;
+}
+
+void u_default_transfer_unmap( struct pipe_context *pipe,
+			      struct pipe_transfer *transfer )
+{
+}
+
+void u_default_transfer_destroy(struct pipe_context *pipe,
+				struct pipe_transfer *transfer)
+{
+   FREE(transfer);
+}
+
diff --git a/src/gallium/auxiliary/util/u_transfer.h b/src/gallium/auxiliary/util/u_transfer.h
new file mode 100644
index 00000000000..eb07945d15f
--- /dev/null
+++ b/src/gallium/auxiliary/util/u_transfer.h
@@ -0,0 +1,145 @@
+
+#ifndef U_TRANSFER_H
+#define U_TRANSFER_H
+
+/* Fallback implementations for inline read/writes which just go back
+ * to the regular transfer behaviour.
+ */
+#include "pipe/p_state.h"
+
+struct pipe_context;
+
+boolean u_default_resource_get_handle(struct pipe_screen *screen,
+				      struct pipe_resource *resource,
+				      struct winsys_handle *handle);
+
+void u_default_transfer_inline_write( struct pipe_context *pipe,
+			      struct pipe_resource *resource,
+			      struct pipe_subresource sr,
+			      unsigned usage,
+			      const struct pipe_box *box,
+			      const void *data,
+			      unsigned stride,
+			      unsigned slice_stride);
+
+void u_default_transfer_flush_region( struct pipe_context *pipe,
+				      struct pipe_transfer *transfer,
+				      const struct pipe_box *box);
+
+unsigned u_default_is_resource_referenced( struct pipe_context *pipe,
+					   struct pipe_resource *resource,
+					   unsigned face, unsigned level);
+
+struct pipe_transfer * u_default_get_transfer(struct pipe_context *context,
+					      struct pipe_resource *resource,
+					      struct pipe_subresource sr,
+					      unsigned usage,
+					      const struct pipe_box *box);
+
+void u_default_transfer_unmap( struct pipe_context *pipe,
+			       struct pipe_transfer *transfer );
+
+void u_default_transfer_destroy(struct pipe_context *pipe,
+				struct pipe_transfer *transfer);
+
+
+
+/* Useful helper to allow >1 implementation of resource functionality
+ * to exist in a single driver.  This is intended to be transitionary!
+ */
+struct u_resource_vtbl {
+
+   boolean (*resource_get_handle)(struct pipe_screen *,
+				  struct pipe_resource *tex,
+				  struct winsys_handle *handle);
+
+   void (*resource_destroy)(struct pipe_screen *,
+			    struct pipe_resource *pt);
+
+   unsigned (*is_resource_referenced)(struct pipe_context *pipe,
+				      struct pipe_resource *texture,
+				      unsigned face, unsigned level);
+
+   struct pipe_transfer *(*get_transfer)(struct pipe_context *,
+					 struct pipe_resource *resource,
+					 struct pipe_subresource,
+					 unsigned usage,
+					 const struct pipe_box *);
+
+   void (*transfer_destroy)(struct pipe_context *,
+			    struct pipe_transfer *);
+
+   void *(*transfer_map)( struct pipe_context *,
+			  struct pipe_transfer *transfer );
+
+   void (*transfer_flush_region)( struct pipe_context *,
+				  struct pipe_transfer *transfer,
+				  const struct pipe_box *);
+
+   void (*transfer_unmap)( struct pipe_context *,
+			   struct pipe_transfer *transfer );
+
+   void (*transfer_inline_write)( struct pipe_context *pipe,
+				  struct pipe_resource *resource,
+				  struct pipe_subresource sr,
+				  unsigned usage,
+				  const struct pipe_box *box,
+				  const void *data,
+				  unsigned stride,
+				  unsigned slice_stride);
+};
+
+
+struct u_resource {
+   struct pipe_resource b;
+   struct u_resource_vtbl *vtbl;
+};
+
+
+boolean u_resource_get_handle_vtbl(struct pipe_screen *screen,
+			      struct pipe_resource *resource,
+			      struct winsys_handle *handle);
+
+void u_resource_destroy_vtbl(struct pipe_screen *screen,
+			struct pipe_resource *resource);
+
+unsigned u_is_resource_referenced_vtbl( struct pipe_context *pipe,
+					struct pipe_resource *resource,
+					unsigned face, unsigned level);
+
+struct pipe_transfer *u_get_transfer_vtbl(struct pipe_context *context,
+				     struct pipe_resource *resource,
+				     struct pipe_subresource sr,
+				     unsigned usage,
+				     const struct pipe_box *box);
+
+void u_transfer_destroy_vtbl(struct pipe_context *pipe,
+			struct pipe_transfer *transfer);
+
+void *u_transfer_map_vtbl( struct pipe_context *pipe,
+		      struct pipe_transfer *transfer );
+
+void u_transfer_flush_region_vtbl( struct pipe_context *pipe,
+			      struct pipe_transfer *transfer,
+			      const struct pipe_box *box);
+
+void u_transfer_unmap_vtbl( struct pipe_context *rm_ctx,
+		       struct pipe_transfer *transfer );
+
+void u_transfer_inline_write_vtbl( struct pipe_context *rm_ctx,
+				   struct pipe_resource *resource,
+				   struct pipe_subresource sr,
+				   unsigned usage,
+				   const struct pipe_box *box,
+				   const void *data,
+				   unsigned stride,
+				   unsigned slice_stride);
+
+
+
+
+
+
+
+
+#endif
diff --git a/src/gallium/auxiliary/util/u_upload_mgr.c b/src/gallium/auxiliary/util/u_upload_mgr.c
index 012b2ae2336..75d44432d9e 100644
--- a/src/gallium/auxiliary/util/u_upload_mgr.c
+++ b/src/gallium/auxiliary/util/u_upload_mgr.c
@@ -31,7 +31,7 @@
 
 #include "pipe/p_defines.h"
 #include "util/u_inlines.h"
-#include "pipe/p_screen.h"
+#include "pipe/p_context.h"
 #include "util/u_memory.h"
 #include "util/u_math.h"
 
@@ -39,7 +39,7 @@
 
 
 struct u_upload_mgr {
-   struct pipe_screen *screen;
+   struct pipe_context *pipe;
 
    unsigned default_size;
    unsigned alignment;
@@ -47,21 +47,21 @@ struct u_upload_mgr {
 
    /* The active buffer:
     */
-   struct pipe_buffer *buffer;
+   struct pipe_resource *buffer;
    unsigned size;
    unsigned offset;
 };
 
 
-struct u_upload_mgr *u_upload_create( struct pipe_screen *screen,
+struct u_upload_mgr *u_upload_create( struct pipe_context *pipe,
                                       unsigned default_size,
                                       unsigned alignment,
                                       unsigned usage )
 {
    struct u_upload_mgr *upload = CALLOC_STRUCT( u_upload_mgr );
 
+   upload->pipe = pipe;
    upload->default_size = default_size;
-   upload->screen = screen;
    upload->alignment = alignment;
    upload->usage = usage;
    upload->buffer = NULL;
@@ -69,31 +69,44 @@ struct u_upload_mgr *u_upload_create( struct pipe_screen *screen,
    return upload;
 }
 
-
+/* Slightly specialized version of buffer_write designed to maximize
+ * chances of the driver consolidating successive writes into a single
+ * upload.
+ *
+ * dirty_size may be slightly greater than size to cope with
+ * alignment.  We don't want to leave holes between succesively mapped
+ * regions as that may prevent the driver from consolidating uploads.
+ * 
+ * Note that the 'data' pointer has probably come from the application
+ * and we cannot read even a byte past its end without risking
+ * segfaults, or at least complaints from valgrind..
+ */
 static INLINE enum pipe_error
-my_buffer_write(struct pipe_screen *screen,
-                struct pipe_buffer *buf,
+my_buffer_write(struct pipe_context *pipe,
+                struct pipe_resource *buf,
                 unsigned offset, unsigned size, unsigned dirty_size,
                 const void *data)
 {
+   struct pipe_transfer *transfer = NULL;
    uint8_t *map;
    
-   assert(offset < buf->size);
-   assert(offset + size <= buf->size);
+   assert(offset < buf->width0);
+   assert(offset + size <= buf->width0);
    assert(dirty_size >= size);
    assert(size);
 
-   map = pipe_buffer_map_range(screen, buf, offset, size, 
-                               PIPE_BUFFER_USAGE_CPU_WRITE |
-                               PIPE_BUFFER_USAGE_FLUSH_EXPLICIT |
-                               PIPE_BUFFER_USAGE_DISCARD |
-                               PIPE_BUFFER_USAGE_UNSYNCHRONIZED);
+   map = pipe_buffer_map_range(pipe, buf, offset, dirty_size,
+                               PIPE_TRANSFER_WRITE |
+                               PIPE_TRANSFER_FLUSH_EXPLICIT |
+                               PIPE_TRANSFER_DISCARD |
+                               PIPE_TRANSFER_UNSYNCHRONIZED,
+			       &transfer);
    if (map == NULL) 
       return PIPE_ERROR_OUT_OF_MEMORY;
 
    memcpy(map + offset, data, size);
-   pipe_buffer_flush_mapped_range(screen, buf, offset, dirty_size);
-   pipe_buffer_unmap(screen, buf);
+   pipe_buffer_flush_mapped_range(pipe, transfer, offset, dirty_size);
+   pipe_buffer_unmap(pipe, buf, transfer);
 
    return PIPE_OK;
 }
@@ -109,7 +122,7 @@ my_buffer_write(struct pipe_screen *screen,
  */
 void u_upload_flush( struct u_upload_mgr *upload )
 {
-   pipe_buffer_reference( &upload->buffer, NULL );
+   pipe_resource_reference( &upload->buffer, NULL );
    upload->size = 0;
 }
 
@@ -135,9 +148,8 @@ u_upload_alloc_buffer( struct u_upload_mgr *upload,
     */
    size = align(MAX2(upload->default_size, min_size), 4096);
 
-   upload->buffer = pipe_buffer_create( upload->screen,
-                                        upload->alignment,
-                                        upload->usage | PIPE_BUFFER_USAGE_CPU_WRITE,
+   upload->buffer = pipe_buffer_create( upload->pipe->screen,
+                                        upload->usage,
                                         size );
    if (upload->buffer == NULL) 
       goto fail;
@@ -149,7 +161,7 @@ u_upload_alloc_buffer( struct u_upload_mgr *upload,
 
 fail:
    if (upload->buffer)
-      pipe_buffer_reference( &upload->buffer, NULL );
+      pipe_resource_reference( &upload->buffer, NULL );
 
    return PIPE_ERROR_OUT_OF_MEMORY;
 }
@@ -159,7 +171,7 @@ enum pipe_error u_upload_data( struct u_upload_mgr *upload,
                                unsigned size,
                                const void *data,
                                unsigned *out_offset,
-                               struct pipe_buffer **outbuf )
+                               struct pipe_resource **outbuf )
 {
    unsigned alloc_size = align( size, upload->alignment );
    enum pipe_error ret = PIPE_OK;
@@ -172,7 +184,7 @@ enum pipe_error u_upload_data( struct u_upload_mgr *upload,
 
    /* Copy the data, using map_range if available:
     */
-   ret = my_buffer_write( upload->screen, 
+   ret = my_buffer_write( upload->pipe, 
                           upload->buffer,
                           upload->offset,
                           size, 
@@ -183,7 +195,7 @@ enum pipe_error u_upload_data( struct u_upload_mgr *upload,
 
    /* Emit the return values:
     */
-   pipe_buffer_reference( outbuf, upload->buffer );
+   pipe_resource_reference( outbuf, upload->buffer );
    *out_offset = upload->offset;
    upload->offset += alloc_size;
    return PIPE_OK;
@@ -198,15 +210,18 @@ enum pipe_error u_upload_data( struct u_upload_mgr *upload,
 enum pipe_error u_upload_buffer( struct u_upload_mgr *upload,
                                  unsigned offset,
                                  unsigned size,
-                                 struct pipe_buffer *inbuf,
+                                 struct pipe_resource *inbuf,
                                  unsigned *out_offset,
-                                 struct pipe_buffer **outbuf )
+                                 struct pipe_resource **outbuf )
 {
    enum pipe_error ret = PIPE_OK;
+   struct pipe_transfer *transfer = NULL;
    const char *map = NULL;
 
-   map = (const char *)pipe_buffer_map( 
-      upload->screen, inbuf, PIPE_BUFFER_USAGE_CPU_READ );
+   map = (const char *)pipe_buffer_map(upload->pipe,
+				       inbuf,
+				       PIPE_TRANSFER_READ,
+				       &transfer);
 
    if (map == NULL) {
       ret = PIPE_ERROR_OUT_OF_MEMORY;
@@ -226,7 +241,7 @@ enum pipe_error u_upload_buffer( struct u_upload_mgr *upload,
 
 done:
    if (map)
-      pipe_buffer_unmap( upload->screen, inbuf );
+      pipe_buffer_unmap( upload->pipe, inbuf, transfer );
 
    return ret;
 }
diff --git a/src/gallium/auxiliary/util/u_upload_mgr.h b/src/gallium/auxiliary/util/u_upload_mgr.h
index e158bed9d04..a124924fc80 100644
--- a/src/gallium/auxiliary/util/u_upload_mgr.h
+++ b/src/gallium/auxiliary/util/u_upload_mgr.h
@@ -35,11 +35,11 @@
 #include "pipe/p_defines.h"
 
 struct pipe_screen;
-struct pipe_buffer;
+struct pipe_resource;
 struct u_upload_mgr;
 
 
-struct u_upload_mgr *u_upload_create( struct pipe_screen *screen,
+struct u_upload_mgr *u_upload_create( struct pipe_context *pipe,
                                       unsigned default_size,
                                       unsigned alignment,
                                       unsigned usage );
@@ -61,15 +61,15 @@ enum pipe_error u_upload_data( struct u_upload_mgr *upload,
                                unsigned size,
                                const void *data,
                                unsigned *out_offset,
-                               struct pipe_buffer **outbuf );
+                               struct pipe_resource **outbuf );
 
 
 enum pipe_error u_upload_buffer( struct u_upload_mgr *upload,
                                  unsigned offset,
                                  unsigned size,
-                                 struct pipe_buffer *inbuf,
+                                 struct pipe_resource *inbuf,
                                  unsigned *out_offset,
-                                 struct pipe_buffer **outbuf );
+                                 struct pipe_resource **outbuf );
 
 
 
diff --git a/src/gallium/auxiliary/vl/vl_bitstream_parser.c b/src/gallium/auxiliary/vl/vl_bitstream_parser.c
deleted file mode 100644
index 3193ea5f41c..00000000000
--- a/src/gallium/auxiliary/vl/vl_bitstream_parser.c
+++ /dev/null
@@ -1,167 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include "vl_bitstream_parser.h"
-#include <assert.h>
-#include <limits.h>
-#include <util/u_memory.h>
-
-static unsigned
-grab_bits(unsigned cursor, unsigned how_many_bits, unsigned bitstream_elt)
-{
-   unsigned excess_bits = sizeof(unsigned) * CHAR_BIT - how_many_bits - cursor;
-	
-   assert(cursor < sizeof(unsigned) * CHAR_BIT);
-   assert(how_many_bits > 0 && how_many_bits <= sizeof(unsigned) * CHAR_BIT);
-   assert(cursor + how_many_bits <= sizeof(unsigned) * CHAR_BIT);
-
-   return (bitstream_elt << excess_bits) >> (excess_bits + cursor);
-}
-
-static unsigned
-show_bits(unsigned cursor, unsigned how_many_bits, const unsigned *bitstream)
-{	
-   unsigned cur_int = cursor / (sizeof(unsigned) * CHAR_BIT);
-   unsigned cur_bit = cursor % (sizeof(unsigned) * CHAR_BIT);
-	
-   assert(bitstream);
-	
-   if (cur_bit + how_many_bits > sizeof(unsigned) * CHAR_BIT) {
-      unsigned lower = grab_bits(cur_bit, sizeof(unsigned) * CHAR_BIT - cur_bit,
-                                 bitstream[cur_int]);
-      unsigned upper = grab_bits(0, cur_bit + how_many_bits - sizeof(unsigned) * CHAR_BIT,
-                                 bitstream[cur_int + 1]);
-      return lower | upper << (sizeof(unsigned) * CHAR_BIT - cur_bit);
-   }
-   else
-      return grab_bits(cur_bit, how_many_bits, bitstream[cur_int]);
-}
-
-bool vl_bitstream_parser_init(struct vl_bitstream_parser *parser,
-                              unsigned num_bitstreams,
-                              const void **bitstreams,
-                              const unsigned *sizes)
-{
-   assert(parser);
-   assert(num_bitstreams);
-   assert(bitstreams);
-   assert(sizes);
-
-   parser->num_bitstreams = num_bitstreams;
-   parser->bitstreams = (const unsigned**)bitstreams;
-   parser->sizes = sizes;
-   parser->cur_bitstream = 0;
-   parser->cursor = 0;
-
-   return true;
-}
-
-void vl_bitstream_parser_cleanup(struct vl_bitstream_parser *parser)
-{
-   assert(parser);
-}
-
-unsigned
-vl_bitstream_parser_get_bits(struct vl_bitstream_parser *parser,
-                             unsigned how_many_bits)
-{
-   unsigned bits;
-
-   assert(parser);
-
-   bits = vl_bitstream_parser_show_bits(parser, how_many_bits);
-
-   vl_bitstream_parser_forward(parser, how_many_bits);
-
-   return bits;
-}
-
-unsigned
-vl_bitstream_parser_show_bits(struct vl_bitstream_parser *parser,
-                              unsigned how_many_bits)
-{	
-   unsigned bits = 0;
-   unsigned shift = 0;
-   unsigned cursor;
-   unsigned cur_bitstream;
-
-   assert(parser);
-
-   cursor = parser->cursor;
-   cur_bitstream = parser->cur_bitstream;
-
-   while (1) {
-      unsigned bits_left = parser->sizes[cur_bitstream] * CHAR_BIT - cursor;
-      unsigned bits_to_show = how_many_bits > bits_left ? bits_left : how_many_bits;
-
-      bits |= show_bits(cursor, bits_to_show,
-                        parser->bitstreams[cur_bitstream]) << shift;
-		
-      if (how_many_bits > bits_to_show) {
-         how_many_bits -= bits_to_show;
-         cursor = 0;
-         ++cur_bitstream;
-         shift += bits_to_show;
-      }
-      else
-         break;
-   }
-
-   return bits;
-}
-
-void vl_bitstream_parser_forward(struct vl_bitstream_parser *parser,
-                                 unsigned how_many_bits)
-{
-   assert(parser);
-   assert(how_many_bits);
-
-   parser->cursor += how_many_bits;
-
-   while (parser->cursor > parser->sizes[parser->cur_bitstream] * CHAR_BIT) {
-      parser->cursor -= parser->sizes[parser->cur_bitstream++] * CHAR_BIT;
-      assert(parser->cur_bitstream < parser->num_bitstreams);
-   }
-}
-
-void vl_bitstream_parser_rewind(struct vl_bitstream_parser *parser,
-                                unsigned how_many_bits)
-{
-   signed c;
-	
-   assert(parser);
-   assert(how_many_bits);
-	
-   c = parser->cursor - how_many_bits;
-
-   while (c < 0) {
-      c += parser->sizes[parser->cur_bitstream--] * CHAR_BIT;
-      assert(parser->cur_bitstream < parser->num_bitstreams);
-   }
-
-   parser->cursor = (unsigned)c;
-}
diff --git a/src/gallium/auxiliary/vl/vl_bitstream_parser.h b/src/gallium/auxiliary/vl/vl_bitstream_parser.h
deleted file mode 100644
index 30ec743fa75..00000000000
--- a/src/gallium/auxiliary/vl/vl_bitstream_parser.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 vl_bitstream_parser_h
-#define vl_bitstream_parser_h
-
-#include "pipe/p_compiler.h"
-
-struct vl_bitstream_parser
-{
-   unsigned num_bitstreams;
-   const unsigned **bitstreams;
-   const unsigned *sizes;
-   unsigned cur_bitstream;
-   unsigned cursor;
-};
-
-bool vl_bitstream_parser_init(struct vl_bitstream_parser *parser,
-                              unsigned num_bitstreams,
-                              const void **bitstreams,
-                              const unsigned *sizes);
-
-void vl_bitstream_parser_cleanup(struct vl_bitstream_parser *parser);
-
-unsigned
-vl_bitstream_parser_get_bits(struct vl_bitstream_parser *parser,
-                             unsigned how_many_bits);
-
-unsigned
-vl_bitstream_parser_show_bits(struct vl_bitstream_parser *parser,
-                              unsigned how_many_bits);
-
-void vl_bitstream_parser_forward(struct vl_bitstream_parser *parser,
-                                 unsigned how_many_bits);
-
-void vl_bitstream_parser_rewind(struct vl_bitstream_parser *parser,
-                                unsigned how_many_bits);
-
-#endif /* vl_bitstream_parser_h */
diff --git a/src/gallium/auxiliary/vl/vl_compositor.c b/src/gallium/auxiliary/vl/vl_compositor.c
deleted file mode 100644
index 6d461cb8800..00000000000
--- a/src/gallium/auxiliary/vl/vl_compositor.c
+++ /dev/null
@@ -1,536 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include "vl_compositor.h"
-#include <assert.h>
-#include <pipe/p_context.h>
-#include <util/u_inlines.h>
-#include <tgsi/tgsi_parse.h>
-#include <tgsi/tgsi_build.h>
-#include <util/u_memory.h>
-#include "vl_csc.h"
-#include "vl_shader_build.h"
-
-struct vertex2f
-{
-   float x, y;
-};
-
-struct vertex4f
-{
-   float x, y, z, w;
-};
-
-struct vertex_shader_consts
-{
-   struct vertex4f dst_scale;
-   struct vertex4f dst_trans;
-   struct vertex4f src_scale;
-   struct vertex4f src_trans;
-};
-
-struct fragment_shader_consts
-{
-   float matrix[16];
-};
-
-/*
- * Represents 2 triangles in a strip in normalized coords.
- * Used to render the surface onto the frame buffer.
- */
-static const struct vertex2f surface_verts[4] =
-{
-   {0.0f, 0.0f},
-   {0.0f, 1.0f},
-   {1.0f, 0.0f},
-   {1.0f, 1.0f}
-};
-
-/*
- * Represents texcoords for the above. We can use the position values directly.
- * TODO: Duplicate these in the shader, no need to create a buffer.
- */
-static const struct vertex2f *surface_texcoords = surface_verts;
-
-static void
-create_vert_shader(struct vl_compositor *c)
-{
-   const unsigned max_tokens = 50;
-
-   struct pipe_shader_state vs;
-   struct tgsi_token *tokens;
-   struct tgsi_header *header;
-
-   struct tgsi_full_declaration decl;
-   struct tgsi_full_instruction inst;
-
-   unsigned ti;
-
-   unsigned i;
-
-   assert(c);
-
-   tokens = (struct tgsi_token*)MALLOC(max_tokens * sizeof(struct tgsi_token));
-   header = (struct tgsi_header*)&tokens[0];
-   *header = tgsi_build_header();
-   *(struct tgsi_processor*)&tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
-
-   ti = 2;
-
-   /*
-    * decl i0             ; Vertex pos
-    * decl i1             ; Vertex texcoords
-    */
-   for (i = 0; i < 2; i++) {
-      decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * decl c0             ; Scaling vector to scale vertex pos rect to destination size
-    * decl c1             ; Translation vector to move vertex pos rect into position
-    * decl c2             ; Scaling vector to scale texcoord rect to source size
-    * decl c3             ; Translation vector to move texcoord rect into position
-    */
-   decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 3);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /*
-    * decl o0             ; Vertex pos
-    * decl o1             ; Vertex texcoords
-    */
-   for (i = 0; i < 2; i++) {
-      decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* decl t0, t1 */
-   decl = vl_decl_temps(0, 1);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /*
-    * mad o0, i0, c0, c1  ; Scale and translate unit output rect to destination size and pos
-    * mad o1, i1, c2, c3  ; Scale and translate unit texcoord rect to source size and pos
-    */
-   for (i = 0; i < 2; ++i) {
-      inst = vl_inst4(TGSI_OPCODE_MAD, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i, TGSI_FILE_CONSTANT, i * 2, TGSI_FILE_CONSTANT, i * 2 + 1);
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* end */
-   inst = vl_end();
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   assert(ti <= max_tokens);
-
-   vs.tokens = tokens;
-   c->vertex_shader = c->pipe->create_vs_state(c->pipe, &vs);
-   FREE(tokens);
-}
-
-static void
-create_frag_shader(struct vl_compositor *c)
-{
-   const unsigned max_tokens = 50;
-
-   struct pipe_shader_state fs;
-   struct tgsi_token *tokens;
-   struct tgsi_header *header;
-
-   struct tgsi_full_declaration decl;
-   struct tgsi_full_instruction inst;
-
-   unsigned ti;
-
-   unsigned i;
-
-   assert(c);
-
-   tokens = (struct tgsi_token*)MALLOC(max_tokens * sizeof(struct tgsi_token));
-   header = (struct tgsi_header*)&tokens[0];
-   *header = tgsi_build_header();
-   *(struct tgsi_processor*)&tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
-
-   ti = 2;
-
-   /* decl i0             ; Texcoords for s0 */
-   decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, 1, 0, 0, TGSI_INTERPOLATE_LINEAR);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /*
-    * decl c0-c3          ; CSC matrix c0-c3
-    */
-   decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 3);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* decl o0             ; Fragment color */
-   decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* decl t0 */
-   decl = vl_decl_temps(0, 0);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* decl s0             ; Sampler for tex containing picture to display */
-   decl = vl_decl_samplers(0, 0);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* tex2d t0, i0, s0    ; Read src pixel */
-   inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_INPUT, 0, TGSI_FILE_SAMPLER, 0);
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   /*
-    * dp4 o0.x, t0, c0    ; Multiply pixel by the color conversion matrix
-    * dp4 o0.y, t0, c1
-    * dp4 o0.z, t0, c2
-    * dp4 o0.w, t0, c3
-    */
-   for (i = 0; i < 4; ++i) {
-      inst = vl_inst3(TGSI_OPCODE_DP4, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, i);
-      inst.Dst[0].Register.WriteMask = TGSI_WRITEMASK_X << i;
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* end */
-   inst = vl_end();
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-	
-   assert(ti <= max_tokens);
-
-   fs.tokens = tokens;
-   c->fragment_shader = c->pipe->create_fs_state(c->pipe, &fs);
-   FREE(tokens);
-}
-
-static bool
-init_pipe_state(struct vl_compositor *c)
-{
-   struct pipe_sampler_state sampler;
-   struct pipe_vertex_element vertex_elems[2];
-
-   assert(c);
-
-   c->fb_state.nr_cbufs = 1;
-   c->fb_state.zsbuf = NULL;
-
-   sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-   sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
-   sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-   sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
-   sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
-   sampler.compare_func = PIPE_FUNC_ALWAYS;
-   sampler.normalized_coords = 1;
-   /*sampler.lod_bias = ;*/
-   /*sampler.min_lod = ;*/
-   /*sampler.max_lod = ;*/
-   /*sampler.border_color[i] = ;*/
-   /*sampler.max_anisotropy = ;*/
-   c->sampler = c->pipe->create_sampler_state(c->pipe, &sampler);
-
-   vertex_elems[0].src_offset = 0;
-   vertex_elems[0].instance_divisor = 0;
-   vertex_elems[0].vertex_buffer_index = 0;
-   vertex_elems[0].src_format = PIPE_FORMAT_R32G32_FLOAT;
-   vertex_elems[1].src_offset = 0;
-   vertex_elems[1].instance_divisor = 0;
-   vertex_elems[1].vertex_buffer_index = 1;
-   vertex_elems[1].src_format = PIPE_FORMAT_R32G32_FLOAT;
-   c->vertex_elems = c->pipe->create_vertex_elements_state(c->pipe, 2, vertex_elems);
-
-
-   return true;
-}
-
-static void cleanup_pipe_state(struct vl_compositor *c)
-{
-   assert(c);
-
-   c->pipe->delete_sampler_state(c->pipe, c->sampler);
-   c->pipe->delete_vertex_elements_state(c->pipe, c->vertex_elems);
-}
-
-static bool
-init_shaders(struct vl_compositor *c)
-{
-   assert(c);
-
-   create_vert_shader(c);
-   create_frag_shader(c);
-
-   return true;
-}
-
-static void cleanup_shaders(struct vl_compositor *c)
-{
-   assert(c);
-	
-   c->pipe->delete_vs_state(c->pipe, c->vertex_shader);
-   c->pipe->delete_fs_state(c->pipe, c->fragment_shader);
-}
-
-static bool
-init_buffers(struct vl_compositor *c)
-{
-   struct fragment_shader_consts fsc;
-
-   assert(c);
-	
-   /*
-    * Create our vertex buffer and vertex buffer element
-    * VB contains 4 vertices that render a quad covering the entire window
-    * to display a rendered surface
-    * Quad is rendered as a tri strip
-    */
-   c->vertex_bufs[0].stride = sizeof(struct vertex2f);
-   c->vertex_bufs[0].max_index = 3;
-   c->vertex_bufs[0].buffer_offset = 0;
-   c->vertex_bufs[0].buffer = pipe_buffer_create
-   (
-      c->pipe->screen,
-      1,
-      PIPE_BUFFER_USAGE_VERTEX,
-      sizeof(struct vertex2f) * 4
-   );
-
-   memcpy
-   (
-      pipe_buffer_map(c->pipe->screen, c->vertex_bufs[0].buffer, PIPE_BUFFER_USAGE_CPU_WRITE),
-      surface_verts,
-      sizeof(struct vertex2f) * 4
-   );
-
-   pipe_buffer_unmap(c->pipe->screen, c->vertex_bufs[0].buffer);
-
-   /*
-    * Create our texcoord buffer and texcoord buffer element
-    * Texcoord buffer contains the TCs for mapping the rendered surface to the 4 vertices
-    */
-   c->vertex_bufs[1].stride = sizeof(struct vertex2f);
-   c->vertex_bufs[1].max_index = 3;
-   c->vertex_bufs[1].buffer_offset = 0;
-   c->vertex_bufs[1].buffer = pipe_buffer_create
-   (
-      c->pipe->screen,
-      1,
-      PIPE_BUFFER_USAGE_VERTEX,
-      sizeof(struct vertex2f) * 4
-   );
-
-   memcpy
-   (
-      pipe_buffer_map(c->pipe->screen, c->vertex_bufs[1].buffer, PIPE_BUFFER_USAGE_CPU_WRITE),
-      surface_texcoords,
-      sizeof(struct vertex2f) * 4
-   );
-
-   pipe_buffer_unmap(c->pipe->screen, c->vertex_bufs[1].buffer);
-
-   /*
-    * Create our vertex shader's constant buffer
-    * Const buffer contains scaling and translation vectors
-    */
-   c->vs_const_buf = pipe_buffer_create
-   (
-      c->pipe->screen,
-      1,
-      PIPE_BUFFER_USAGE_CONSTANT | PIPE_BUFFER_USAGE_DISCARD,
-      sizeof(struct vertex_shader_consts)
-   );
-
-   /*
-    * Create our fragment shader's constant buffer
-    * Const buffer contains the color conversion matrix and bias vectors
-    */
-   c->fs_const_buf = pipe_buffer_create
-   (
-      c->pipe->screen,
-      1,
-      PIPE_BUFFER_USAGE_CONSTANT,
-      sizeof(struct fragment_shader_consts)
-   );
-
-   vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, fsc.matrix);
-
-   vl_compositor_set_csc_matrix(c, fsc.matrix);
-
-   return true;
-}
-
-static void
-cleanup_buffers(struct vl_compositor *c)
-{
-   unsigned i;
-
-   assert(c);
-	
-   for (i = 0; i < 2; ++i)
-      pipe_buffer_reference(&c->vertex_bufs[i].buffer, NULL);
-
-   pipe_buffer_reference(&c->vs_const_buf, NULL);
-   pipe_buffer_reference(&c->fs_const_buf, NULL);
-}
-
-bool vl_compositor_init(struct vl_compositor *compositor, struct pipe_context *pipe)
-{
-   assert(compositor);
-
-   memset(compositor, 0, sizeof(struct vl_compositor));
-
-   compositor->pipe = pipe;
-
-   if (!init_pipe_state(compositor))
-      return false;
-   if (!init_shaders(compositor)) {
-      cleanup_pipe_state(compositor);
-      return false;
-   }
-   if (!init_buffers(compositor)) {
-      cleanup_shaders(compositor);
-      cleanup_pipe_state(compositor);
-      return false;
-   }
-
-   return true;
-}
-
-void vl_compositor_cleanup(struct vl_compositor *compositor)
-{
-   assert(compositor);
-	
-   cleanup_buffers(compositor);
-   cleanup_shaders(compositor);
-   cleanup_pipe_state(compositor);
-}
-
-void vl_compositor_render(struct vl_compositor          *compositor,
-                          /*struct pipe_texture         *backround,
-                          struct pipe_video_rect        *backround_area,*/
-                          struct pipe_texture           *src_surface,
-                          enum pipe_mpeg12_picture_type picture_type,
-                          /*unsigned                    num_past_surfaces,
-                          struct pipe_texture           *past_surfaces,
-                          unsigned                      num_future_surfaces,
-                          struct pipe_texture           *future_surfaces,*/
-                          struct pipe_video_rect        *src_area,
-                          struct pipe_texture           *dst_surface,
-                          struct pipe_video_rect        *dst_area,
-                          /*unsigned                      num_layers,
-                          struct pipe_texture           *layers,
-                          struct pipe_video_rect        *layer_src_areas,
-                          struct pipe_video_rect        *layer_dst_areas*/
-                          struct pipe_fence_handle      **fence)
-{
-   struct vertex_shader_consts *vs_consts;
-
-   assert(compositor);
-   assert(src_surface);
-   assert(src_area);
-   assert(dst_surface);
-   assert(dst_area);
-   assert(picture_type == PIPE_MPEG12_PICTURE_TYPE_FRAME);
-
-   compositor->fb_state.width = dst_surface->width0;
-   compositor->fb_state.height = dst_surface->height0;
-   compositor->fb_state.cbufs[0] = compositor->pipe->screen->get_tex_surface
-   (
-      compositor->pipe->screen,
-      dst_surface,
-      0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE
-   );
-
-   compositor->viewport.scale[0] = compositor->fb_state.width;
-   compositor->viewport.scale[1] = compositor->fb_state.height;
-   compositor->viewport.scale[2] = 1;
-   compositor->viewport.scale[3] = 1;
-   compositor->viewport.translate[0] = 0;
-   compositor->viewport.translate[1] = 0;
-   compositor->viewport.translate[2] = 0;
-   compositor->viewport.translate[3] = 0;
-
-   compositor->scissor.maxx = compositor->fb_state.width;
-   compositor->scissor.maxy = compositor->fb_state.height;
-
-   compositor->pipe->set_framebuffer_state(compositor->pipe, &compositor->fb_state);
-   compositor->pipe->set_viewport_state(compositor->pipe, &compositor->viewport);
-   compositor->pipe->set_scissor_state(compositor->pipe, &compositor->scissor);
-   compositor->pipe->bind_fragment_sampler_states(compositor->pipe, 1, &compositor->sampler);
-   compositor->pipe->set_fragment_sampler_textures(compositor->pipe, 1, &src_surface);
-   compositor->pipe->bind_vs_state(compositor->pipe, compositor->vertex_shader);
-   compositor->pipe->bind_fs_state(compositor->pipe, compositor->fragment_shader);
-   compositor->pipe->set_vertex_buffers(compositor->pipe, 2, compositor->vertex_bufs);
-   compositor->pipe->bind_vertex_elements_state(compositor->pipe, compositor->vertex_elems);
-   compositor->pipe->set_constant_buffer(compositor->pipe, PIPE_SHADER_VERTEX, 0, compositor->vs_const_buf);
-   compositor->pipe->set_constant_buffer(compositor->pipe, PIPE_SHADER_FRAGMENT, 0, compositor->fs_const_buf);
-
-   vs_consts = pipe_buffer_map
-   (
-      compositor->pipe->screen,
-      compositor->vs_const_buf,
-      PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_DISCARD
-   );
-
-   vs_consts->dst_scale.x = dst_area->w / (float)compositor->fb_state.cbufs[0]->width;
-   vs_consts->dst_scale.y = dst_area->h / (float)compositor->fb_state.cbufs[0]->height;
-   vs_consts->dst_scale.z = 1;
-   vs_consts->dst_scale.w = 1;
-   vs_consts->dst_trans.x = dst_area->x / (float)compositor->fb_state.cbufs[0]->width;
-   vs_consts->dst_trans.y = dst_area->y / (float)compositor->fb_state.cbufs[0]->height;
-   vs_consts->dst_trans.z = 0;
-   vs_consts->dst_trans.w = 0;
-
-   vs_consts->src_scale.x = src_area->w / (float)src_surface->width0;
-   vs_consts->src_scale.y = src_area->h / (float)src_surface->height0;
-   vs_consts->src_scale.z = 1;
-   vs_consts->src_scale.w = 1;
-   vs_consts->src_trans.x = src_area->x / (float)src_surface->width0;
-   vs_consts->src_trans.y = src_area->y / (float)src_surface->height0;
-   vs_consts->src_trans.z = 0;
-   vs_consts->src_trans.w = 0;
-
-   pipe_buffer_unmap(compositor->pipe->screen, compositor->vs_const_buf);
-
-   compositor->pipe->draw_arrays(compositor->pipe, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
-   compositor->pipe->flush(compositor->pipe, PIPE_FLUSH_RENDER_CACHE, fence);
-
-   pipe_surface_reference(&compositor->fb_state.cbufs[0], NULL);
-}
-
-void vl_compositor_set_csc_matrix(struct vl_compositor *compositor, const float *mat)
-{
-   assert(compositor);
-
-   memcpy
-   (
-      pipe_buffer_map(compositor->pipe->screen, compositor->fs_const_buf, PIPE_BUFFER_USAGE_CPU_WRITE),
-      mat,
-      sizeof(struct fragment_shader_consts)
-   );
-
-   pipe_buffer_unmap(compositor->pipe->screen, compositor->fs_const_buf);
-}
diff --git a/src/gallium/auxiliary/vl/vl_compositor.h b/src/gallium/auxiliary/vl/vl_compositor.h
deleted file mode 100644
index 51755554da1..00000000000
--- a/src/gallium/auxiliary/vl/vl_compositor.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 vl_compositor_h
-#define vl_compositor_h
-
-#include <pipe/p_compiler.h>
-#include <pipe/p_state.h>
-#include <pipe/p_video_state.h>
-
-struct pipe_context;
-struct pipe_texture;
-
-struct vl_compositor
-{
-   struct pipe_context *pipe;
-
-   struct pipe_framebuffer_state fb_state;
-   void *sampler;
-   void *vertex_shader;
-   void *fragment_shader;
-   void *vertex_elems;
-   struct pipe_viewport_state viewport;
-   struct pipe_scissor_state scissor;
-   struct pipe_vertex_buffer vertex_bufs[2];
-   struct pipe_buffer *vs_const_buf, *fs_const_buf;
-};
-
-bool vl_compositor_init(struct vl_compositor *compositor, struct pipe_context *pipe);
-
-void vl_compositor_cleanup(struct vl_compositor *compositor);
-
-void vl_compositor_render(struct vl_compositor          *compositor,
-                          /*struct pipe_texture         *backround,
-                          struct pipe_video_rect        *backround_area,*/
-                          struct pipe_texture           *src_surface,
-                          enum pipe_mpeg12_picture_type picture_type,
-                          /*unsigned                    num_past_surfaces,
-                          struct pipe_texture           *past_surfaces,
-                          unsigned                      num_future_surfaces,
-                          struct pipe_texture           *future_surfaces,*/
-                          struct pipe_video_rect        *src_area,
-                          struct pipe_texture           *dst_surface,
-                          struct pipe_video_rect        *dst_area,
-                          /*unsigned                      num_layers,
-                          struct pipe_texture           *layers,
-                          struct pipe_video_rect        *layer_src_areas,
-                          struct pipe_video_rect        *layer_dst_areas,*/
-                          struct pipe_fence_handle      **fence);
-
-void vl_compositor_set_csc_matrix(struct vl_compositor *compositor, const float *mat);
-
-#endif /* vl_compositor_h */
diff --git a/src/gallium/auxiliary/vl/vl_csc.c b/src/gallium/auxiliary/vl/vl_csc.c
deleted file mode 100644
index 5ecc43a5fa3..00000000000
--- a/src/gallium/auxiliary/vl/vl_csc.c
+++ /dev/null
@@ -1,206 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include "vl_csc.h"
-#include <util/u_math.h>
-#include <util/u_debug.h>
-
-/*
- * Color space conversion formulas
- *
- * To convert YCbCr to RGB,
- *    vec4  ycbcr, rgb
- *    mat44 csc
- *    rgb = csc * ycbcr
- *
- * To calculate the color space conversion matrix csc with ProcAmp adjustments,
- *    mat44 csc, cstd, procamp, bias
- *    csc = cstd * (procamp * bias)
- *
- * Where cstd is a matrix corresponding to one of the color standards (BT.601, BT.709, etc)
- * adjusted for the kind of YCbCr -> RGB mapping wanted (1:1, full),
- * bias is a matrix corresponding to the kind of YCbCr -> RGB mapping wanted (1:1, full)
- *
- * To calculate procamp,
- *    mat44 procamp, hue, saturation, brightness, contrast
- *    procamp = brightness * (saturation * (contrast * hue))
- * Alternatively,
- *    procamp = saturation * (brightness * (contrast * hue))
- *
- * contrast
- * [ c, 0, 0, 0]
- * [ 0, c, 0, 0]
- * [ 0, 0, c, 0]
- * [ 0, 0, 0, 1]
- *
- * brightness
- * [ 1, 0, 0, b]
- * [ 0, 1, 0, 0]
- * [ 0, 0, 1, 0]
- * [ 0, 0, 0, 1]
- *
- * saturation
- * [ 1, 0, 0, 0]
- * [ 0, s, 0, 0]
- * [ 0, 0, s, 0]
- * [ 0, 0, 0, 1]
- *
- * hue
- * [ 1,       0,      0, 0]
- * [ 0,  cos(h), sin(h), 0]
- * [ 0, -sin(h), cos(h), 0]
- * [ 0,       0,      0, 1]
- *
- * procamp
- * [ c,           0,          0, b]
- * [ 0,  c*s*cos(h), c*s*sin(h), 0]
- * [ 0, -c*s*sin(h), c*s*cos(h), 0]
- * [ 0,           0,          0, 1]
- *
- * bias
- * [ 1, 0, 0,  ybias]
- * [ 0, 1, 0, cbbias]
- * [ 0, 0, 1, crbias]
- * [ 0, 0, 0,      1]
- *
- * csc
- * [ c*cstd[ 0], c*cstd[ 1]*s*cos(h) - c*cstd[ 2]*s*sin(h), c*cstd[ 2]*s*cos(h) + c*cstd[ 1]*s*sin(h), cstd[ 3] + cstd[ 0]*(b + c*ybias) + cstd[ 1]*(c*cbbias*s*cos(h) + c*crbias*s*sin(h)) + cstd[ 2]*(c*crbias*s*cos(h) - c*cbbias*s*sin(h))]
- * [ c*cstd[ 4], c*cstd[ 5]*s*cos(h) - c*cstd[ 6]*s*sin(h), c*cstd[ 6]*s*cos(h) + c*cstd[ 5]*s*sin(h), cstd[ 7] + cstd[ 4]*(b + c*ybias) + cstd[ 5]*(c*cbbias*s*cos(h) + c*crbias*s*sin(h)) + cstd[ 6]*(c*crbias*s*cos(h) - c*cbbias*s*sin(h))]
- * [ c*cstd[ 8], c*cstd[ 9]*s*cos(h) - c*cstd[10]*s*sin(h), c*cstd[10]*s*cos(h) + c*cstd[ 9]*s*sin(h), cstd[11] + cstd[ 8]*(b + c*ybias) + cstd[ 9]*(c*cbbias*s*cos(h) + c*crbias*s*sin(h)) + cstd[10]*(c*crbias*s*cos(h) - c*cbbias*s*sin(h))]
- * [ c*cstd[12], c*cstd[13]*s*cos(h) - c*cstd[14]*s*sin(h), c*cstd[14]*s*cos(h) + c*cstd[13]*s*sin(h), cstd[15] + cstd[12]*(b + c*ybias) + cstd[13]*(c*cbbias*s*cos(h) + c*crbias*s*sin(h)) + cstd[14]*(c*crbias*s*cos(h) - c*cbbias*s*sin(h))]
- */
-
-/*
- * Converts ITU-R BT.601 YCbCr pixels to RGB pixels where:
- * Y is in [16,235], Cb and Cr are in [16,240]
- * R, G, and B are in [16,235]
- */
-static const float bt_601[16] =
-{
-   1.0f,  0.0f,    1.371f, 0.0f,
-   1.0f, -0.336f, -0.698f, 0.0f,
-   1.0f,  1.732f,  0.0f,   0.0f,
-   0.0f,  0.0f,    0.0f,   1.0f
-};
-
-/*
- * Converts ITU-R BT.601 YCbCr pixels to RGB pixels where:
- * Y is in [16,235], Cb and Cr are in [16,240]
- * R, G, and B are in [0,255]
- */
-static const float bt_601_full[16] =
-{
-   1.164f,  0.0f,    1.596f, 0.0f,
-   1.164f, -0.391f, -0.813f, 0.0f,
-   1.164f,  2.018f,  0.0f,   0.0f,
-   0.0f,    0.0f,    0.0f,   1.0f
-};
-
-/*
- * Converts ITU-R BT.709 YCbCr pixels to RGB pixels where:
- * Y is in [16,235], Cb and Cr are in [16,240]
- * R, G, and B are in [16,235]
- */
-static const float bt_709[16] =
-{
-   1.0f,  0.0f,    1.540f, 0.0f,
-   1.0f, -0.183f, -0.459f, 0.0f,
-   1.0f,  1.816f,  0.0f,   0.0f,
-   0.0f,  0.0f,    0.0f,   1.0f
-};
-
-/*
- * Converts ITU-R BT.709 YCbCr pixels to RGB pixels where:
- * Y is in [16,235], Cb and Cr are in [16,240]
- * R, G, and B are in [0,255]
- */
-static const float bt_709_full[16] =
-{
-   1.164f,  0.0f,    1.793f, 0.0f,
-   1.164f, -0.213f, -0.534f, 0.0f,
-   1.164f,  2.115f,  0.0f,   0.0f,
-   0.0f,    0.0f,    0.0f,   1.0f
-};
-
-static const float identity[16] =
-{
-   1.0f, 0.0f, 0.0f, 0.0f,
-   0.0f, 1.0f, 0.0f, 0.0f,
-   0.0f, 0.0f, 1.0f, 0.0f,
-   0.0f, 0.0f, 0.0f, 1.0f
-};
-
-void vl_csc_get_matrix(enum VL_CSC_COLOR_STANDARD cs,
-                       struct vl_procamp *procamp,
-                       bool full_range,
-                       float *matrix)
-{
-   float ybias = full_range ? -16.0f/255.0f : 0.0f;
-   float cbbias = -128.0f/255.0f;
-   float crbias = -128.0f/255.0f;
-   float c = procamp ? procamp->contrast : 1.0f;
-   float s = procamp ? procamp->saturation : 1.0f;
-   float b = procamp ? procamp->brightness : 0.0f;
-   float h = procamp ? procamp->hue : 0.0f;
-   const float *cstd;
-
-   assert(matrix);
-
-   switch (cs) {
-      case VL_CSC_COLOR_STANDARD_BT_601:
-         cstd = full_range ? &bt_601_full[0] : &bt_601[0];
-         break;
-      case VL_CSC_COLOR_STANDARD_BT_709:
-         cstd = full_range ? &bt_709_full[0] : &bt_709[0];
-         break;
-      case VL_CSC_COLOR_STANDARD_IDENTITY:
-      default:
-         assert(cs == VL_CSC_COLOR_STANDARD_IDENTITY);
-         memcpy(matrix, &identity[0], sizeof(float) * 16);
-         return;
-   }
-
-   matrix[ 0] = c*cstd[ 0];
-   matrix[ 1] = c*cstd[ 1]*s*cosf(h) - c*cstd[ 2]*s*sinf(h);
-   matrix[ 2] = c*cstd[ 2]*s*cosf(h) + c*cstd[ 1]*s*sinf(h);
-   matrix[ 3] = cstd[ 3] + cstd[ 0]*(b + c*ybias) + cstd[ 1]*(c*cbbias*s*cosf(h) + c*crbias*s*sinf(h)) + cstd[ 2]*(c*crbias*s*cosf(h) - c*cbbias*s*sinf(h));
-
-   matrix[ 4] = c*cstd[ 4];
-   matrix[ 5] = c*cstd[ 5]*s*cosf(h) - c*cstd[ 6]*s*sinf(h);
-   matrix[ 6] = c*cstd[ 6]*s*cosf(h) + c*cstd[ 5]*s*sinf(h);
-   matrix[ 7] = cstd[ 7] + cstd[ 4]*(b + c*ybias) + cstd[ 5]*(c*cbbias*s*cosf(h) + c*crbias*s*sinf(h)) + cstd[ 6]*(c*crbias*s*cosf(h) - c*cbbias*s*sinf(h));
-
-   matrix[ 8] = c*cstd[ 8];
-   matrix[ 9] = c*cstd[ 9]*s*cosf(h) - c*cstd[10]*s*sinf(h);
-   matrix[10] = c*cstd[10]*s*cosf(h) + c*cstd[ 9]*s*sinf(h);
-   matrix[11] = cstd[11] + cstd[ 8]*(b + c*ybias) + cstd[ 9]*(c*cbbias*s*cosf(h) + c*crbias*s*sinf(h)) + cstd[10]*(c*crbias*s*cosf(h) - c*cbbias*s*sinf(h));
-
-   matrix[12] = c*cstd[12];
-   matrix[13] = c*cstd[13]*s*cos(h) - c*cstd[14]*s*sin(h);
-   matrix[14] = c*cstd[14]*s*cos(h) + c*cstd[13]*s*sin(h);
-   matrix[15] = cstd[15] + cstd[12]*(b + c*ybias) + cstd[13]*(c*cbbias*s*cos(h) + c*crbias*s*sin(h)) + cstd[14]*(c*crbias*s*cos(h) - c*cbbias*s*sin(h));
-}
diff --git a/src/gallium/auxiliary/vl/vl_csc.h b/src/gallium/auxiliary/vl/vl_csc.h
deleted file mode 100644
index 722ca35f339..00000000000
--- a/src/gallium/auxiliary/vl/vl_csc.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 vl_csc_h
-#define vl_csc_h
-
-#include <pipe/p_compiler.h>
-
-struct vl_procamp
-{
-   float brightness;
-   float contrast;
-   float saturation;
-   float hue;
-};
-
-enum VL_CSC_COLOR_STANDARD
-{
-   VL_CSC_COLOR_STANDARD_IDENTITY,
-   VL_CSC_COLOR_STANDARD_BT_601,
-   VL_CSC_COLOR_STANDARD_BT_709
-};
-
-void vl_csc_get_matrix(enum VL_CSC_COLOR_STANDARD cs,
-                       struct vl_procamp *procamp,
-                       bool full_range,
-                       float *matrix);
-
-#endif /* vl_csc_h */
diff --git a/src/gallium/auxiliary/vl/vl_mpeg12_mc_renderer.c b/src/gallium/auxiliary/vl/vl_mpeg12_mc_renderer.c
deleted file mode 100644
index beb4722901e..00000000000
--- a/src/gallium/auxiliary/vl/vl_mpeg12_mc_renderer.c
+++ /dev/null
@@ -1,1672 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include "vl_mpeg12_mc_renderer.h"
-#include <assert.h>
-#include <pipe/p_context.h>
-#include <util/u_inlines.h>
-#include <util/u_format.h>
-#include <util/u_math.h>
-#include <util/u_memory.h>
-#include <tgsi/tgsi_parse.h>
-#include <tgsi/tgsi_build.h>
-#include "vl_shader_build.h"
-
-#define DEFAULT_BUF_ALIGNMENT 1
-#define MACROBLOCK_WIDTH 16
-#define MACROBLOCK_HEIGHT 16
-#define BLOCK_WIDTH 8
-#define BLOCK_HEIGHT 8
-#define ZERO_BLOCK_NIL -1.0f
-#define ZERO_BLOCK_IS_NIL(zb) ((zb).x < 0.0f)
-
-struct vertex2f
-{
-   float x, y;
-};
-
-struct vertex4f
-{
-   float x, y, z, w;
-};
-
-struct vertex_shader_consts
-{
-   struct vertex4f denorm;
-};
-
-struct fragment_shader_consts
-{
-   struct vertex4f multiplier;
-   struct vertex4f div;
-};
-
-/*
- * Muliplier renormalizes block samples from 16 bits to 12 bits.
- * Divider is used when calculating Y % 2 for choosing top or bottom
- * field for P or B macroblocks.
- * TODO: Use immediates.
- */
-static const struct fragment_shader_consts fs_consts = {
-   {32767.0f / 255.0f, 32767.0f / 255.0f, 32767.0f / 255.0f, 0.0f},
-   {0.5f, 2.0f, 0.0f, 0.0f}
-};
-
-struct vert_stream_0
-{
-   struct vertex2f pos;
-   struct vertex2f luma_tc;
-   struct vertex2f cb_tc;
-   struct vertex2f cr_tc;
-};
-
-enum MACROBLOCK_TYPE
-{
-   MACROBLOCK_TYPE_INTRA,
-   MACROBLOCK_TYPE_FWD_FRAME_PRED,
-   MACROBLOCK_TYPE_FWD_FIELD_PRED,
-   MACROBLOCK_TYPE_BKWD_FRAME_PRED,
-   MACROBLOCK_TYPE_BKWD_FIELD_PRED,
-   MACROBLOCK_TYPE_BI_FRAME_PRED,
-   MACROBLOCK_TYPE_BI_FIELD_PRED,
-
-   NUM_MACROBLOCK_TYPES
-};
-
-static void
-create_intra_vert_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   const unsigned max_tokens = 50;
-
-   struct pipe_shader_state vs;
-   struct tgsi_token *tokens;
-   struct tgsi_header *header;
-
-   struct tgsi_full_declaration decl;
-   struct tgsi_full_instruction inst;
-
-   unsigned ti;
-
-   unsigned i;
-
-   assert(r);
-
-   tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
-   header = (struct tgsi_header *) &tokens[0];
-   *header = tgsi_build_header();
-   *(struct tgsi_processor *) &tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
-
-   ti = 2;
-
-   /*
-    * decl i0              ; Vertex pos
-    * decl i1              ; Luma texcoords
-    * decl i2              ; Chroma Cb texcoords
-    * decl i3              ; Chroma Cr texcoords
-    */
-   for (i = 0; i < 4; i++) {
-      decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * decl o0              ; Vertex pos
-    * decl o1              ; Luma texcoords
-    * decl o2              ; Chroma Cb texcoords
-    * decl o3              ; Chroma Cr texcoords
-    */
-   for (i = 0; i < 4; i++) {
-      decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * mov o0, i0           ; Move input vertex pos to output
-    * mov o1, i1           ; Move input luma texcoords to output
-    * mov o2, i2           ; Move input chroma Cb texcoords to output
-    * mov o3, i3           ; Move input chroma Cr texcoords to output
-    */
-   for (i = 0; i < 4; ++i) {
-      inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* end */
-   inst = vl_end();
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   assert(ti <= max_tokens);
-
-   vs.tokens = tokens;
-   r->i_vs = r->pipe->create_vs_state(r->pipe, &vs);
-   free(tokens);
-}
-
-static void
-create_intra_frag_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   const unsigned max_tokens = 100;
-
-   struct pipe_shader_state fs;
-   struct tgsi_token *tokens;
-   struct tgsi_header *header;
-
-   struct tgsi_full_declaration decl;
-   struct tgsi_full_instruction inst;
-
-   unsigned ti;
-
-   unsigned i;
-
-   assert(r);
-
-   tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
-   header = (struct tgsi_header *) &tokens[0];
-   *header = tgsi_build_header();
-   *(struct tgsi_processor *) &tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
-
-   ti = 2;
-
-   /*
-    * decl i0                      ; Luma texcoords
-    * decl i1                      ; Chroma Cb texcoords
-    * decl i2                      ; Chroma Cr texcoords
-    */
-   for (i = 0; i < 3; ++i) {
-      decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* decl c0                      ; Scaling factor, rescales 16-bit snorm to 9-bit snorm */
-   decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 0);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* decl o0                      ; Fragment color */
-   decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* decl t0, t1 */
-   decl = vl_decl_temps(0, 1);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /*
-    * decl s0                      ; Sampler for luma texture
-    * decl s1                      ; Sampler for chroma Cb texture
-    * decl s2                      ; Sampler for chroma Cr texture
-    */
-   for (i = 0; i < 3; ++i) {
-      decl = vl_decl_samplers(i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * tex2d t1, i0, s0             ; Read texel from luma texture
-    * mov t0.x, t1.x               ; Move luma sample into .x component
-    * tex2d t1, i1, s1             ; Read texel from chroma Cb texture
-    * mov t0.y, t1.x               ; Move Cb sample into .y component
-    * tex2d t1, i2, s2             ; Read texel from chroma Cr texture
-    * mov t0.z, t1.x               ; Move Cr sample into .z component
-    */
-   for (i = 0; i < 3; ++i) {
-      inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-      inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
-      inst.Src[0].Register.SwizzleX = TGSI_SWIZZLE_X;
-      inst.Src[0].Register.SwizzleY = TGSI_SWIZZLE_X;
-      inst.Src[0].Register.SwizzleZ = TGSI_SWIZZLE_X;
-      inst.Dst[0].Register.WriteMask = TGSI_WRITEMASK_X << i;
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* mul o0, t0, c0               ; Rescale texel to correct range */
-   inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   /* end */
-   inst = vl_end();
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   assert(ti <= max_tokens);
-
-   fs.tokens = tokens;
-   r->i_fs = r->pipe->create_fs_state(r->pipe, &fs);
-   free(tokens);
-}
-
-static void
-create_frame_pred_vert_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   const unsigned max_tokens = 100;
-
-   struct pipe_shader_state vs;
-   struct tgsi_token *tokens;
-   struct tgsi_header *header;
-
-   struct tgsi_full_declaration decl;
-   struct tgsi_full_instruction inst;
-
-   unsigned ti;
-
-   unsigned i;
-
-   assert(r);
-
-   tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
-   header = (struct tgsi_header *) &tokens[0];
-   *header = tgsi_build_header();
-   *(struct tgsi_processor *) &tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
-
-   ti = 2;
-
-   /*
-    * decl i0              ; Vertex pos
-    * decl i1              ; Luma texcoords
-    * decl i2              ; Chroma Cb texcoords
-    * decl i3              ; Chroma Cr texcoords
-    * decl i4              ; Ref surface top field texcoords
-    * decl i5              ; Ref surface bottom field texcoords (unused, packed in the same stream)
-    */
-   for (i = 0; i < 6; i++) {
-      decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * decl o0              ; Vertex pos
-    * decl o1              ; Luma texcoords
-    * decl o2              ; Chroma Cb texcoords
-    * decl o3              ; Chroma Cr texcoords
-    * decl o4              ; Ref macroblock texcoords
-    */
-   for (i = 0; i < 5; i++) {
-      decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * mov o0, i0           ; Move input vertex pos to output
-    * mov o1, i1           ; Move input luma texcoords to output
-    * mov o2, i2           ; Move input chroma Cb texcoords to output
-    * mov o3, i3           ; Move input chroma Cr texcoords to output
-    */
-   for (i = 0; i < 4; ++i) {
-        inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
-        ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* add o4, i0, i4       ; Translate vertex pos by motion vec to form ref macroblock texcoords */
-   inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 4, TGSI_FILE_INPUT, 0, TGSI_FILE_INPUT, 4);
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   /* end */
-   inst = vl_end();
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   assert(ti <= max_tokens);
-
-   vs.tokens = tokens;
-   r->p_vs[0] = r->pipe->create_vs_state(r->pipe, &vs);
-   free(tokens);
-}
-
-#if 0
-static void
-create_field_pred_vert_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   assert(false);
-}
-#endif
-
-static void
-create_frame_pred_frag_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   const unsigned max_tokens = 100;
-
-   struct pipe_shader_state fs;
-   struct tgsi_token *tokens;
-   struct tgsi_header *header;
-
-   struct tgsi_full_declaration decl;
-   struct tgsi_full_instruction inst;
-
-   unsigned ti;
-
-   unsigned i;
-
-   assert(r);
-
-   tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
-   header = (struct tgsi_header *) &tokens[0];
-   *header = tgsi_build_header();
-   *(struct tgsi_processor *) &tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
-
-   ti = 2;
-
-   /*
-    * decl i0                      ; Luma texcoords
-    * decl i1                      ; Chroma Cb texcoords
-    * decl i2                      ; Chroma Cr texcoords
-    * decl i3                      ; Ref macroblock texcoords
-    */
-   for (i = 0; i < 4; ++i) {
-      decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* decl c0                      ; Scaling factor, rescales 16-bit snorm to 9-bit snorm */
-   decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 0);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* decl o0                      ; Fragment color */
-   decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* decl t0, t1 */
-   decl = vl_decl_temps(0, 1);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /*
-    * decl s0                      ; Sampler for luma texture
-    * decl s1                      ; Sampler for chroma Cb texture
-    * decl s2                      ; Sampler for chroma Cr texture
-    * decl s3                      ; Sampler for ref surface texture
-    */
-   for (i = 0; i < 4; ++i) {
-      decl = vl_decl_samplers(i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * tex2d t1, i0, s0             ; Read texel from luma texture
-    * mov t0.x, t1.x               ; Move luma sample into .x component
-    * tex2d t1, i1, s1             ; Read texel from chroma Cb texture
-    * mov t0.y, t1.x               ; Move Cb sample into .y component
-    * tex2d t1, i2, s2             ; Read texel from chroma Cr texture
-    * mov t0.z, t1.x               ; Move Cr sample into .z component
-    */
-   for (i = 0; i < 3; ++i) {
-      inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-      inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
-      inst.Src[0].Register.SwizzleX = TGSI_SWIZZLE_X;
-      inst.Src[0].Register.SwizzleY = TGSI_SWIZZLE_X;
-      inst.Src[0].Register.SwizzleZ = TGSI_SWIZZLE_X;
-      inst.Dst[0].Register.WriteMask = TGSI_WRITEMASK_X << i;
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* mul t0, t0, c0               ; Rescale texel to correct range */
-   inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   /* tex2d t1, i3, s3             ; Read texel from ref macroblock */
-   inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, 3, TGSI_FILE_SAMPLER, 3);
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   /* add o0, t0, t1               ; Add ref and differential to form final output */
-   inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   /* end */
-   inst = vl_end();
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   assert(ti <= max_tokens);
-
-   fs.tokens = tokens;
-   r->p_fs[0] = r->pipe->create_fs_state(r->pipe, &fs);
-   free(tokens);
-}
-
-#if 0
-static void
-create_field_pred_frag_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   assert(false);
-}
-#endif
-
-static void
-create_frame_bi_pred_vert_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   const unsigned max_tokens = 100;
-
-   struct pipe_shader_state vs;
-   struct tgsi_token *tokens;
-   struct tgsi_header *header;
-
-   struct tgsi_full_declaration decl;
-   struct tgsi_full_instruction inst;
-
-   unsigned ti;
-
-   unsigned i;
-
-   assert(r);
-
-   tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
-   header = (struct tgsi_header *) &tokens[0];
-   *header = tgsi_build_header();
-   *(struct tgsi_processor *) &tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_VERTEX, header);
-
-   ti = 2;
-
-   /*
-    * decl i0              ; Vertex pos
-    * decl i1              ; Luma texcoords
-    * decl i2              ; Chroma Cb texcoords
-    * decl i3              ; Chroma Cr texcoords
-    * decl i4              ; First ref macroblock top field texcoords
-    * decl i5              ; First ref macroblock bottom field texcoords (unused, packed in the same stream)
-    * decl i6              ; Second ref macroblock top field texcoords
-    * decl i7              ; Second ref macroblock bottom field texcoords (unused, packed in the same stream)
-    */
-   for (i = 0; i < 8; i++) {
-      decl = vl_decl_input(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * decl o0              ; Vertex pos
-    * decl o1              ; Luma texcoords
-    * decl o2              ; Chroma Cb texcoords
-    * decl o3              ; Chroma Cr texcoords
-    * decl o4              ; First ref macroblock texcoords
-    * decl o5              ; Second ref macroblock texcoords
-    */
-   for (i = 0; i < 6; i++) {
-      decl = vl_decl_output(i == 0 ? TGSI_SEMANTIC_POSITION : TGSI_SEMANTIC_GENERIC, i, i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * mov o0, i0           ; Move input vertex pos to output
-    * mov o1, i1           ; Move input luma texcoords to output
-    * mov o2, i2           ; Move input chroma Cb texcoords to output
-    * mov o3, i3           ; Move input chroma Cr texcoords to output
-    */
-   for (i = 0; i < 4; ++i) {
-      inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, i, TGSI_FILE_INPUT, i);
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * add o4, i0, i4       ; Translate vertex pos by motion vec to form first ref macroblock texcoords
-    * add o5, i0, i6       ; Translate vertex pos by motion vec to form second ref macroblock texcoords
-    */
-   for (i = 0; i < 2; ++i) {
-      inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, i + 4, TGSI_FILE_INPUT, 0, TGSI_FILE_INPUT, (i + 2) * 2);
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* end */
-   inst = vl_end();
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   assert(ti <= max_tokens);
-
-   vs.tokens = tokens;
-   r->b_vs[0] = r->pipe->create_vs_state(r->pipe, &vs);
-   free(tokens);
-}
-
-#if 0
-static void
-create_field_bi_pred_vert_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   assert(false);
-}
-#endif
-
-static void
-create_frame_bi_pred_frag_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   const unsigned max_tokens = 100;
-
-   struct pipe_shader_state fs;
-   struct tgsi_token *tokens;
-   struct tgsi_header *header;
-
-   struct tgsi_full_declaration decl;
-   struct tgsi_full_instruction inst;
-
-   unsigned ti;
-
-   unsigned i;
-
-   assert(r);
-
-   tokens = (struct tgsi_token *) malloc(max_tokens * sizeof(struct tgsi_token));
-   header = (struct tgsi_header *) &tokens[0];
-   *header = tgsi_build_header();
-   *(struct tgsi_processor *) &tokens[1] = tgsi_build_processor(TGSI_PROCESSOR_FRAGMENT, header);
-
-   ti = 2;
-
-   /*
-    * decl i0                      ; Luma texcoords
-    * decl i1                      ; Chroma Cb texcoords
-    * decl i2                      ; Chroma Cr texcoords
-    * decl i3                      ; First ref macroblock texcoords
-    * decl i4                      ; Second ref macroblock texcoords
-    */
-   for (i = 0; i < 5; ++i) {
-      decl = vl_decl_interpolated_input(TGSI_SEMANTIC_GENERIC, i + 1, i, i, TGSI_INTERPOLATE_LINEAR);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * decl c0                      ; Scaling factor, rescales 16-bit snorm to 9-bit snorm
-    * decl c1                      ; Constant 1/2 in .x channel to use as weight to blend past and future texels
-    */
-   decl = vl_decl_constants(TGSI_SEMANTIC_GENERIC, 0, 0, 1);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* decl o0                      ; Fragment color */
-   decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /* decl t0-t2 */
-   decl = vl_decl_temps(0, 2);
-   ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-
-   /*
-    * decl s0                      ; Sampler for luma texture
-    * decl s1                      ; Sampler for chroma Cb texture
-    * decl s2                      ; Sampler for chroma Cr texture
-    * decl s3                      ; Sampler for first ref surface texture
-    * decl s4                      ; Sampler for second ref surface texture
-    */
-   for (i = 0; i < 5; ++i) {
-      decl = vl_decl_samplers(i, i);
-      ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /*
-    * tex2d t1, i0, s0             ; Read texel from luma texture
-    * mov t0.x, t1.x               ; Move luma sample into .x component
-    * tex2d t1, i1, s1             ; Read texel from chroma Cb texture
-    * mov t0.y, t1.x               ; Move Cb sample into .y component
-    * tex2d t1, i2, s2             ; Read texel from chroma Cr texture
-    * mov t0.z, t1.x               ; Move Cr sample into .z component
-    */
-   for (i = 0; i < 3; ++i) {
-      inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_INPUT, i, TGSI_FILE_SAMPLER, i);
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-      inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
-      inst.Src[0].Register.SwizzleX = TGSI_SWIZZLE_X;
-      inst.Src[0].Register.SwizzleY = TGSI_SWIZZLE_X;
-      inst.Src[0].Register.SwizzleZ = TGSI_SWIZZLE_X;
-      inst.Dst[0].Register.WriteMask = TGSI_WRITEMASK_X << i;
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* mul t0, t0, c0               ; Rescale texel to correct range */
-   inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_CONSTANT, 0);
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   /*
-    * tex2d t1, i3, s3             ; Read texel from first ref macroblock
-    * tex2d t2, i4, s4             ; Read texel from second ref macroblock
-    */
-   for (i = 0; i < 2; ++i) {
-      inst = vl_tex(TGSI_TEXTURE_2D, TGSI_FILE_TEMPORARY, i + 1, TGSI_FILE_INPUT, i + 3, TGSI_FILE_SAMPLER, i + 3);
-      ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-   }
-
-   /* lerp t1, c1.x, t1, t2        ; Blend past and future texels */
-   inst = vl_inst4(TGSI_OPCODE_LRP, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_CONSTANT, 1, TGSI_FILE_TEMPORARY, 1, TGSI_FILE_TEMPORARY, 2);
-   inst.Src[0].Register.SwizzleX = TGSI_SWIZZLE_X;
-   inst.Src[0].Register.SwizzleY = TGSI_SWIZZLE_X;
-   inst.Src[0].Register.SwizzleZ = TGSI_SWIZZLE_X;
-   inst.Src[0].Register.SwizzleW = TGSI_SWIZZLE_X;
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   /* add o0, t0, t1               ; Add past/future ref and differential to form final output */
-   inst = vl_inst3(TGSI_OPCODE_ADD, TGSI_FILE_OUTPUT, 0, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_TEMPORARY, 1);
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   /* end */
-   inst = vl_end();
-   ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
-
-   assert(ti <= max_tokens);
-
-   fs.tokens = tokens;
-   r->b_fs[0] = r->pipe->create_fs_state(r->pipe, &fs);
-   free(tokens);
-}
-
-#if 0
-static void
-create_field_bi_pred_frag_shader(struct vl_mpeg12_mc_renderer *r)
-{
-   assert(false);
-}
-#endif
-
-static void
-xfer_buffers_map(struct vl_mpeg12_mc_renderer *r)
-{
-   unsigned i;
-
-   assert(r);
-
-   for (i = 0; i < 3; ++i) {
-      r->tex_transfer[i] = r->pipe->get_tex_transfer
-      (
-         r->pipe, r->textures.all[i],
-         0, 0, 0, PIPE_TRANSFER_WRITE, 0, 0,
-         r->textures.all[i]->width0, r->textures.all[i]->height0
-      );
-
-      r->texels[i] = r->pipe->transfer_map(r->pipe, r->tex_transfer[i]);
-   }
-}
-
-static void
-xfer_buffers_unmap(struct vl_mpeg12_mc_renderer *r)
-{
-   unsigned i;
-
-   assert(r);
-
-   for (i = 0; i < 3; ++i) {
-      r->pipe->transfer_unmap(r->pipe, r->tex_transfer[i]);
-      r->pipe->tex_transfer_destroy(r->pipe, r->tex_transfer[i]);
-   }
-}
-
-static bool
-init_pipe_state(struct vl_mpeg12_mc_renderer *r)
-{
-   struct pipe_sampler_state sampler;
-   struct pipe_vertex_element vertex_elems[8];
-   unsigned filters[5];
-   unsigned i;
-
-   assert(r);
-
-   r->viewport.scale[0] = r->pot_buffers ?
-      util_next_power_of_two(r->picture_width) : r->picture_width;
-   r->viewport.scale[1] = r->pot_buffers ?
-      util_next_power_of_two(r->picture_height) : r->picture_height;
-   r->viewport.scale[2] = 1;
-   r->viewport.scale[3] = 1;
-   r->viewport.translate[0] = 0;
-   r->viewport.translate[1] = 0;
-   r->viewport.translate[2] = 0;
-   r->viewport.translate[3] = 0;
-
-   r->scissor.maxx = r->pot_buffers ?
-      util_next_power_of_two(r->picture_width) : r->picture_width;
-   r->scissor.maxy = r->pot_buffers ?
-      util_next_power_of_two(r->picture_height) : r->picture_height;
-
-   r->fb_state.width = r->pot_buffers ?
-      util_next_power_of_two(r->picture_width) : r->picture_width;
-   r->fb_state.height = r->pot_buffers ?
-      util_next_power_of_two(r->picture_height) : r->picture_height;
-   r->fb_state.nr_cbufs = 1;
-   r->fb_state.zsbuf = NULL;
-
-   /* Luma filter */
-   filters[0] = PIPE_TEX_FILTER_NEAREST;
-   /* Chroma filters */
-   if (r->chroma_format == PIPE_VIDEO_CHROMA_FORMAT_444 ||
-       r->eb_handling == VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ONE) {
-      filters[1] = PIPE_TEX_FILTER_NEAREST;
-      filters[2] = PIPE_TEX_FILTER_NEAREST;
-   }
-   else {
-      filters[1] = PIPE_TEX_FILTER_LINEAR;
-      filters[2] = PIPE_TEX_FILTER_LINEAR;
-   }
-   /* Fwd, bkwd ref filters */
-   filters[3] = PIPE_TEX_FILTER_LINEAR;
-   filters[4] = PIPE_TEX_FILTER_LINEAR;
-
-   for (i = 0; i < 5; ++i) {
-      sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-      sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-      sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
-      sampler.min_img_filter = filters[i];
-      sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-      sampler.mag_img_filter = filters[i];
-      sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
-      sampler.compare_func = PIPE_FUNC_ALWAYS;
-      sampler.normalized_coords = 1;
-      /*sampler.shadow_ambient = ; */
-      /*sampler.lod_bias = ; */
-      sampler.min_lod = 0;
-      /*sampler.max_lod = ; */
-      /*sampler.border_color[i] = ; */
-      /*sampler.max_anisotropy = ; */
-      r->samplers.all[i] = r->pipe->create_sampler_state(r->pipe, &sampler);
-   }
-
-   /* Position element */
-   vertex_elems[0].src_offset = 0;
-   vertex_elems[0].instance_divisor = 0;
-   vertex_elems[0].vertex_buffer_index = 0;
-   vertex_elems[0].src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* Luma, texcoord element */
-   vertex_elems[1].src_offset = sizeof(struct vertex2f);
-   vertex_elems[1].instance_divisor = 0;
-   vertex_elems[1].vertex_buffer_index = 0;
-   vertex_elems[1].src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* Chroma Cr texcoord element */
-   vertex_elems[2].src_offset = sizeof(struct vertex2f) * 2;
-   vertex_elems[2].instance_divisor = 0;
-   vertex_elems[2].vertex_buffer_index = 0;
-   vertex_elems[2].src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* Chroma Cb texcoord element */
-   vertex_elems[3].src_offset = sizeof(struct vertex2f) * 3;
-   vertex_elems[3].instance_divisor = 0;
-   vertex_elems[3].vertex_buffer_index = 0;
-   vertex_elems[3].src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* First ref surface top field texcoord element */
-   vertex_elems[4].src_offset = 0;
-   vertex_elems[4].instance_divisor = 0;
-   vertex_elems[4].vertex_buffer_index = 1;
-   vertex_elems[4].src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* First ref surface bottom field texcoord element */
-   vertex_elems[5].src_offset = sizeof(struct vertex2f);
-   vertex_elems[5].instance_divisor = 0;
-   vertex_elems[5].vertex_buffer_index = 1;
-   vertex_elems[5].src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* Second ref surface top field texcoord element */
-   vertex_elems[6].src_offset = 0;
-   vertex_elems[6].instance_divisor = 0;
-   vertex_elems[6].vertex_buffer_index = 2;
-   vertex_elems[6].src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* Second ref surface bottom field texcoord element */
-   vertex_elems[7].src_offset = sizeof(struct vertex2f);
-   vertex_elems[7].instance_divisor = 0;
-   vertex_elems[7].vertex_buffer_index = 2;
-   vertex_elems[7].src_format = PIPE_FORMAT_R32G32_FLOAT;
-
-   /* need versions with 4,6 and 8 vertex elems */
-   r->vertex_elems[0] = r->pipe->create_vertex_elements_state(r->pipe, 4, vertex_elems);
-   r->vertex_elems[1] = r->pipe->create_vertex_elements_state(r->pipe, 6, vertex_elems);
-   r->vertex_elems[2] = r->pipe->create_vertex_elements_state(r->pipe, 8, vertex_elems);
-
-   return true;
-}
-
-static void
-cleanup_pipe_state(struct vl_mpeg12_mc_renderer *r)
-{
-   unsigned i;
-
-   assert(r);
-
-   for (i = 0; i < 5; ++i)
-      r->pipe->delete_sampler_state(r->pipe, r->samplers.all[i]);
-   for (i = 0; i < 3; i++)
-      r->pipe->delete_vertex_elements_state(r->pipe, r->vertex_elems[i]);
-}
-
-static bool
-init_shaders(struct vl_mpeg12_mc_renderer *r)
-{
-   assert(r);
-
-   create_intra_vert_shader(r);
-   create_intra_frag_shader(r);
-   create_frame_pred_vert_shader(r);
-   create_frame_pred_frag_shader(r);
-   create_frame_bi_pred_vert_shader(r);
-   create_frame_bi_pred_frag_shader(r);
-
-   return true;
-}
-
-static void
-cleanup_shaders(struct vl_mpeg12_mc_renderer *r)
-{
-   assert(r);
-
-   r->pipe->delete_vs_state(r->pipe, r->i_vs);
-   r->pipe->delete_fs_state(r->pipe, r->i_fs);
-   r->pipe->delete_vs_state(r->pipe, r->p_vs[0]);
-   r->pipe->delete_fs_state(r->pipe, r->p_fs[0]);
-   r->pipe->delete_vs_state(r->pipe, r->b_vs[0]);
-   r->pipe->delete_fs_state(r->pipe, r->b_fs[0]);
-}
-
-static bool
-init_buffers(struct vl_mpeg12_mc_renderer *r)
-{
-   struct pipe_texture template;
-
-   const unsigned mbw =
-      align(r->picture_width, MACROBLOCK_WIDTH) / MACROBLOCK_WIDTH;
-   const unsigned mbh =
-      align(r->picture_height, MACROBLOCK_HEIGHT) / MACROBLOCK_HEIGHT;
-
-   unsigned i;
-
-   assert(r);
-
-   r->macroblocks_per_batch =
-      mbw * (r->bufmode == VL_MPEG12_MC_RENDERER_BUFFER_PICTURE ? mbh : 1);
-   r->num_macroblocks = 0;
-   r->macroblock_buf = MALLOC(r->macroblocks_per_batch * sizeof(struct pipe_mpeg12_macroblock));
-
-   memset(&template, 0, sizeof(struct pipe_texture));
-   template.target = PIPE_TEXTURE_2D;
-   /* TODO: Accomodate HW that can't do this and also for cases when this isn't precise enough */
-   template.format = PIPE_FORMAT_R16_SNORM;
-   template.last_level = 0;
-   template.width0 = r->pot_buffers ?
-      util_next_power_of_two(r->picture_width) : r->picture_width;
-   template.height0 = r->pot_buffers ?
-      util_next_power_of_two(r->picture_height) : r->picture_height;
-   template.depth0 = 1;
-   template.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER | PIPE_TEXTURE_USAGE_DYNAMIC;
-
-   r->textures.individual.y = r->pipe->screen->texture_create(r->pipe->screen, &template);
-
-   if (r->chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420) {
-      template.width0 = r->pot_buffers ?
-         util_next_power_of_two(r->picture_width / 2) :
-         r->picture_width / 2;
-      template.height0 = r->pot_buffers ?
-         util_next_power_of_two(r->picture_height / 2) :
-         r->picture_height / 2;
-   }
-   else if (r->chroma_format == PIPE_VIDEO_CHROMA_FORMAT_422)
-      template.height0 = r->pot_buffers ?
-         util_next_power_of_two(r->picture_height / 2) :
-         r->picture_height / 2;
-
-   r->textures.individual.cb =
-      r->pipe->screen->texture_create(r->pipe->screen, &template);
-   r->textures.individual.cr =
-      r->pipe->screen->texture_create(r->pipe->screen, &template);
-
-   r->vertex_bufs.individual.ycbcr.stride = sizeof(struct vertex2f) * 4;
-   r->vertex_bufs.individual.ycbcr.max_index = 24 * r->macroblocks_per_batch - 1;
-   r->vertex_bufs.individual.ycbcr.buffer_offset = 0;
-   r->vertex_bufs.individual.ycbcr.buffer = pipe_buffer_create
-   (
-      r->pipe->screen,
-      DEFAULT_BUF_ALIGNMENT,
-      PIPE_BUFFER_USAGE_VERTEX | PIPE_BUFFER_USAGE_DISCARD,
-      sizeof(struct vertex2f) * 4 * 24 * r->macroblocks_per_batch
-   );
-
-   for (i = 1; i < 3; ++i) {
-      r->vertex_bufs.all[i].stride = sizeof(struct vertex2f) * 2;
-      r->vertex_bufs.all[i].max_index = 24 * r->macroblocks_per_batch - 1;
-      r->vertex_bufs.all[i].buffer_offset = 0;
-      r->vertex_bufs.all[i].buffer = pipe_buffer_create
-      (
-         r->pipe->screen,
-         DEFAULT_BUF_ALIGNMENT,
-         PIPE_BUFFER_USAGE_VERTEX | PIPE_BUFFER_USAGE_DISCARD,
-         sizeof(struct vertex2f) * 2 * 24 * r->macroblocks_per_batch
-      );
-   }
-
-   r->vs_const_buf = pipe_buffer_create
-   (
-      r->pipe->screen,
-      DEFAULT_BUF_ALIGNMENT,
-      PIPE_BUFFER_USAGE_CONSTANT | PIPE_BUFFER_USAGE_DISCARD,
-      sizeof(struct vertex_shader_consts)
-   );
-
-   r->fs_const_buf = pipe_buffer_create
-   (
-      r->pipe->screen,
-      DEFAULT_BUF_ALIGNMENT,
-      PIPE_BUFFER_USAGE_CONSTANT, sizeof(struct fragment_shader_consts)
-   );
-
-   memcpy
-   (
-      pipe_buffer_map(r->pipe->screen, r->fs_const_buf, PIPE_BUFFER_USAGE_CPU_WRITE),
-      &fs_consts, sizeof(struct fragment_shader_consts)
-   );
-
-   pipe_buffer_unmap(r->pipe->screen, r->fs_const_buf);
-
-   return true;
-}
-
-static void
-cleanup_buffers(struct vl_mpeg12_mc_renderer *r)
-{
-   unsigned i;
-
-   assert(r);
-
-   pipe_buffer_reference(&r->vs_const_buf, NULL);
-   pipe_buffer_reference(&r->fs_const_buf, NULL);
-
-   for (i = 0; i < 3; ++i)
-      pipe_buffer_reference(&r->vertex_bufs.all[i].buffer, NULL);
-
-   for (i = 0; i < 3; ++i)
-      pipe_texture_reference(&r->textures.all[i], NULL);
-
-   FREE(r->macroblock_buf);
-}
-
-static enum MACROBLOCK_TYPE
-get_macroblock_type(struct pipe_mpeg12_macroblock *mb)
-{
-   assert(mb);
-
-   switch (mb->mb_type) {
-      case PIPE_MPEG12_MACROBLOCK_TYPE_INTRA:
-         return MACROBLOCK_TYPE_INTRA;
-      case PIPE_MPEG12_MACROBLOCK_TYPE_FWD:
-         return mb->mo_type == PIPE_MPEG12_MOTION_TYPE_FRAME ?
-            MACROBLOCK_TYPE_FWD_FRAME_PRED : MACROBLOCK_TYPE_FWD_FIELD_PRED;
-      case PIPE_MPEG12_MACROBLOCK_TYPE_BKWD:
-         return mb->mo_type == PIPE_MPEG12_MOTION_TYPE_FRAME ?
-            MACROBLOCK_TYPE_BKWD_FRAME_PRED : MACROBLOCK_TYPE_BKWD_FIELD_PRED;
-      case PIPE_MPEG12_MACROBLOCK_TYPE_BI:
-         return mb->mo_type == PIPE_MPEG12_MOTION_TYPE_FRAME ?
-            MACROBLOCK_TYPE_BI_FRAME_PRED : MACROBLOCK_TYPE_BI_FIELD_PRED;
-      default:
-         assert(0);
-   }
-
-   /* Unreachable */
-   return -1;
-}
-
-/* XXX: One of these days this will have to be killed with fire */
-#define SET_BLOCK(vb, cbp, mbx, mby, unitx, unity, ofsx, ofsy, hx, hy, lm, cbm, crm, use_zb, zb)				\
-	do {															\
-	(vb)[0].pos.x = (mbx) * (unitx) + (ofsx);		(vb)[0].pos.y = (mby) * (unity) + (ofsy);			\
-	(vb)[1].pos.x = (mbx) * (unitx) + (ofsx);		(vb)[1].pos.y = (mby) * (unity) + (ofsy) + (hy);		\
-	(vb)[2].pos.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[2].pos.y = (mby) * (unity) + (ofsy);			\
-	(vb)[3].pos.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[3].pos.y = (mby) * (unity) + (ofsy);			\
-	(vb)[4].pos.x = (mbx) * (unitx) + (ofsx);		(vb)[4].pos.y = (mby) * (unity) + (ofsy) + (hy);		\
-	(vb)[5].pos.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[5].pos.y = (mby) * (unity) + (ofsy) + (hy);		\
-																\
-	if (!use_zb || (cbp) & (lm))												\
-	{															\
-		(vb)[0].luma_tc.x = (mbx) * (unitx) + (ofsx);		(vb)[0].luma_tc.y = (mby) * (unity) + (ofsy);		\
-		(vb)[1].luma_tc.x = (mbx) * (unitx) + (ofsx);		(vb)[1].luma_tc.y = (mby) * (unity) + (ofsy) + (hy);	\
-		(vb)[2].luma_tc.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[2].luma_tc.y = (mby) * (unity) + (ofsy);		\
-		(vb)[3].luma_tc.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[3].luma_tc.y = (mby) * (unity) + (ofsy);		\
-		(vb)[4].luma_tc.x = (mbx) * (unitx) + (ofsx);		(vb)[4].luma_tc.y = (mby) * (unity) + (ofsy) + (hy);	\
-		(vb)[5].luma_tc.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[5].luma_tc.y = (mby) * (unity) + (ofsy) + (hy);	\
-	}															\
-	else															\
-	{															\
-		(vb)[0].luma_tc.x = (zb)[0].x;		(vb)[0].luma_tc.y = (zb)[0].y;						\
-		(vb)[1].luma_tc.x = (zb)[0].x;		(vb)[1].luma_tc.y = (zb)[0].y + (hy);					\
-		(vb)[2].luma_tc.x = (zb)[0].x + (hx);	(vb)[2].luma_tc.y = (zb)[0].y;						\
-		(vb)[3].luma_tc.x = (zb)[0].x + (hx);	(vb)[3].luma_tc.y = (zb)[0].y;						\
-		(vb)[4].luma_tc.x = (zb)[0].x;		(vb)[4].luma_tc.y = (zb)[0].y + (hy);					\
-		(vb)[5].luma_tc.x = (zb)[0].x + (hx);	(vb)[5].luma_tc.y = (zb)[0].y + (hy);					\
-	}															\
-																\
-	if (!use_zb || (cbp) & (cbm))												\
-	{															\
-		(vb)[0].cb_tc.x = (mbx) * (unitx) + (ofsx);		(vb)[0].cb_tc.y = (mby) * (unity) + (ofsy);		\
-		(vb)[1].cb_tc.x = (mbx) * (unitx) + (ofsx);		(vb)[1].cb_tc.y = (mby) * (unity) + (ofsy) + (hy);	\
-		(vb)[2].cb_tc.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[2].cb_tc.y = (mby) * (unity) + (ofsy);		\
-		(vb)[3].cb_tc.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[3].cb_tc.y = (mby) * (unity) + (ofsy);		\
-		(vb)[4].cb_tc.x = (mbx) * (unitx) + (ofsx);		(vb)[4].cb_tc.y = (mby) * (unity) + (ofsy) + (hy);	\
-		(vb)[5].cb_tc.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[5].cb_tc.y = (mby) * (unity) + (ofsy) + (hy);	\
-	}															\
-	else															\
-	{															\
-		(vb)[0].cb_tc.x = (zb)[1].x;		(vb)[0].cb_tc.y = (zb)[1].y;						\
-		(vb)[1].cb_tc.x = (zb)[1].x;		(vb)[1].cb_tc.y = (zb)[1].y + (hy);					\
-		(vb)[2].cb_tc.x = (zb)[1].x + (hx);	(vb)[2].cb_tc.y = (zb)[1].y;						\
-		(vb)[3].cb_tc.x = (zb)[1].x + (hx);	(vb)[3].cb_tc.y = (zb)[1].y;						\
-		(vb)[4].cb_tc.x = (zb)[1].x;		(vb)[4].cb_tc.y = (zb)[1].y + (hy);					\
-		(vb)[5].cb_tc.x = (zb)[1].x + (hx);	(vb)[5].cb_tc.y = (zb)[1].y + (hy);					\
-	}															\
-																\
-	if (!use_zb || (cbp) & (crm))												\
-	{															\
-		(vb)[0].cr_tc.x = (mbx) * (unitx) + (ofsx);		(vb)[0].cr_tc.y = (mby) * (unity) + (ofsy);		\
-		(vb)[1].cr_tc.x = (mbx) * (unitx) + (ofsx);		(vb)[1].cr_tc.y = (mby) * (unity) + (ofsy) + (hy);	\
-		(vb)[2].cr_tc.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[2].cr_tc.y = (mby) * (unity) + (ofsy);		\
-		(vb)[3].cr_tc.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[3].cr_tc.y = (mby) * (unity) + (ofsy);		\
-		(vb)[4].cr_tc.x = (mbx) * (unitx) + (ofsx);		(vb)[4].cr_tc.y = (mby) * (unity) + (ofsy) + (hy);	\
-		(vb)[5].cr_tc.x = (mbx) * (unitx) + (ofsx) + (hx);	(vb)[5].cr_tc.y = (mby) * (unity) + (ofsy) + (hy);	\
-	}															\
-	else															\
-	{															\
-		(vb)[0].cr_tc.x = (zb)[2].x;		(vb)[0].cr_tc.y = (zb)[2].y;						\
-		(vb)[1].cr_tc.x = (zb)[2].x;		(vb)[1].cr_tc.y = (zb)[2].y + (hy);					\
-		(vb)[2].cr_tc.x = (zb)[2].x + (hx);	(vb)[2].cr_tc.y = (zb)[2].y;						\
-		(vb)[3].cr_tc.x = (zb)[2].x + (hx);	(vb)[3].cr_tc.y = (zb)[2].y;						\
-		(vb)[4].cr_tc.x = (zb)[2].x;		(vb)[4].cr_tc.y = (zb)[2].y + (hy);					\
-		(vb)[5].cr_tc.x = (zb)[2].x + (hx);	(vb)[5].cr_tc.y = (zb)[2].y + (hy);					\
-	}															\
-	} while (0)
-
-static void
-gen_macroblock_verts(struct vl_mpeg12_mc_renderer *r,
-                     struct pipe_mpeg12_macroblock *mb, unsigned pos,
-                     struct vert_stream_0 *ycbcr_vb, struct vertex2f **ref_vb)
-{
-   struct vertex2f mo_vec[2];
-
-   unsigned i;
-
-   assert(r);
-   assert(mb);
-   assert(ycbcr_vb);
-   assert(pos < r->macroblocks_per_batch);
-
-   mo_vec[1].x = 0;
-   mo_vec[1].y = 0;
-
-   switch (mb->mb_type) {
-      case PIPE_MPEG12_MACROBLOCK_TYPE_BI:
-      {
-         struct vertex2f *vb;
-
-         assert(ref_vb && ref_vb[1]);
-
-         vb = ref_vb[1] + pos * 2 * 24;
-
-         mo_vec[0].x = mb->pmv[0][1][0] * 0.5f * r->surface_tex_inv_size.x;
-         mo_vec[0].y = mb->pmv[0][1][1] * 0.5f * r->surface_tex_inv_size.y;
-
-         if (mb->mo_type == PIPE_MPEG12_MOTION_TYPE_FRAME) {
-            for (i = 0; i < 24 * 2; i += 2) {
-               vb[i].x = mo_vec[0].x;
-               vb[i].y = mo_vec[0].y;
-            }
-         }
-         else {
-            mo_vec[1].x = mb->pmv[1][1][0] * 0.5f * r->surface_tex_inv_size.x;
-            mo_vec[1].y = mb->pmv[1][1][1] * 0.5f * r->surface_tex_inv_size.y;
-
-            for (i = 0; i < 24 * 2; i += 2) {
-               vb[i].x = mo_vec[0].x;
-               vb[i].y = mo_vec[0].y;
-               vb[i + 1].x = mo_vec[1].x;
-               vb[i + 1].y = mo_vec[1].y;
-            }
-         }
-
-         /* fall-through */
-      }
-      case PIPE_MPEG12_MACROBLOCK_TYPE_FWD:
-      case PIPE_MPEG12_MACROBLOCK_TYPE_BKWD:
-      {
-         struct vertex2f *vb;
-
-         assert(ref_vb && ref_vb[0]);
-
-         vb = ref_vb[0] + pos * 2 * 24;
-
-         if (mb->mb_type == PIPE_MPEG12_MACROBLOCK_TYPE_BKWD) {
-             mo_vec[0].x = mb->pmv[0][1][0] * 0.5f * r->surface_tex_inv_size.x;
-             mo_vec[0].y = mb->pmv[0][1][1] * 0.5f * r->surface_tex_inv_size.y;
-
-             if (mb->mo_type == PIPE_MPEG12_MOTION_TYPE_FIELD) {
-                mo_vec[1].x = mb->pmv[1][1][0] * 0.5f * r->surface_tex_inv_size.x;
-                mo_vec[1].y = mb->pmv[1][1][1] * 0.5f * r->surface_tex_inv_size.y;
-             }
-         }
-         else {
-            mo_vec[0].x = mb->pmv[0][0][0] * 0.5f * r->surface_tex_inv_size.x;
-            mo_vec[0].y = mb->pmv[0][0][1] * 0.5f * r->surface_tex_inv_size.y;
-
-            if (mb->mo_type == PIPE_MPEG12_MOTION_TYPE_FIELD) {
-               mo_vec[1].x = mb->pmv[1][0][0] * 0.5f * r->surface_tex_inv_size.x;
-               mo_vec[1].y = mb->pmv[1][0][1] * 0.5f * r->surface_tex_inv_size.y;
-            }
-         }
-
-         if (mb->mb_type == PIPE_MPEG12_MOTION_TYPE_FRAME) {
-            for (i = 0; i < 24 * 2; i += 2) {
-               vb[i].x = mo_vec[0].x;
-               vb[i].y = mo_vec[0].y;
-            }
-         }
-         else {
-            for (i = 0; i < 24 * 2; i += 2) {
-               vb[i].x = mo_vec[0].x;
-               vb[i].y = mo_vec[0].y;
-               vb[i + 1].x = mo_vec[1].x;
-               vb[i + 1].y = mo_vec[1].y;
-            }
-         }
-
-         /* fall-through */
-      }
-      case PIPE_MPEG12_MACROBLOCK_TYPE_INTRA:
-      {
-         const struct vertex2f unit =
-         {
-            r->surface_tex_inv_size.x * MACROBLOCK_WIDTH,
-            r->surface_tex_inv_size.y * MACROBLOCK_HEIGHT
-         };
-         const struct vertex2f half =
-         {
-            r->surface_tex_inv_size.x * (MACROBLOCK_WIDTH / 2),
-            r->surface_tex_inv_size.y * (MACROBLOCK_HEIGHT / 2)
-         };
-         const bool use_zb = r->eb_handling == VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ONE;
-
-         struct vert_stream_0 *vb = ycbcr_vb + pos * 24;
-
-         SET_BLOCK(vb, mb->cbp, mb->mbx, mb->mby,
-                   unit.x, unit.y, 0, 0, half.x, half.y,
-                   32, 2, 1, use_zb, r->zero_block);
-
-         SET_BLOCK(vb + 6, mb->cbp, mb->mbx, mb->mby,
-                   unit.x, unit.y, half.x, 0, half.x, half.y,
-                   16, 2, 1, use_zb, r->zero_block);
-
-         SET_BLOCK(vb + 12, mb->cbp, mb->mbx, mb->mby,
-                   unit.x, unit.y, 0, half.y, half.x, half.y,
-                   8, 2, 1, use_zb, r->zero_block);
-
-         SET_BLOCK(vb + 18, mb->cbp, mb->mbx, mb->mby,
-                   unit.x, unit.y, half.x, half.y, half.x, half.y,
-                   4, 2, 1, use_zb, r->zero_block);
-
-         break;
-      }
-      default:
-         assert(0);
-   }
-}
-
-static void
-gen_macroblock_stream(struct vl_mpeg12_mc_renderer *r,
-                      unsigned *num_macroblocks)
-{
-   unsigned offset[NUM_MACROBLOCK_TYPES];
-   struct vert_stream_0 *ycbcr_vb;
-   struct vertex2f *ref_vb[2];
-   unsigned i;
-
-   assert(r);
-   assert(num_macroblocks);
-
-   for (i = 0; i < r->num_macroblocks; ++i) {
-      enum MACROBLOCK_TYPE mb_type = get_macroblock_type(&r->macroblock_buf[i]);
-      ++num_macroblocks[mb_type];
-   }
-
-   offset[0] = 0;
-
-   for (i = 1; i < NUM_MACROBLOCK_TYPES; ++i)
-      offset[i] = offset[i - 1] + num_macroblocks[i - 1];
-
-   ycbcr_vb = (struct vert_stream_0 *)pipe_buffer_map
-   (
-      r->pipe->screen,
-      r->vertex_bufs.individual.ycbcr.buffer,
-      PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_DISCARD
-   );
-
-   for (i = 0; i < 2; ++i)
-      ref_vb[i] = (struct vertex2f *)pipe_buffer_map
-      (
-         r->pipe->screen,
-         r->vertex_bufs.individual.ref[i].buffer,
-         PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_DISCARD
-      );
-
-   for (i = 0; i < r->num_macroblocks; ++i) {
-      enum MACROBLOCK_TYPE mb_type = get_macroblock_type(&r->macroblock_buf[i]);
-
-      gen_macroblock_verts(r, &r->macroblock_buf[i], offset[mb_type],
-                           ycbcr_vb, ref_vb);
-
-      ++offset[mb_type];
-   }
-
-   pipe_buffer_unmap(r->pipe->screen, r->vertex_bufs.individual.ycbcr.buffer);
-   for (i = 0; i < 2; ++i)
-      pipe_buffer_unmap(r->pipe->screen, r->vertex_bufs.individual.ref[i].buffer);
-}
-
-static void
-flush(struct vl_mpeg12_mc_renderer *r)
-{
-   unsigned num_macroblocks[NUM_MACROBLOCK_TYPES] = { 0 };
-   unsigned vb_start = 0;
-   struct vertex_shader_consts *vs_consts;
-   unsigned i;
-
-   assert(r);
-   assert(r->num_macroblocks == r->macroblocks_per_batch);
-
-   gen_macroblock_stream(r, num_macroblocks);
-
-   r->fb_state.cbufs[0] = r->pipe->screen->get_tex_surface
-   (
-      r->pipe->screen, r->surface,
-      0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE
-   );
-
-   r->pipe->set_framebuffer_state(r->pipe, &r->fb_state);
-   r->pipe->set_viewport_state(r->pipe, &r->viewport);
-   r->pipe->set_scissor_state(r->pipe, &r->scissor);
-
-   vs_consts = pipe_buffer_map
-   (
-      r->pipe->screen, r->vs_const_buf,
-      PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_DISCARD
-   );
-
-   vs_consts->denorm.x = r->surface->width0;
-   vs_consts->denorm.y = r->surface->height0;
-
-   pipe_buffer_unmap(r->pipe->screen, r->vs_const_buf);
-
-   r->pipe->set_constant_buffer(r->pipe, PIPE_SHADER_VERTEX, 0,
-                                r->vs_const_buf);
-   r->pipe->set_constant_buffer(r->pipe, PIPE_SHADER_FRAGMENT, 0,
-                                r->fs_const_buf);
-
-   if (num_macroblocks[MACROBLOCK_TYPE_INTRA] > 0) {
-      r->pipe->set_vertex_buffers(r->pipe, 1, r->vertex_bufs.all);
-      r->pipe->bind_vertex_elements_state(r->pipe, r->vertex_elems[0]);
-      r->pipe->set_fragment_sampler_textures(r->pipe, 3, r->textures.all);
-      r->pipe->bind_fragment_sampler_states(r->pipe, 3, r->samplers.all);
-      r->pipe->bind_vs_state(r->pipe, r->i_vs);
-      r->pipe->bind_fs_state(r->pipe, r->i_fs);
-
-      r->pipe->draw_arrays(r->pipe, PIPE_PRIM_TRIANGLES, vb_start,
-                           num_macroblocks[MACROBLOCK_TYPE_INTRA] * 24);
-      vb_start += num_macroblocks[MACROBLOCK_TYPE_INTRA] * 24;
-   }
-
-   if (num_macroblocks[MACROBLOCK_TYPE_FWD_FRAME_PRED] > 0) {
-      r->pipe->set_vertex_buffers(r->pipe, 2, r->vertex_bufs.all);
-      r->pipe->bind_vertex_elements_state(r->pipe, r->vertex_elems[1]);
-      r->textures.individual.ref[0] = r->past;
-      r->pipe->set_fragment_sampler_textures(r->pipe, 4, r->textures.all);
-      r->pipe->bind_fragment_sampler_states(r->pipe, 4, r->samplers.all);
-      r->pipe->bind_vs_state(r->pipe, r->p_vs[0]);
-      r->pipe->bind_fs_state(r->pipe, r->p_fs[0]);
-
-      r->pipe->draw_arrays(r->pipe, PIPE_PRIM_TRIANGLES, vb_start,
-                           num_macroblocks[MACROBLOCK_TYPE_FWD_FRAME_PRED] * 24);
-      vb_start += num_macroblocks[MACROBLOCK_TYPE_FWD_FRAME_PRED] * 24;
-   }
-
-   if (false /*num_macroblocks[MACROBLOCK_TYPE_FWD_FIELD_PRED] > 0 */ ) {
-      r->pipe->set_vertex_buffers(r->pipe, 2, r->vertex_bufs.all);
-      r->pipe->bind_vertex_elements_state(r->pipe, r->vertex_elems[1]);
-      r->textures.individual.ref[0] = r->past;
-      r->pipe->set_fragment_sampler_textures(r->pipe, 4, r->textures.all);
-      r->pipe->bind_fragment_sampler_states(r->pipe, 4, r->samplers.all);
-      r->pipe->bind_vs_state(r->pipe, r->p_vs[1]);
-      r->pipe->bind_fs_state(r->pipe, r->p_fs[1]);
-
-      r->pipe->draw_arrays(r->pipe, PIPE_PRIM_TRIANGLES, vb_start,
-                           num_macroblocks[MACROBLOCK_TYPE_FWD_FIELD_PRED] * 24);
-      vb_start += num_macroblocks[MACROBLOCK_TYPE_FWD_FIELD_PRED] * 24;
-   }
-
-   if (num_macroblocks[MACROBLOCK_TYPE_BKWD_FRAME_PRED] > 0) {
-      r->pipe->set_vertex_buffers(r->pipe, 2, r->vertex_bufs.all);
-      r->pipe->bind_vertex_elements_state(r->pipe, r->vertex_elems[1]);
-      r->textures.individual.ref[0] = r->future;
-      r->pipe->set_fragment_sampler_textures(r->pipe, 4, r->textures.all);
-      r->pipe->bind_fragment_sampler_states(r->pipe, 4, r->samplers.all);
-      r->pipe->bind_vs_state(r->pipe, r->p_vs[0]);
-      r->pipe->bind_fs_state(r->pipe, r->p_fs[0]);
-
-      r->pipe->draw_arrays(r->pipe, PIPE_PRIM_TRIANGLES, vb_start,
-                           num_macroblocks[MACROBLOCK_TYPE_BKWD_FRAME_PRED] * 24);
-      vb_start += num_macroblocks[MACROBLOCK_TYPE_BKWD_FRAME_PRED] * 24;
-   }
-
-   if (false /*num_macroblocks[MACROBLOCK_TYPE_BKWD_FIELD_PRED] > 0 */ ) {
-      r->pipe->set_vertex_buffers(r->pipe, 2, r->vertex_bufs.all);
-      r->pipe->bind_vertex_elements_state(r->pipe, r->vertex_elems[1]);
-      r->textures.individual.ref[0] = r->future;
-      r->pipe->set_fragment_sampler_textures(r->pipe, 4, r->textures.all);
-      r->pipe->bind_fragment_sampler_states(r->pipe, 4, r->samplers.all);
-      r->pipe->bind_vs_state(r->pipe, r->p_vs[1]);
-      r->pipe->bind_fs_state(r->pipe, r->p_fs[1]);
-
-      r->pipe->draw_arrays(r->pipe, PIPE_PRIM_TRIANGLES, vb_start,
-                           num_macroblocks[MACROBLOCK_TYPE_BKWD_FIELD_PRED] * 24);
-      vb_start += num_macroblocks[MACROBLOCK_TYPE_BKWD_FIELD_PRED] * 24;
-   }
-
-   if (num_macroblocks[MACROBLOCK_TYPE_BI_FRAME_PRED] > 0) {
-      r->pipe->set_vertex_buffers(r->pipe, 3, r->vertex_bufs.all);
-      r->pipe->bind_vertex_elements_state(r->pipe, r->vertex_elems[2]);
-      r->textures.individual.ref[0] = r->past;
-      r->textures.individual.ref[1] = r->future;
-      r->pipe->set_fragment_sampler_textures(r->pipe, 5, r->textures.all);
-      r->pipe->bind_fragment_sampler_states(r->pipe, 5, r->samplers.all);
-      r->pipe->bind_vs_state(r->pipe, r->b_vs[0]);
-      r->pipe->bind_fs_state(r->pipe, r->b_fs[0]);
-
-      r->pipe->draw_arrays(r->pipe, PIPE_PRIM_TRIANGLES, vb_start,
-                           num_macroblocks[MACROBLOCK_TYPE_BI_FRAME_PRED] * 24);
-      vb_start += num_macroblocks[MACROBLOCK_TYPE_BI_FRAME_PRED] * 24;
-   }
-
-   if (false /*num_macroblocks[MACROBLOCK_TYPE_BI_FIELD_PRED] > 0 */ ) {
-      r->pipe->set_vertex_buffers(r->pipe, 3, r->vertex_bufs.all);
-      r->pipe->bind_vertex_elements_state(r->pipe, r->vertex_elems[2]);
-      r->textures.individual.ref[0] = r->past;
-      r->textures.individual.ref[1] = r->future;
-      r->pipe->set_fragment_sampler_textures(r->pipe, 5, r->textures.all);
-      r->pipe->bind_fragment_sampler_states(r->pipe, 5, r->samplers.all);
-      r->pipe->bind_vs_state(r->pipe, r->b_vs[1]);
-      r->pipe->bind_fs_state(r->pipe, r->b_fs[1]);
-
-      r->pipe->draw_arrays(r->pipe, PIPE_PRIM_TRIANGLES, vb_start,
-                           num_macroblocks[MACROBLOCK_TYPE_BI_FIELD_PRED] * 24);
-      vb_start += num_macroblocks[MACROBLOCK_TYPE_BI_FIELD_PRED] * 24;
-   }
-
-   r->pipe->flush(r->pipe, PIPE_FLUSH_RENDER_CACHE, r->fence);
-   pipe_surface_reference(&r->fb_state.cbufs[0], NULL);
-
-   if (r->eb_handling == VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ONE)
-      for (i = 0; i < 3; ++i)
-         r->zero_block[i].x = ZERO_BLOCK_NIL;
-
-   r->num_macroblocks = 0;
-}
-
-static void
-grab_frame_coded_block(short *src, short *dst, unsigned dst_pitch)
-{
-   unsigned y;
-
-   assert(src);
-   assert(dst);
-
-   for (y = 0; y < BLOCK_HEIGHT; ++y)
-      memcpy(dst + y * dst_pitch, src + y * BLOCK_WIDTH, BLOCK_WIDTH * 2);
-}
-
-static void
-grab_field_coded_block(short *src, short *dst, unsigned dst_pitch)
-{
-   unsigned y;
-
-   assert(src);
-   assert(dst);
-
-   for (y = 0; y < BLOCK_HEIGHT; ++y)
-      memcpy(dst + y * dst_pitch * 2, src + y * BLOCK_WIDTH, BLOCK_WIDTH * 2);
-}
-
-static void
-fill_zero_block(short *dst, unsigned dst_pitch)
-{
-   unsigned y;
-
-   assert(dst);
-
-   for (y = 0; y < BLOCK_HEIGHT; ++y)
-      memset(dst + y * dst_pitch, 0, BLOCK_WIDTH * 2);
-}
-
-static void
-grab_blocks(struct vl_mpeg12_mc_renderer *r, unsigned mbx, unsigned mby,
-            enum pipe_mpeg12_dct_type dct_type, unsigned cbp, short *blocks)
-{
-   unsigned tex_pitch;
-   short *texels;
-   unsigned tb = 0, sb = 0;
-   unsigned mbpx = mbx * MACROBLOCK_WIDTH, mbpy = mby * MACROBLOCK_HEIGHT;
-   unsigned x, y;
-
-   assert(r);
-   assert(blocks);
-
-   tex_pitch = r->tex_transfer[0]->stride / util_format_get_blocksize(r->tex_transfer[0]->texture->format);
-   texels = r->texels[0] + mbpy * tex_pitch + mbpx;
-
-   for (y = 0; y < 2; ++y) {
-      for (x = 0; x < 2; ++x, ++tb) {
-         if ((cbp >> (5 - tb)) & 1) {
-            if (dct_type == PIPE_MPEG12_DCT_TYPE_FRAME) {
-               grab_frame_coded_block(blocks + sb * BLOCK_WIDTH * BLOCK_HEIGHT,
-                                      texels + y * tex_pitch * BLOCK_WIDTH +
-                                      x * BLOCK_WIDTH, tex_pitch);
-            }
-            else {
-               grab_field_coded_block(blocks + sb * BLOCK_WIDTH * BLOCK_HEIGHT,
-                                      texels + y * tex_pitch + x * BLOCK_WIDTH,
-                                      tex_pitch);
-            }
-
-            ++sb;
-         }
-         else if (r->eb_handling != VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_NONE) {
-            if (r->eb_handling == VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ALL ||
-                ZERO_BLOCK_IS_NIL(r->zero_block[0])) {
-               fill_zero_block(texels + y * tex_pitch * BLOCK_WIDTH + x * BLOCK_WIDTH, tex_pitch);
-               if (r->eb_handling == VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ONE) {
-                  r->zero_block[0].x = (mbpx + x * 8) * r->surface_tex_inv_size.x;
-                  r->zero_block[0].y = (mbpy + y * 8) * r->surface_tex_inv_size.y;
-               }
-            }
-         }
-      }
-   }
-
-   /* TODO: Implement 422, 444 */
-   assert(r->chroma_format == PIPE_VIDEO_CHROMA_FORMAT_420);
-
-   mbpx /= 2;
-   mbpy /= 2;
-
-   for (tb = 0; tb < 2; ++tb) {
-      tex_pitch = r->tex_transfer[tb + 1]->stride / util_format_get_blocksize(r->tex_transfer[tb + 1]->texture->format);
-      texels = r->texels[tb + 1] + mbpy * tex_pitch + mbpx;
-
-      if ((cbp >> (1 - tb)) & 1) {
-         grab_frame_coded_block(blocks + sb * BLOCK_WIDTH * BLOCK_HEIGHT, texels, tex_pitch);
-         ++sb;
-      }
-      else if (r->eb_handling != VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_NONE) {
-         if (r->eb_handling == VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ALL ||
-             ZERO_BLOCK_IS_NIL(r->zero_block[tb + 1])) {
-            fill_zero_block(texels, tex_pitch);
-            if (r->eb_handling == VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ONE) {
-               r->zero_block[tb + 1].x = (mbpx << 1) * r->surface_tex_inv_size.x;
-               r->zero_block[tb + 1].y = (mbpy << 1) * r->surface_tex_inv_size.y;
-            }
-         }
-      }
-   }
-}
-
-static void
-grab_macroblock(struct vl_mpeg12_mc_renderer *r,
-                struct pipe_mpeg12_macroblock *mb)
-{
-   assert(r);
-   assert(mb);
-   assert(r->num_macroblocks < r->macroblocks_per_batch);
-
-   memcpy(&r->macroblock_buf[r->num_macroblocks], mb,
-          sizeof(struct pipe_mpeg12_macroblock));
-
-   grab_blocks(r, mb->mbx, mb->mby, mb->dct_type, mb->cbp, mb->blocks);
-
-   ++r->num_macroblocks;
-}
-
-bool
-vl_mpeg12_mc_renderer_init(struct vl_mpeg12_mc_renderer *renderer,
-                           struct pipe_context *pipe,
-                           unsigned picture_width,
-                           unsigned picture_height,
-                           enum pipe_video_chroma_format chroma_format,
-                           enum VL_MPEG12_MC_RENDERER_BUFFER_MODE bufmode,
-                           enum VL_MPEG12_MC_RENDERER_EMPTY_BLOCK eb_handling,
-                           bool pot_buffers)
-{
-   unsigned i;
-
-   assert(renderer);
-   assert(pipe);
-   /* TODO: Implement other policies */
-   assert(bufmode == VL_MPEG12_MC_RENDERER_BUFFER_PICTURE);
-   /* TODO: Implement this */
-   /* XXX: XFER_ALL sampling issue at block edges when using bilinear filtering */
-   assert(eb_handling != VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_NONE);
-   /* TODO: Non-pot buffers untested, probably doesn't work without changes to texcoord generation, vert shader, etc */
-   assert(pot_buffers);
-
-   memset(renderer, 0, sizeof(struct vl_mpeg12_mc_renderer));
-
-   renderer->pipe = pipe;
-   renderer->picture_width = picture_width;
-   renderer->picture_height = picture_height;
-   renderer->chroma_format = chroma_format;
-   renderer->bufmode = bufmode;
-   renderer->eb_handling = eb_handling;
-   renderer->pot_buffers = pot_buffers;
-
-   if (!init_pipe_state(renderer))
-      return false;
-   if (!init_shaders(renderer)) {
-      cleanup_pipe_state(renderer);
-      return false;
-   }
-   if (!init_buffers(renderer)) {
-      cleanup_shaders(renderer);
-      cleanup_pipe_state(renderer);
-      return false;
-   }
-
-   renderer->surface = NULL;
-   renderer->past = NULL;
-   renderer->future = NULL;
-   for (i = 0; i < 3; ++i)
-      renderer->zero_block[i].x = ZERO_BLOCK_NIL;
-   renderer->num_macroblocks = 0;
-
-   xfer_buffers_map(renderer);
-
-   return true;
-}
-
-void
-vl_mpeg12_mc_renderer_cleanup(struct vl_mpeg12_mc_renderer *renderer)
-{
-   assert(renderer);
-
-   xfer_buffers_unmap(renderer);
-
-   cleanup_pipe_state(renderer);
-   cleanup_shaders(renderer);
-   cleanup_buffers(renderer);
-}
-
-void
-vl_mpeg12_mc_renderer_render_macroblocks(struct vl_mpeg12_mc_renderer
-                                         *renderer,
-                                         struct pipe_texture *surface,
-                                         struct pipe_texture *past,
-                                         struct pipe_texture *future,
-                                         unsigned num_macroblocks,
-                                         struct pipe_mpeg12_macroblock
-                                         *mpeg12_macroblocks,
-                                         struct pipe_fence_handle **fence)
-{
-   bool new_surface = false;
-
-   assert(renderer);
-   assert(surface);
-   assert(num_macroblocks);
-   assert(mpeg12_macroblocks);
-
-   if (renderer->surface) {
-      if (surface != renderer->surface) {
-         if (renderer->num_macroblocks > 0) {
-            xfer_buffers_unmap(renderer);
-            flush(renderer);
-         }
-         
-         new_surface = true;
-      }
-
-      /* If the surface we're rendering hasn't changed the ref frames shouldn't change. */
-      assert(surface != renderer->surface || renderer->past == past);
-      assert(surface != renderer->surface || renderer->future == future);
-   }
-   else
-      new_surface = true;
-
-   if (new_surface) {
-      renderer->surface = surface;
-      renderer->past = past;
-      renderer->future = future;
-      renderer->fence = fence;
-      renderer->surface_tex_inv_size.x = 1.0f / surface->width0;
-      renderer->surface_tex_inv_size.y = 1.0f / surface->height0;
-   }
-
-   while (num_macroblocks) {
-      unsigned left_in_batch = renderer->macroblocks_per_batch - renderer->num_macroblocks;
-      unsigned num_to_submit = MIN2(num_macroblocks, left_in_batch);
-      unsigned i;
-
-      for (i = 0; i < num_to_submit; ++i) {
-         assert(mpeg12_macroblocks[i].base.codec == PIPE_VIDEO_CODEC_MPEG12);
-         grab_macroblock(renderer, &mpeg12_macroblocks[i]);
-      }
-
-      num_macroblocks -= num_to_submit;
-
-      if (renderer->num_macroblocks == renderer->macroblocks_per_batch) {
-         xfer_buffers_unmap(renderer);
-         flush(renderer);
-         xfer_buffers_map(renderer);
-         /* Next time we get this surface it may have new ref frames */
-         renderer->surface = NULL;
-      }
-   }
-}
diff --git a/src/gallium/auxiliary/vl/vl_mpeg12_mc_renderer.h b/src/gallium/auxiliary/vl/vl_mpeg12_mc_renderer.h
deleted file mode 100644
index a11a3e7307b..00000000000
--- a/src/gallium/auxiliary/vl/vl_mpeg12_mc_renderer.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 vl_mpeg12_mc_renderer_h
-#define vl_mpeg12_mc_renderer_h
-
-#include <pipe/p_compiler.h>
-#include <pipe/p_state.h>
-#include <pipe/p_video_state.h>
-
-struct pipe_context;
-struct pipe_video_surface;
-struct pipe_macroblock;
-
-/* A slice is video-width (rounded up to a multiple of macroblock width) x macroblock height */
-enum VL_MPEG12_MC_RENDERER_BUFFER_MODE
-{
-   VL_MPEG12_MC_RENDERER_BUFFER_SLICE,  /* Saves memory at the cost of smaller batches */
-   VL_MPEG12_MC_RENDERER_BUFFER_PICTURE /* Larger batches, more memory */
-};
-
-enum VL_MPEG12_MC_RENDERER_EMPTY_BLOCK
-{
-   VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ALL, /* Waste of memory bandwidth */
-   VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ONE, /* Can only do point-filtering when interpolating subsampled chroma channels */
-   VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_NONE /* Needs conditional texel fetch! */
-};
-
-struct vl_mpeg12_mc_renderer
-{
-   struct pipe_context *pipe;
-   unsigned picture_width;
-   unsigned picture_height;
-   enum pipe_video_chroma_format chroma_format;
-   enum VL_MPEG12_MC_RENDERER_BUFFER_MODE bufmode;
-   enum VL_MPEG12_MC_RENDERER_EMPTY_BLOCK eb_handling;
-   bool pot_buffers;
-   unsigned macroblocks_per_batch;
-
-   struct pipe_viewport_state viewport;
-   struct pipe_scissor_state scissor;
-   struct pipe_buffer *vs_const_buf;
-   struct pipe_buffer *fs_const_buf;
-   struct pipe_framebuffer_state fb_state;
-   void *vertex_elems[3];
-
-   union
-   {
-      void *all[5];
-      struct { void *y, *cb, *cr, *ref[2]; } individual;
-   } samplers;
-	
-   void *i_vs, *p_vs[2], *b_vs[2];
-   void *i_fs, *p_fs[2], *b_fs[2];
-	
-   union
-   {
-      struct pipe_texture *all[5];
-      struct { struct pipe_texture *y, *cb, *cr, *ref[2]; } individual;
-   } textures;
-
-   union
-   {
-      struct pipe_vertex_buffer all[3];
-      struct { struct pipe_vertex_buffer ycbcr, ref[2]; } individual;
-   } vertex_bufs;
-	
-   struct pipe_texture *surface, *past, *future;
-   struct pipe_fence_handle **fence;
-   unsigned num_macroblocks;
-   struct pipe_mpeg12_macroblock *macroblock_buf;
-   struct pipe_transfer *tex_transfer[3];
-   short *texels[3];
-   struct { float x, y; } surface_tex_inv_size;
-   struct { float x, y; } zero_block[3];
-};
-
-bool vl_mpeg12_mc_renderer_init(struct vl_mpeg12_mc_renderer *renderer,
-                                struct pipe_context *pipe,
-                                unsigned picture_width,
-                                unsigned picture_height,
-                                enum pipe_video_chroma_format chroma_format,
-                                enum VL_MPEG12_MC_RENDERER_BUFFER_MODE bufmode,
-                                enum VL_MPEG12_MC_RENDERER_EMPTY_BLOCK eb_handling,
-                                bool pot_buffers);
-
-void vl_mpeg12_mc_renderer_cleanup(struct vl_mpeg12_mc_renderer *renderer);
-
-void vl_mpeg12_mc_renderer_render_macroblocks(struct vl_mpeg12_mc_renderer *renderer,
-                                              struct pipe_texture *surface,
-                                              struct pipe_texture *past,
-                                              struct pipe_texture *future,
-                                              unsigned num_macroblocks,
-                                              struct pipe_mpeg12_macroblock *mpeg12_macroblocks,
-                                              struct pipe_fence_handle **fence);
-
-#endif /* vl_mpeg12_mc_renderer_h */
diff --git a/src/gallium/auxiliary/vl/vl_shader_build.c b/src/gallium/auxiliary/vl/vl_shader_build.c
deleted file mode 100644
index d011ef97bd6..00000000000
--- a/src/gallium/auxiliary/vl/vl_shader_build.c
+++ /dev/null
@@ -1,243 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include "vl_shader_build.h"
-#include <assert.h>
-#include <tgsi/tgsi_parse.h>
-#include <tgsi/tgsi_build.h>
-
-struct tgsi_full_declaration vl_decl_input(unsigned int name, unsigned int index, unsigned int first, unsigned int last)
-{
-   struct tgsi_full_declaration decl = tgsi_default_full_declaration();
-
-   decl.Declaration.File = TGSI_FILE_INPUT;
-   decl.Declaration.Semantic = 1;
-   decl.Semantic.Name = name;
-   decl.Semantic.Index = index;
-   decl.Range.First = first;
-   decl.Range.Last = last;
-
-   return decl;
-}
-
-struct tgsi_full_declaration vl_decl_interpolated_input
-(
-   unsigned int name,
-   unsigned int index,
-   unsigned int first,
-   unsigned int last,
-   int interpolation
-)
-{
-   struct tgsi_full_declaration decl = tgsi_default_full_declaration();
-
-   assert
-   (
-      interpolation == TGSI_INTERPOLATE_CONSTANT ||
-      interpolation == TGSI_INTERPOLATE_LINEAR ||
-      interpolation == TGSI_INTERPOLATE_PERSPECTIVE
-   );
-
-   decl.Declaration.File = TGSI_FILE_INPUT;
-   decl.Declaration.Semantic = 1;
-   decl.Semantic.Name = name;
-   decl.Semantic.Index = index;
-   decl.Declaration.Interpolate = interpolation;;
-   decl.Range.First = first;
-   decl.Range.Last = last;
-
-   return decl;
-}
-
-struct tgsi_full_declaration vl_decl_constants(unsigned int name, unsigned int index, unsigned int first, unsigned int last)
-{
-   struct tgsi_full_declaration decl = tgsi_default_full_declaration();
-
-   decl.Declaration.File = TGSI_FILE_CONSTANT;
-   decl.Declaration.Semantic = 1;
-   decl.Semantic.Name = name;
-   decl.Semantic.Index = index;
-   decl.Range.First = first;
-   decl.Range.Last = last;
-
-   return decl;
-}
-
-struct tgsi_full_declaration vl_decl_output(unsigned int name, unsigned int index, unsigned int first, unsigned int last)
-{
-   struct tgsi_full_declaration decl = tgsi_default_full_declaration();
-
-   decl.Declaration.File = TGSI_FILE_OUTPUT;
-   decl.Declaration.Semantic = 1;
-   decl.Semantic.Name = name;
-   decl.Semantic.Index = index;
-   decl.Range.First = first;
-   decl.Range.Last = last;
-
-   return decl;
-}
-
-struct tgsi_full_declaration vl_decl_temps(unsigned int first, unsigned int last)
-{
-   struct tgsi_full_declaration decl = tgsi_default_full_declaration();
-
-   decl = tgsi_default_full_declaration();
-   decl.Declaration.File = TGSI_FILE_TEMPORARY;
-   decl.Range.First = first;
-   decl.Range.Last = last;
-
-   return decl;
-}
-
-struct tgsi_full_declaration vl_decl_samplers(unsigned int first, unsigned int last)
-{
-   struct tgsi_full_declaration decl = tgsi_default_full_declaration();
-
-   decl = tgsi_default_full_declaration();
-   decl.Declaration.File = TGSI_FILE_SAMPLER;
-   decl.Range.First = first;
-   decl.Range.Last = last;
-
-   return decl;
-}
-
-struct tgsi_full_instruction vl_inst2
-(
-   int opcode,
-   enum tgsi_file_type dst_file,
-   unsigned int dst_index,
-   enum tgsi_file_type src_file,
-   unsigned int src_index
-)
-{
-   struct tgsi_full_instruction inst = tgsi_default_full_instruction();
-
-   inst.Instruction.Opcode = opcode;
-   inst.Instruction.NumDstRegs = 1;
-   inst.Dst[0].Register.File = dst_file;
-   inst.Dst[0].Register.Index = dst_index;
-   inst.Instruction.NumSrcRegs = 1;
-   inst.Src[0].Register.File = src_file;
-   inst.Src[0].Register.Index = src_index;
-
-   return inst;
-}
-
-struct tgsi_full_instruction vl_inst3
-(
-   int opcode,
-   enum tgsi_file_type dst_file,
-   unsigned int dst_index,
-   enum tgsi_file_type src1_file,
-   unsigned int src1_index,
-   enum tgsi_file_type src2_file,
-   unsigned int src2_index
-)
-{
-   struct tgsi_full_instruction inst = tgsi_default_full_instruction();
-
-   inst.Instruction.Opcode = opcode;
-   inst.Instruction.NumDstRegs = 1;
-   inst.Dst[0].Register.File = dst_file;
-   inst.Dst[0].Register.Index = dst_index;
-   inst.Instruction.NumSrcRegs = 2;
-   inst.Src[0].Register.File = src1_file;
-   inst.Src[0].Register.Index = src1_index;
-   inst.Src[1].Register.File = src2_file;
-   inst.Src[1].Register.Index = src2_index;
-
-   return inst;
-}
-
-struct tgsi_full_instruction vl_tex
-(
-   int tex,
-   enum tgsi_file_type dst_file,
-   unsigned int dst_index,
-   enum tgsi_file_type src1_file,
-   unsigned int src1_index,
-   enum tgsi_file_type src2_file,
-   unsigned int src2_index
-)
-{
-   struct tgsi_full_instruction inst = tgsi_default_full_instruction();
-
-   inst.Instruction.Opcode = TGSI_OPCODE_TEX;
-   inst.Instruction.NumDstRegs = 1;
-   inst.Dst[0].Register.File = dst_file;
-   inst.Dst[0].Register.Index = dst_index;
-   inst.Instruction.NumSrcRegs = 2;
-   inst.Instruction.Texture = 1;
-   inst.Texture.Texture = tex;
-   inst.Src[0].Register.File = src1_file;
-   inst.Src[0].Register.Index = src1_index;
-   inst.Src[1].Register.File = src2_file;
-   inst.Src[1].Register.Index = src2_index;
-
-   return inst;
-}
-
-struct tgsi_full_instruction vl_inst4
-(
-   int opcode,
-   enum tgsi_file_type dst_file,
-   unsigned int dst_index,
-   enum tgsi_file_type src1_file,
-   unsigned int src1_index,
-   enum tgsi_file_type src2_file,
-   unsigned int src2_index,
-   enum tgsi_file_type src3_file,
-   unsigned int src3_index
-)
-{
-   struct tgsi_full_instruction inst = tgsi_default_full_instruction();
-
-   inst.Instruction.Opcode = opcode;
-   inst.Instruction.NumDstRegs = 1;
-   inst.Dst[0].Register.File = dst_file;
-   inst.Dst[0].Register.Index = dst_index;
-   inst.Instruction.NumSrcRegs = 3;
-   inst.Src[0].Register.File = src1_file;
-   inst.Src[0].Register.Index = src1_index;
-   inst.Src[1].Register.File = src2_file;
-   inst.Src[1].Register.Index = src2_index;
-   inst.Src[2].Register.File = src3_file;
-   inst.Src[2].Register.Index = src3_index;
-
-   return inst;
-}
-
-struct tgsi_full_instruction vl_end(void)
-{
-   struct tgsi_full_instruction inst = tgsi_default_full_instruction();
-
-   inst.Instruction.Opcode = TGSI_OPCODE_END;
-   inst.Instruction.NumDstRegs = 0;
-   inst.Instruction.NumSrcRegs = 0;
-
-   return inst;
-}
diff --git a/src/gallium/auxiliary/vl/vl_shader_build.h b/src/gallium/auxiliary/vl/vl_shader_build.h
deleted file mode 100644
index 5da71f8e136..00000000000
--- a/src/gallium/auxiliary/vl/vl_shader_build.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 vl_shader_build_h
-#define vl_shader_build_h
-
-#include <pipe/p_shader_tokens.h>
-
-struct tgsi_full_declaration vl_decl_input(unsigned int name, unsigned int index, unsigned int first, unsigned int last);
-struct tgsi_full_declaration vl_decl_interpolated_input
-(
-   unsigned int name,
-   unsigned int index,
-   unsigned int first,
-   unsigned int last,
-   int interpolation
-);
-struct tgsi_full_declaration vl_decl_constants(unsigned int name, unsigned int index, unsigned int first, unsigned int last);
-struct tgsi_full_declaration vl_decl_output(unsigned int name, unsigned int index, unsigned int first, unsigned int last);
-struct tgsi_full_declaration vl_decl_temps(unsigned int first, unsigned int last);
-struct tgsi_full_declaration vl_decl_samplers(unsigned int first, unsigned int last);
-struct tgsi_full_instruction vl_inst2
-(
-   int opcode,
-   enum tgsi_file_type dst_file,
-   unsigned int dst_index,
-   enum tgsi_file_type src_file,
-   unsigned int src_index
-);
-struct tgsi_full_instruction vl_inst3
-(
-   int opcode,
-   enum tgsi_file_type dst_file,
-   unsigned int dst_index,
-   enum tgsi_file_type src1_file,
-   unsigned int src1_index,
-   enum tgsi_file_type src2_file,
-   unsigned int src2_index
-);
-struct tgsi_full_instruction vl_tex
-(
-   int tex,
-   enum tgsi_file_type dst_file,
-   unsigned int dst_index,
-   enum tgsi_file_type src1_file,
-   unsigned int src1_index,
-   enum tgsi_file_type src2_file,
-   unsigned int src2_index
-);
-struct tgsi_full_instruction vl_inst4
-(
-   int opcode,
-   enum tgsi_file_type dst_file,
-   unsigned int dst_index,
-   enum tgsi_file_type src1_file,
-   unsigned int src1_index,
-   enum tgsi_file_type src2_file,
-   unsigned int src2_index,
-   enum tgsi_file_type src3_file,
-   unsigned int src3_index
-);
-struct tgsi_full_instruction vl_end(void);
-
-#endif
diff --git a/src/gallium/docs/source/context.rst b/src/gallium/docs/source/context.rst
index 2b0941010b0..7439d100973 100644
--- a/src/gallium/docs/source/context.rst
+++ b/src/gallium/docs/source/context.rst
@@ -239,9 +239,7 @@ Flushing
 Resource Busy Queries
 ^^^^^^^^^^^^^^^^^^^^^
 
-``is_texture_referenced``
-
-``is_buffer_referenced``
+``is_resource_referenced``
 
 
 
@@ -265,3 +263,51 @@ The interfaces to these calls are likely to change to make it easier
 for a driver to batch multiple blits with the same source and
 destination.
 
+
+Transfers
+^^^^^^^^^
+
+These methods are used to get data to/from a resource.
+
+``get_transfer`` creates a transfer object.
+
+``transfer_destroy`` destroys the transfer object. May cause
+data to be written to the resource at this point.
+
+``transfer_map`` creates a memory mapping for the transfer object.
+The returned map points to the start of the mapped range according to
+the box region, not the beginning of the resource.
+
+.. _transfer_flush_region:
+``transfer_flush_region`` If a transfer was created with TRANFER_FLUSH_EXPLICIT,
+only the region specified is guaranteed to be written to. This is relative to
+the mapped range, not the beginning of the resource.
+
+``transfer_unmap`` remove the memory mapping for the transfer object.
+Any pointers into the map should be considered invalid and discarded.
+
+``transfer_inline_write`` performs a simplified transfer for simple writes.
+Basically get_transfer, transfer_map, data write, transfer_unmap, and
+transfer_destroy all in one.
+
+.. _pipe_transfer:
+
+PIPE_TRANSFER
+^^^^^^^^^^^^^
+
+These flags control the behavior of a transfer object.
+
+* ``READ``: resource contents are read at transfer create time.
+* ``WRITE``: resource contents will be written back at transfer destroy time.
+* ``MAP_DIRECTLY``: a transfer should directly map the resource. May return
+  NULL if not supported.
+* ``DISCARD``: The memory within the mapped region is discarded.
+  Cannot be used with ``READ``.
+* ``DONTBLOCK``: Fail if the resource cannot be mapped immediately.
+* ``UNSYNCHRONIZED``: Do not synchronize pending operations on the resource
+  when mapping. The interaction of any writes to the map and any
+  operations pending on the resource are undefined. Cannot be used with
+  ``READ``.
+* ``FLUSH_EXPLICIT``: Written ranges will be notified later with
+  :ref:`transfer_flush_region`. Cannot be used with
+  ``READ``.
diff --git a/src/gallium/docs/source/cso/blend.rst b/src/gallium/docs/source/cso/blend.rst
index 55c0f328859..c74396284cc 100644
--- a/src/gallium/docs/source/cso/blend.rst
+++ b/src/gallium/docs/source/cso/blend.rst
@@ -28,7 +28,7 @@ logicop_enable
 logicop_func
    The logic operation to use if logic ops are enabled. One of PIPE_LOGICOP.
 dither
-   Whether dithering is enabled.
+   Whether dithering is enabled. Note: Dithering is implementation-dependent.
 rt
    Contains the per-rendertarget blend state.
 
diff --git a/src/gallium/docs/source/screen.rst b/src/gallium/docs/source/screen.rst
index e78634e59e9..b6efd1d40cf 100644
--- a/src/gallium/docs/source/screen.rst
+++ b/src/gallium/docs/source/screen.rst
@@ -103,59 +103,47 @@ For backwards compatibility, one-dimensional access to CONST register
 file is still supported. In that case, the constbuf index is assumed
 to be 0.
 
-.. _pipe_buffer_usage:
+.. _pipe_bind:
 
-PIPE_BUFFER_USAGE
-^^^^^^^^^^^^^^^^^
+PIPE_BIND
+^^^^^^^^^
 
-These flags control buffer creation. Buffers may only have one role, so
-care should be taken to not allocate a buffer with the wrong usage.
-
-* ``PIXEL``: This is the flag to use for all textures.
-* ``VERTEX``: A vertex buffer.
-* ``INDEX``: An element buffer.
-* ``CONSTANT``: A buffer of shader constants.
-
-Buffers are inevitably abstracting the pipe's underlying memory management,
-so many of their usage flags can be used to direct the way the buffer is
-handled.
-
-* ``CPU_READ``, ``CPU_WRITE``: Whether the user will map and, in the case of
-  the latter, write to, the buffer. The convenience flag ``CPU_READ_WRITE`` is
-  available to signify a read/write buffer.
-* ``GPU_READ``, ``GPU_WRITE``: Whether the driver will internally need to
-  read from or write to the buffer. The latter will only happen if the buffer
-  is made into a render target.
-* ``DISCARD``: When set on a map, the contents of the map will be discarded
-  beforehand. Cannot be used with ``CPU_READ``.
-* ``DONTBLOCK``: When set on a map, the map will fail if the buffer cannot be
-  mapped immediately.
-* ``UNSYNCHRONIZED``: When set on a map, any outstanding operations on the
-  buffer will be ignored. The interaction of any writes to the map and any
-  operations pending with the buffer are undefined. Cannot be used with
-  ``CPU_READ``.
-* ``FLUSH_EXPLICIT``: When set on a map, written ranges of the map require
-  explicit flushes using :ref:`buffer_flush_mapped_range`. Requires
-  ``CPU_WRITE``.
-
-.. _pipe_texture_usage:
-
-PIPE_TEXTURE_USAGE
-^^^^^^^^^^^^^^^^^^
-
-These flags determine the possible roles a texture may be used for during its
-lifetime. Texture usage flags are cumulative and may be combined to create a
-texture that can be used as multiple things.
+These flags control resource creation. Resources may be used in different roles
+during their lifecycle. Bind flags are cumulative and may be combined to create
+a resource which can be used as multiple things.
+Depending on the pipe driver's memory management, depending on these bind flags
+resources might be created and handled quite differently.
 
 * ``RENDER_TARGET``: A color buffer or pixel buffer which will be rendered to.
 * ``DISPLAY_TARGET``: A sharable buffer that can be given to another process.
-* ``PRIMARY``: A front color buffer or scanout buffer.
 * ``DEPTH_STENCIL``: A depth (Z) buffer or stencil buffer.  Gallium does
   not explicitly provide for stencil-only buffers, so any stencil buffer
   validated here is implicitly also a depth buffer.
-* ``SAMPLER``: A texture that may be sampled from in a fragment or vertex
+* ``SAMPLER_VIEW``: A texture that may be sampled from in a fragment or vertex
   shader.
-* ``DYNAMIC``: A texture that will be mapped frequently.
+* ``VERTEX_BUFFER``: A vertex buffer.
+* ``INDEX_BUFFER``: An element buffer.
+* ``CONSTANT_BUFFER``: A buffer of shader constants.
+* ``BLIT_SOURCE``: A blit source, as given to surface_copy.
+* ``BLIT_DESTINATION``: A blit destination, as given to surface_copy and surface_fill.
+* ``TRANSFER_WRITE``: A transfer object which will be written to.
+* ``TRANSFER_READ``: A transfer object which will be read from.
+* ``CUSTOM``:
+* ``SCANOUT``: A front color buffer or scanout buffer.
+* ``SHARED``:
+
+.. _pipe_usage:
+
+PIPE_USAGE
+^^^^^^^^^^
+
+The PIPE_USAGE enums are hints about the expected lifecycle of a resource.
+* ``DEFAULT``: Expect many uploads to the resource, intermixed with draws.
+* ``DYNAMIC``: Expect many uploads to the resource, intermixed with draws.
+* ``STATIC``: Same as immutable (?)
+* ``IMMUTABLE``: Resource will not be changed after first upload.
+* ``STREAM``: Upload will be followed by draw, followed by upload, ...
+
 
 
 PIPE_TEXTURE_GEOM
@@ -218,64 +206,23 @@ is_format_supported
 
 See if a format can be used in a specific manner.
 
-**usage** is a bitmask of :ref:`PIPE_TEXTURE_USAGE` flags.
+**tex_usage** is a bitmask of :ref:`PIPE_BIND` flags.
 
 Returns TRUE if all usages can be satisfied.
 
-.. note::
-
-   ``PIPE_TEXTURE_USAGE_DYNAMIC`` is not a valid usage.
 
-.. _texture_create:
+.. _resource_create:
 
-texture_create
+resource_create
 ^^^^^^^^^^^^^^
 
-Given a template of texture setup, create a buffer and texture.
+Given a template of texture setup, create a resource.
+The way a resource may be used is specifed by bind flags, :ref:`pipe_bind`.
+and hints are used to indicate to the driver what access pattern might be
+likely, :ref:`pipe_usage`.
 
-texture_blanket
+resource_destroy
 ^^^^^^^^^^^^^^^
 
-Like :ref:`texture_create`, but use a supplied buffer instead of creating a
-new one.
-
-texture_destroy
-^^^^^^^^^^^^^^^
-
-Destroy a texture. The buffer backing the texture is destroyed if it has no
-more references.
-
-buffer_map
-^^^^^^^^^^
-
-Map a buffer into memory.
-
-**usage** is a bitmask of :ref:`PIPE_BUFFER_USAGE` flags.
-
-Returns a pointer to the map, or NULL if the mapping failed.
-
-buffer_map_range
-^^^^^^^^^^^^^^^^
-
-Map a range of a buffer into memory.
-
-The returned map is always relative to the beginning of the buffer, not the
-beginning of the mapped range.
-
-.. _buffer_flush_mapped_range:
-
-buffer_flush_mapped_range
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Flush a range of mapped memory into a buffer.
-
-The buffer must have been mapped with ``PIPE_BUFFER_USAGE_FLUSH_EXPLICIT``.
-
-**usage** is a bitmask of :ref:`PIPE_BUFFER_USAGE` flags.
-
-buffer_unmap
-^^^^^^^^^^^^
-
-Unmap a buffer from memory.
+Destroy a resource. A resource is destroyed if it has no more references.
 
-Any pointers into the map should be considered invalid and discarded.
diff --git a/src/gallium/drivers/cell/ppu/Makefile b/src/gallium/drivers/cell/ppu/Makefile
index 8769b826b5f..c92f8e5cba2 100644
--- a/src/gallium/drivers/cell/ppu/Makefile
+++ b/src/gallium/drivers/cell/ppu/Makefile
@@ -21,7 +21,6 @@ SPU_CODE_MODULE = ../spu/g3d_spu.a
 
 SOURCES = \
 	cell_batch.c \
-	cell_buffer.c \
 	cell_clear.c \
 	cell_context.c \
 	cell_draw_arrays.c \
diff --git a/src/gallium/drivers/cell/ppu/cell_buffer.c b/src/gallium/drivers/cell/ppu/cell_buffer.c
deleted file mode 100644
index f56a28d62e2..00000000000
--- a/src/gallium/drivers/cell/ppu/cell_buffer.c
+++ /dev/null
@@ -1,118 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.
- * 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 VMWARE 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.
- *
- **************************************************************************/
-
-
-#include "util/u_inlines.h"
-#include "util/u_memory.h"
-#include "util/u_math.h"
-
-#include "cell_screen.h"
-#include "cell_buffer.h"
-
-
-static void *
-cell_buffer_map(struct pipe_screen *screen,
-                    struct pipe_buffer *buf,
-                    unsigned flags)
-{
-   struct cell_buffer *cell_buf = cell_buffer(buf);
-   return cell_buf->data;
-}
-
-
-static void
-cell_buffer_unmap(struct pipe_screen *screen,
-                      struct pipe_buffer *buf)
-{
-}
-
-
-static void
-cell_buffer_destroy(struct pipe_buffer *buf)
-{
-   struct cell_buffer *sbuf = cell_buffer(buf);
-
-   if (!sbuf->userBuffer)
-      align_free(sbuf->data);
-      
-   FREE(sbuf);
-}
-
-
-static struct pipe_buffer *
-cell_buffer_create(struct pipe_screen *screen,
-                       unsigned alignment,
-                       unsigned usage,
-                       unsigned size)
-{
-   struct cell_buffer *buffer = CALLOC_STRUCT(cell_buffer);
-
-   pipe_reference_init(&buffer->base.reference, 1);
-   buffer->base.screen = screen;
-   buffer->base.alignment = MAX2(alignment, 16);
-   buffer->base.usage = usage;
-   buffer->base.size = size;
-
-   buffer->data = align_malloc(size, alignment);
-
-   return &buffer->base;
-}
-
-
-/**
- * Create buffer which wraps user-space data.
- */
-static struct pipe_buffer *
-cell_user_buffer_create(struct pipe_screen *screen,
-                            void *ptr,
-                            unsigned bytes)
-{
-   struct cell_buffer *buffer;
-
-   buffer = CALLOC_STRUCT(cell_buffer);
-   if(!buffer)
-      return NULL;
-
-   pipe_reference_init(&buffer->base.reference, 1);
-   buffer->base.screen = screen;
-   buffer->base.size = bytes;
-   buffer->userBuffer = TRUE;
-   buffer->data = ptr;
-
-   return &buffer->base;
-}
-
-
-void
-cell_init_screen_buffer_funcs(struct pipe_screen *screen)
-{
-   screen->buffer_create = cell_buffer_create;
-   screen->user_buffer_create = cell_user_buffer_create;
-   screen->buffer_map = cell_buffer_map;
-   screen->buffer_unmap = cell_buffer_unmap;
-   screen->buffer_destroy = cell_buffer_destroy;
-}
diff --git a/src/gallium/drivers/cell/ppu/cell_buffer.h b/src/gallium/drivers/cell/ppu/cell_buffer.h
deleted file mode 100644
index ef0a8a70e59..00000000000
--- a/src/gallium/drivers/cell/ppu/cell_buffer.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.
- * 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 VMWARE 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 SP_BUFFER_H
-#define SP_BUFFER_H
-
-#include "pipe/p_compiler.h"
-#include "pipe/p_state.h"
-
-
-struct cell_buffer
-{
-   struct pipe_buffer base;
-   boolean userBuffer;  /** Is this a user-space buffer? */
-   void *data;
-};
-
-
-/** Cast wrapper */
-static INLINE struct cell_buffer *
-cell_buffer( struct pipe_buffer *buf )
-{
-   return (struct cell_buffer *)buf;
-}
-
-
-void
-cell_init_screen_buffer_funcs(struct pipe_screen *screen);
-
-
-#endif /* SP_BUFFER_H */
diff --git a/src/gallium/drivers/cell/ppu/cell_context.c b/src/gallium/drivers/cell/ppu/cell_context.c
index f6cb1fc9be7..49cece58b8f 100644
--- a/src/gallium/drivers/cell/ppu/cell_context.c
+++ b/src/gallium/drivers/cell/ppu/cell_context.c
@@ -99,8 +99,8 @@ static const struct debug_named_value cell_debug_flags[] = {
 };
 
 static unsigned int
-cell_is_texture_referenced( struct pipe_context *pipe,
-			    struct pipe_texture *texture,
+cell_is_resource_referenced( struct pipe_context *pipe,
+			    struct pipe_resource *texture,
 			    unsigned face, unsigned level)
 {
    /**
@@ -110,16 +110,6 @@ cell_is_texture_referenced( struct pipe_context *pipe,
    return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
 }
 
-static unsigned int
-cell_is_buffer_referenced( struct pipe_context *pipe,
-			   struct pipe_buffer *buf)
-{
-   /**
-    * FIXME: Optimize.
-    */
-
-   return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
-}
 
 struct pipe_context *
 cell_create_context(struct pipe_screen *screen,
@@ -144,8 +134,7 @@ cell_create_context(struct pipe_screen *screen,
    cell->pipe.clear = cell_clear;
    cell->pipe.flush = cell_flush;
 
-   cell->pipe.is_texture_referenced = cell_is_texture_referenced;
-   cell->pipe.is_buffer_referenced = cell_is_buffer_referenced;
+   cell->pipe.is_resource_referenced = cell_is_resource_referenced;
 
 #if 0
    cell->pipe.begin_query = cell_begin_query;
diff --git a/src/gallium/drivers/cell/ppu/cell_context.h b/src/gallium/drivers/cell/ppu/cell_context.h
index f7e2284445d..07b6eebc69c 100644
--- a/src/gallium/drivers/cell/ppu/cell_context.h
+++ b/src/gallium/drivers/cell/ppu/cell_context.h
@@ -122,11 +122,11 @@ struct cell_context
    struct pipe_blend_color blend_color;
    struct pipe_stencil_ref stencil_ref;
    struct pipe_clip_state clip;
-   struct pipe_buffer *constants[2];
+   struct pipe_resource *constants[2];
    struct pipe_framebuffer_state framebuffer;
    struct pipe_poly_stipple poly_stipple;
    struct pipe_scissor_state scissor;
-   struct cell_texture *texture[PIPE_MAX_SAMPLERS];
+   struct cell_resource *texture[PIPE_MAX_SAMPLERS];
    struct pipe_sampler_view *fragment_sampler_views[PIPE_MAX_SAMPLERS];
    uint num_textures;
    struct pipe_viewport_state viewport;
diff --git a/src/gallium/drivers/cell/ppu/cell_draw_arrays.c b/src/gallium/drivers/cell/ppu/cell_draw_arrays.c
index 15d4e8338f4..80e94a79df7 100644
--- a/src/gallium/drivers/cell/ppu/cell_draw_arrays.c
+++ b/src/gallium/drivers/cell/ppu/cell_draw_arrays.c
@@ -39,7 +39,7 @@
 #include "cell_draw_arrays.h"
 #include "cell_state.h"
 #include "cell_flush.h"
-#include "cell_buffer.h"
+#include "cell_texture.h"
 
 #include "draw/draw_context.h"
 
@@ -57,7 +57,7 @@
  */
 static void
 cell_draw_range_elements(struct pipe_context *pipe,
-                         struct pipe_buffer *indexBuffer,
+                         struct pipe_resource *indexBuffer,
                          unsigned indexSize,
                          unsigned min_index,
                          unsigned max_index,
@@ -78,12 +78,12 @@ cell_draw_range_elements(struct pipe_context *pipe,
     * Map vertex buffers
     */
    for (i = 0; i < cell->num_vertex_buffers; i++) {
-      void *buf = cell_buffer(cell->vertex_buffer[i].buffer)->data;
+      void *buf = cell_resource(cell->vertex_buffer[i].buffer)->data;
       draw_set_mapped_vertex_buffer(draw, i, buf);
    }
    /* Map index buffer, if present */
    if (indexBuffer) {
-      void *mapped_indexes = cell_buffer(indexBuffer)->data;
+      void *mapped_indexes = cell_resource(indexBuffer)->data;
       draw_set_mapped_element_buffer(draw, indexSize, mapped_indexes);
    }
    else {
@@ -116,7 +116,7 @@ cell_draw_range_elements(struct pipe_context *pipe,
 
 static void
 cell_draw_elements(struct pipe_context *pipe,
-                   struct pipe_buffer *indexBuffer,
+                   struct pipe_resource *indexBuffer,
                    unsigned indexSize,
                    unsigned mode, unsigned start, unsigned count)
 {
diff --git a/src/gallium/drivers/cell/ppu/cell_fence.c b/src/gallium/drivers/cell/ppu/cell_fence.c
index 035ef41b898..eac798e8cf6 100644
--- a/src/gallium/drivers/cell/ppu/cell_fence.c
+++ b/src/gallium/drivers/cell/ppu/cell_fence.c
@@ -82,7 +82,7 @@ cell_fence_finish(const struct cell_context *cell,
 
 struct cell_buffer_node
 {
-   struct pipe_buffer *buffer;
+   struct pipe_resource *buffer;
    struct cell_buffer_node *next;
 };
 
@@ -90,12 +90,12 @@ struct cell_buffer_node
 static void
 cell_add_buffer_to_list(struct cell_context *cell,
                         struct cell_buffer_list *list,
-                        struct pipe_buffer *buffer)
+                        struct pipe_resource *buffer)
 {
    struct cell_buffer_node *node = CALLOC_STRUCT(cell_buffer_node);
    /* create new list node which references the buffer, insert at head */
    if (node) {
-      pipe_buffer_reference(&node->buffer, buffer);
+      pipe_resource_reference(&node->buffer, buffer);
       node->next = list->head;
       list->head = node;
    }
@@ -129,7 +129,7 @@ cell_free_fenced_buffers(struct cell_context *cell,
          if (node->buffer->reference.count == 1)
             printf("   Delete!\n");
 #endif
-         pipe_buffer_reference(&node->buffer, NULL);
+         pipe_resource_reference(&node->buffer, NULL);
          FREE(node);
          node = next;
       }
@@ -150,7 +150,7 @@ cell_add_fenced_textures(struct cell_context *cell)
    uint i;
 
    for (i = 0; i < cell->num_textures; i++) {
-      struct cell_texture *ct = cell->texture[i];
+      struct cell_resource *ct = cell->texture[i];
       if (ct) {
 #if 0
          printf("Adding texture %p buffer %p to list\n",
diff --git a/src/gallium/drivers/cell/ppu/cell_pipe_state.c b/src/gallium/drivers/cell/ppu/cell_pipe_state.c
index 059ce8597bc..8c975c6ae2a 100644
--- a/src/gallium/drivers/cell/ppu/cell_pipe_state.c
+++ b/src/gallium/drivers/cell/ppu/cell_pipe_state.c
@@ -271,12 +271,12 @@ cell_set_fragment_sampler_views(struct pipe_context *pipe,
       struct pipe_sampler_view *old_view = cell->fragment_sampler_views[i];
 
       if (old_view != new_view) {
-         struct pipe_texture *new_tex = new_view ? new_view->texture : NULL;
+         struct pipe_resource *new_tex = new_view ? new_view->texture : NULL;
 
          pipe_sampler_view_reference(&cell->fragment_sampler_views[i],
                                      views[i]);
-         pipe_texture_reference((struct pipe_texture **) &cell->texture[i],
-                                (struct pipe_texture *) new_tex);
+         pipe_resource_reference((struct pipe_resource **) &cell->texture[i],
+                                (struct pipe_resource *) new_tex);
 
          changed |= (1 << i);
       }
@@ -293,7 +293,7 @@ cell_set_fragment_sampler_views(struct pipe_context *pipe,
 
 static struct pipe_sampler_view *
 cell_create_sampler_view(struct pipe_context *pipe,
-                         struct pipe_texture *texture,
+                         struct pipe_resource *texture,
                          const struct pipe_sampler_view *templ)
 {
    struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
@@ -302,7 +302,7 @@ cell_create_sampler_view(struct pipe_context *pipe,
       *view = *templ;
       view->reference.count = 1;
       view->texture = NULL;
-      pipe_texture_reference(&view->texture, texture);
+      pipe_resource_reference(&view->texture, texture);
       view->context = pipe;
    }
 
@@ -314,7 +314,7 @@ static void
 cell_sampler_view_destroy(struct pipe_context *pipe,
                           struct pipe_sampler_view *view)
 {
-   pipe_texture_reference(&view->texture, NULL);
+   pipe_resource_reference(&view->texture, NULL);
    FREE(view);
 }
 
@@ -333,7 +333,7 @@ cell_map_surfaces(struct cell_context *cell)
    for (i = 0; i < 1; i++) {
       struct pipe_surface *ps = cell->framebuffer.cbufs[i];
       if (ps) {
-         struct cell_texture *ct = cell_texture(ps->texture);
+         struct cell_resource *ct = cell_resource(ps->texture);
 #if 0
          cell->cbuf_map[i] = screen->buffer_map(screen,
                                                 ct->buffer,
@@ -348,7 +348,7 @@ cell_map_surfaces(struct cell_context *cell)
    {
       struct pipe_surface *ps = cell->framebuffer.zsbuf;
       if (ps) {
-         struct cell_texture *ct = cell_texture(ps->texture);
+         struct cell_resource *ct = cell_resource(ps->texture);
 #if 0
          cell->zsbuf_map = screen->buffer_map(screen,
                                               ct->buffer,
@@ -374,7 +374,7 @@ cell_unmap_surfaces(struct cell_context *cell)
    for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
       struct pipe_surface *ps = cell->framebuffer.cbufs[i];
       if (ps && cell->cbuf_map[i]) {
-         /*struct cell_texture *ct = cell_texture(ps->texture);*/
+         /*struct cell_resource *ct = cell_resource(ps->texture);*/
          assert(ps->texture);
          /*assert(ct->buffer);*/
 
@@ -386,7 +386,7 @@ cell_unmap_surfaces(struct cell_context *cell)
    {
       struct pipe_surface *ps = cell->framebuffer.zsbuf;
       if (ps && cell->zsbuf_map) {
-         /*struct cell_texture *ct = cell_texture(ps->texture);*/
+         /*struct cell_resource *ct = cell_resource(ps->texture);*/
          /*screen->buffer_unmap(screen, ct->buffer);*/
          cell->zsbuf_map = NULL;
       }
diff --git a/src/gallium/drivers/cell/ppu/cell_screen.c b/src/gallium/drivers/cell/ppu/cell_screen.c
index 363d1e65e7f..b4fd8d7235c 100644
--- a/src/gallium/drivers/cell/ppu/cell_screen.c
+++ b/src/gallium/drivers/cell/ppu/cell_screen.c
@@ -35,7 +35,6 @@
 #include "cell_context.h"
 #include "cell_screen.h"
 #include "cell_texture.h"
-#include "cell_buffer.h"
 #include "cell_public.h"
 
 #include "state_tracker/sw_winsys.h"
@@ -138,9 +137,11 @@ cell_is_format_supported( struct pipe_screen *screen,
                           unsigned tex_usage, 
                           unsigned geom_flags )
 {
-   if (tex_usage & (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                    PIPE_TEXTURE_USAGE_SCANOUT |
-                    PIPE_TEXTURE_USAGE_SHARED)) {
+   struct sw_winsys *winsys = cell_screen(screen)->winsys;
+
+   if (tex_usage & (PIPE_BIND_DISPLAY_TARGET |
+                    PIPE_BIND_SCANOUT |
+                    PIPE_BIND_SHARED)) {
       if (!winsys->is_displaytarget_format_supported(winsys, tex_usage, format))
          return FALSE;
    }
@@ -198,7 +199,6 @@ cell_create_screen(struct sw_winsys *winsys)
    screen->base.context_create = cell_create_context;
 
    cell_init_screen_texture_funcs(&screen->base);
-   cell_init_screen_buffer_funcs(&screen->base);
 
    return &screen->base;
 }
diff --git a/src/gallium/drivers/cell/ppu/cell_state_emit.c b/src/gallium/drivers/cell/ppu/cell_state_emit.c
index 424e2628a95..bb11c68fa24 100644
--- a/src/gallium/drivers/cell/ppu/cell_state_emit.c
+++ b/src/gallium/drivers/cell/ppu/cell_state_emit.c
@@ -241,7 +241,7 @@ cell_emit_state(struct cell_context *cell)
 
    if (cell->dirty & (CELL_NEW_FS_CONSTANTS)) {
       const uint shader = PIPE_SHADER_FRAGMENT;
-      const uint num_const = cell->constants[shader]->size / sizeof(float);
+      const uint num_const = cell->constants[shader]->width0 / sizeof(float);
       uint i, j;
       float *buf = cell_batch_alloc16(cell, ROUNDUP16(32 + num_const * sizeof(float)));
       uint32_t *ibuf = (uint32_t *) buf;
@@ -293,7 +293,7 @@ cell_emit_state(struct cell_context *cell)
             texture->opcode[0] = CELL_CMD_STATE_TEXTURE;
             texture->unit = i;
             if (cell->texture[i]) {
-               struct cell_texture *ct = cell->texture[i];
+               struct cell_resource *ct = cell->texture[i];
                uint level;
                for (level = 0; level < CELL_MAX_TEXTURE_LEVELS; level++) {
                   texture->start[level] = (ct->mapped +
diff --git a/src/gallium/drivers/cell/ppu/cell_state_shader.c b/src/gallium/drivers/cell/ppu/cell_state_shader.c
index 9e29ddc2d45..ddf14772689 100644
--- a/src/gallium/drivers/cell/ppu/cell_state_shader.c
+++ b/src/gallium/drivers/cell/ppu/cell_state_shader.c
@@ -34,7 +34,7 @@
 #include "cell_context.h"
 #include "cell_state.h"
 #include "cell_gen_fp.h"
-#include "cell_buffer.h"
+#include "cell_texture.h"
 
 
 /** cast wrapper */
@@ -183,11 +183,11 @@ cell_delete_vs_state(struct pipe_context *pipe, void *vs)
 static void
 cell_set_constant_buffer(struct pipe_context *pipe,
                          uint shader, uint index,
-                         struct pipe_buffer *constants)
+                         struct pipe_resource *constants)
 {
    struct cell_context *cell = cell_context(pipe);
-   unsigned size = constants ? constants->size : 0;
-   const void *data = constants ? cell_buffer(constants)->data : NULL;
+   unsigned size = constants ? constants->width0 : 0;
+   const void *data = constants ? cell_resource(constants)->data : NULL;
 
    assert(shader < PIPE_SHADER_TYPES);
    assert(index == 0);
@@ -198,7 +198,7 @@ cell_set_constant_buffer(struct pipe_context *pipe,
    draw_flush(cell->draw);
 
    /* note: reference counting */
-   pipe_buffer_reference(&cell->constants[shader], constants);
+   pipe_resource_reference(&cell->constants[shader], constants);
 
    if(shader == PIPE_SHADER_VERTEX) {
       draw_set_mapped_constant_buffer(cell->draw, PIPE_SHADER_VERTEX, 0,
diff --git a/src/gallium/drivers/cell/ppu/cell_texture.c b/src/gallium/drivers/cell/ppu/cell_texture.c
index 5b169afaf88..8a379154d1b 100644
--- a/src/gallium/drivers/cell/ppu/cell_texture.c
+++ b/src/gallium/drivers/cell/ppu/cell_texture.c
@@ -42,17 +42,17 @@
 #include "cell_context.h"
 #include "cell_screen.h"
 #include "cell_state.h"
-#include "cell_texture.h"
+#include "cell_resource.h"
 
 #include "state_tracker/sw_winsys.h"
 
 
 
 static boolean
-cell_texture_layout(struct pipe_screen *screen, 
-                    struct cell_texture *ct)
+cell_resource_layout(struct pipe_screen *screen, 
+		     struct cell_resource *ct)
 {
-   struct pipe_texture *pt = &ct->base;
+   struct pipe_resource *pt = &ct->base;
    unsigned level;
    unsigned width = pt->width0;
    unsigned height = pt->height0;
@@ -98,14 +98,14 @@ cell_texture_layout(struct pipe_screen *screen,
  */
 static boolean
 cell_displaytarget_layout(struct pipe_screen *screen,
-                          struct cell_texture * ct)
+                          struct cell_resource * ct)
 {
    struct sw_winsys *winsys = cell_screen(screen)->winsys;
 
    /* Round up the surface size to a multiple of the tile size?
     */
    ct->dt = winsys->displaytarget_create(winsys,
-                                          ct->base->tex_usage,
+                                          ct->base.bind,
                                           ct->base.format,
                                           ct->base.width0, 
                                           ct->base.height0,
@@ -115,11 +115,11 @@ cell_displaytarget_layout(struct pipe_screen *screen,
    return ct->dt != NULL;
 }
 
-static struct pipe_texture *
-cell_texture_create(struct pipe_screen *screen,
-                    const struct pipe_texture *templat)
+static struct pipe_resource *
+cell_resource_create(struct pipe_screen *screen,
+                    const struct pipe_resource *templat)
 {
-   struct cell_texture *ct = CALLOC_STRUCT(cell_texture);
+   struct cell_resource *ct = CALLOC_STRUCT(cell_resource);
    if (!ct)
       return NULL;
 
@@ -130,14 +130,14 @@ cell_texture_create(struct pipe_screen *screen,
    /* Create both a displaytarget (linear) and regular texture
     * (twiddled).  Convert twiddled->linear at flush_frontbuffer time.
     */
-   if (ct->base.tex_usage & (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                             PIPE_TEXTURE_USAGE_SCANOUT |
-                             PIPE_TEXTURE_USAGE_SHARED)) {
+   if (ct->base.bind & (PIPE_BIND_DISPLAY_TARGET |
+                        PIPE_BIND_SCANOUT |
+                        PIPE_BIND_SHARED)) {
       if (!cell_displaytarget_layout(screen, ct))
          goto fail;
    }
 
-   if (!cell_texture_layout(screen, ct))
+   if (!cell_resource_layout(screen, ct))
       goto fail;
 
    return &ct->base;
@@ -155,18 +155,19 @@ fail:
 
 
 static void
-cell_texture_destroy(struct pipe_texture *pt)
+cell_resource_destroy(struct pipe_resource *pt)
 {
    struct cell_screen *screen = cell_screen(pt->screen);
    struct sw_winsys *winsys = screen->winsys;
-   struct cell_texture *ct = cell_texture(pt);
+   struct cell_resource *ct = cell_resource(pt);
 
    if (ct->dt) {
       /* display target */
       winsys->displaytarget_destroy(winsys, ct->dt);
    }
-
-   align_free(ct->data);
+   else if (!ct->userBuffer) {
+      align_free(ct->data);
+   }
 
    FREE(ct);
 }
@@ -304,17 +305,17 @@ untwiddle_image_uint(uint w, uint h, uint tile_size, uint *dst,
 
 static struct pipe_surface *
 cell_get_tex_surface(struct pipe_screen *screen,
-                     struct pipe_texture *pt,
+                     struct pipe_resource *pt,
                      unsigned face, unsigned level, unsigned zslice,
                      unsigned usage)
 {
-   struct cell_texture *ct = cell_texture(pt);
+   struct cell_resource *ct = cell_resource(pt);
    struct pipe_surface *ps;
 
    ps = CALLOC_STRUCT(pipe_surface);
    if (ps) {
       pipe_reference_init(&ps->reference, 1);
-      pipe_texture_reference(&ps->texture, pt);
+      pipe_resource_reference(&ps->texture, pt);
       ps->format = pt->format;
       ps->width = u_minify(pt->width0, level);
       ps->height = u_minify(pt->height0, level);
@@ -345,7 +346,7 @@ cell_get_tex_surface(struct pipe_screen *screen,
 static void 
 cell_tex_surface_destroy(struct pipe_surface *surf)
 {
-   pipe_texture_reference(&surf->texture, NULL);
+   pipe_resource_reference(&surf->texture, NULL);
    FREE(surf);
 }
 
@@ -356,46 +357,48 @@ cell_tex_surface_destroy(struct pipe_surface *surf)
  * back out for glGetTexImage).
  */
 static struct pipe_transfer *
-cell_get_tex_transfer(struct pipe_context *ctx,
-                      struct pipe_texture *texture,
-                      unsigned face, unsigned level, unsigned zslice,
-                      enum pipe_transfer_usage usage,
-                      unsigned x, unsigned y, unsigned w, unsigned h)
+cell_get_transfer(struct pipe_context *ctx,
+		  struct pipe_resource *resource,
+		  struct pipe_subresource sr,
+		  unsigned usage,
+		  const struct pipe_box *box)
 {
-   struct cell_texture *ct = cell_texture(texture);
+   struct cell_resource *ct = cell_resource(resource);
    struct cell_transfer *ctrans;
+   enum pipe_format *format = resource->format;
+
+   assert(resource);
+   assert(level <= resource->last_level);
 
-   assert(texture);
-   assert(level <= texture->last_level);
+   /* make sure the requested region is in the image bounds */
+   assert(box->x + box->width <= u_minify(resource->width0, sr.level));
+   assert(box->y + box->height <= u_minify(resource->height0, sr.level));
+   assert(box->z + box->depth <= u_minify(resource->depth0, sr.level));
 
    ctrans = CALLOC_STRUCT(cell_transfer);
    if (ctrans) {
       struct pipe_transfer *pt = &ctrans->base;
-      pipe_texture_reference(&pt->texture, texture);
-      pt->x = x;
-      pt->y = y;
-      pt->width = w;
-      pt->height = h;
-      pt->stride = ct->stride[level];
+      pipe_resource_reference(&pt->resource, resource);
+      pt->sr = sr;
       pt->usage = usage;
-      pt->face = face;
-      pt->level = level;
-      pt->zslice = zslice;
+      pt->box = *box;
+      pt->stride = ct->stride[sr.level];
 
-      ctrans->offset = ct->level_offset[level];
+      ctrans->offset = ct->level_offset[sr.level];
 
-      if (texture->target == PIPE_TEXTURE_CUBE) {
-         unsigned h_tile = align(u_minify(texture->height0, level), TILE_SIZE);
-         ctrans->offset += face * util_format_get_nblocksy(texture->format, h_tile) * pt->stride;
+      if (resource->target == PIPE_TEXTURE_CUBE) {
+         unsigned h_tile = align(u_minify(resource->height0, sr.level), TILE_SIZE);
+         ctrans->offset += sr.face * util_format_get_nblocksy(format, h_tile) * pt->stride;
       }
-      else if (texture->target == PIPE_TEXTURE_3D) {
-         unsigned h_tile = align(u_minify(texture->height0, level), TILE_SIZE);
-         ctrans->offset += zslice * util_format_get_nblocksy(texture->format, h_tile) * pt->stride;
+      else if (resource->target == PIPE_TEXTURE_3D) {
+         unsigned h_tile = align(u_minify(resource->height0, sr.level), TILE_SIZE);
+         ctrans->offset += box->z * util_format_get_nblocksy(format, h_tile) * pt->stride;
       }
       else {
-         assert(face == 0);
-         assert(zslice == 0);
+         assert(sr.face == 0);
+         assert(box->z == 0);
       }
+
       return pt;
    }
    return NULL;
@@ -403,15 +406,15 @@ cell_get_tex_transfer(struct pipe_context *ctx,
 
 
 static void 
-cell_tex_transfer_destroy(struct pipe_context *ctx, struct pipe_transfer *t)
+cell_transfer_destroy(struct pipe_context *ctx, struct pipe_transfer *t)
 {
    struct cell_transfer *transfer = cell_transfer(t);
    /* Effectively do the texture_update work here - if texture images
     * needed post-processing to put them into hardware layout, this is
     * where it would happen.  For cell, nothing to do.
     */
-   assert (transfer->base.texture);
-   pipe_texture_reference(&transfer->base.texture, NULL);
+   assert (transfer->base.resource);
+   pipe_resource_reference(&transfer->base.resource, NULL);
    FREE(transfer);
 }
 
@@ -423,44 +426,63 @@ static void *
 cell_transfer_map(struct pipe_context *ctx, struct pipe_transfer *transfer)
 {
    struct cell_transfer *ctrans = cell_transfer(transfer);
-   struct pipe_texture *pt = transfer->texture;
-   struct cell_texture *ct = cell_texture(pt);
-   const uint level = ctrans->base.level;
-   const uint texWidth = u_minify(pt->width0, level);
-   const uint texHeight = u_minify(pt->height0, level);
-   const uint stride = ct->stride[level];
-   unsigned size;
+   struct pipe_resource *pt = transfer->resource;
+   struct cell_resource *ct = cell_resource(pt);
 
-   assert(transfer->texture);
+   assert(transfer->resource);
 
    if (ct->mapped == NULL) {
       ct->mapped = ct->data;
    }
 
-   /*
-    * Create a buffer of ordinary memory for the linear texture.
-    * This is the memory that the user will read/write.
+
+   /* Better test would be resource->is_linear
     */
-   size = util_format_get_stride(pt->format, align(texWidth, TILE_SIZE)) *
-          util_format_get_nblocksy(pt->format, align(texHeight, TILE_SIZE));
-
-   ctrans->map = align_malloc(size, 16);
-   if (!ctrans->map)
-      return NULL; /* out of memory */
-
-   if (transfer->usage & PIPE_TRANSFER_READ) {
-      /* need to untwiddle the texture to make a linear version */
-      const uint bpp = util_format_get_blocksize(ct->base.format);
-      if (bpp == 4) {
-         const uint *src = (uint *) (ct->mapped + ctrans->offset);
-         uint *dst = ctrans->map;
-         untwiddle_image_uint(texWidth, texHeight, TILE_SIZE,
-                              dst, stride, src);
-      }
-      else {
-         // xxx fix
+   if (transfer->resource->target != PIPE_BUFFER) {
+      const uint level = ctrans->base.sr.level;
+      const uint texWidth = u_minify(pt->width0, level);
+      const uint texHeight = u_minify(pt->height0, level);
+      unsigned size;
+
+
+      /*
+       * Create a buffer of ordinary memory for the linear texture.
+       * This is the memory that the user will read/write.
+       */
+      size = (util_format_get_stride(pt->format, align(texWidth, TILE_SIZE)) *
+	      util_format_get_nblocksy(pt->format, align(texHeight, TILE_SIZE)));
+
+      ctrans->map = align_malloc(size, 16);
+      if (!ctrans->map)
+	 return NULL; /* out of memory */
+
+      if (transfer->usage & PIPE_TRANSFER_READ) {
+	 /* Textures always stored twiddled, need to untwiddle the
+	  * texture to make a linear version.
+	  */
+	 const uint bpp = util_format_get_blocksize(ct->base.format);
+	 if (bpp == 4) {
+	    const uint *src = (uint *) (ct->mapped + ctrans->offset);
+	    uint *dst = ctrans->map;
+	    untwiddle_image_uint(texWidth, texHeight, TILE_SIZE,
+				 dst, transfer->stride, src);
+	 }
+	 else {
+	    // xxx fix
+	 }
       }
    }
+   else {
+      unsigned stride = transfer->stride;
+      enum pipe_format format = pt->format;
+      unsigned blocksize = util_format_get_blocksize(format);
+
+      ctrans->map = (ct->mapped + 
+		     ctrans->offset +
+		     ctrans->base.box.y / util_format_get_blockheight(format) * stride +
+		     ctrans->base.box.x / util_format_get_blockwidth(format) * blocksize);
+   }
+
 
    return ctrans->map;
 }
@@ -476,9 +498,9 @@ cell_transfer_unmap(struct pipe_context *ctx,
                     struct pipe_transfer *transfer)
 {
    struct cell_transfer *ctrans = cell_transfer(transfer);
-   struct pipe_texture *pt = transfer->texture;
-   struct cell_texture *ct = cell_texture(pt);
-   const uint level = ctrans->base.level;
+   struct pipe_resource *pt = transfer->resource;
+   struct cell_resource *ct = cell_resource(pt);
+   const uint level = ctrans->base.sr.level;
    const uint texWidth = u_minify(pt->width0, level);
    const uint texHeight = u_minify(pt->height0, level);
    const uint stride = ct->stride[level];
@@ -488,22 +510,28 @@ cell_transfer_unmap(struct pipe_context *ctx,
       return;
    }
 
-   if (transfer->usage & PIPE_TRANSFER_WRITE) {
-      /* The user wrote new texture data into the mapped buffer.
-       * We need to convert the new linear data into the twiddled/tiled format.
-       */
-      const uint bpp = util_format_get_blocksize(ct->base.format);
-      if (bpp == 4) {
-         const uint *src = ctrans->map;
-         uint *dst = (uint *) (ct->mapped + ctrans->offset);
-         twiddle_image_uint(texWidth, texHeight, TILE_SIZE, dst, stride, src);
-      }
-      else {
-         // xxx fix
+   if (pt->target != PIPE_BUFFER) {
+      if (transfer->usage & PIPE_TRANSFER_WRITE) {
+	 /* The user wrote new texture data into the mapped buffer.
+	  * We need to convert the new linear data into the twiddled/tiled format.
+	  */
+	 const uint bpp = util_format_get_blocksize(ct->base.format);
+	 if (bpp == 4) {
+	    const uint *src = ctrans->map;
+	    uint *dst = (uint *) (ct->mapped + ctrans->offset);
+	    twiddle_image_uint(texWidth, texHeight, TILE_SIZE, dst, stride, src);
+	 }
+	 else {
+	    // xxx fix
+	 }
       }
+      
+      align_free(ctrans->map);
+   }
+   else {
+      /* nothing to do */
    }
 
-   align_free(ctrans->map);
    ctrans->map = NULL;
 }
 
@@ -525,7 +553,7 @@ cell_flush_frontbuffer(struct pipe_screen *_screen,
 {
    struct cell_screen *screen = cell_screen(_screen);
    struct sw_winsys *winsys = screen->winsys;
-   struct cell_texture *ct = cell_texture(surface->texture);
+   struct cell_resource *ct = cell_resource(surface->texture);
 
    if (!ct->dt)
       return;
@@ -534,8 +562,8 @@ cell_flush_frontbuffer(struct pipe_screen *_screen,
     */
    {
       unsigned *map = winsys->displaytarget_map(winsys, ct->dt,
-                                                (PIPE_BUFFER_USAGE_CPU_READ |
-                                                 PIPE_BUFFER_USAGE_CPU_WRITE));
+                                                (PIPE_TRANSFER_READ |
+                                                 PIPE_TRANSFER_WRITE));
       unsigned *src = (unsigned *)(ct->data + ct->level_offset[surface->level]);
 
       untwiddle_image_uint(surface->width,
@@ -552,11 +580,48 @@ cell_flush_frontbuffer(struct pipe_screen *_screen,
 }
 
 
+
+/**
+ * Create buffer which wraps user-space data.
+ */
+static struct pipe_resource *
+cell_user_buffer_create(struct pipe_screen *screen,
+                            void *ptr,
+                            unsigned bytes,
+			    unsigned bind_flags)
+{
+   struct cell_resource *buffer;
+
+   buffer = CALLOC_STRUCT(cell_resource);
+   if(!buffer)
+      return NULL;
+
+   pipe_reference_init(&buffer->base.reference, 1);
+   buffer->base.screen = screen;
+   buffer->base.format = PIPE_FORMAT_R8_UNORM; /* ?? */
+   buffer->base.bind = PIPE_BIND_TRANSFER_READ | bind_flags;
+   buffer->base._usage = PIPE_USAGE_IMMUTABLE;
+   buffer->base.flags = 0;
+   buffer->base.width0 = bytes;
+   buffer->base.height0 = 1;
+   buffer->base.depth0 = 1;
+   buffer->userBuffer = TRUE;
+   buffer->data = ptr;
+
+   return &buffer->base;
+}
+
+
+
+
 void
 cell_init_screen_texture_funcs(struct pipe_screen *screen)
 {
-   screen->texture_create = cell_texture_create;
-   screen->texture_destroy = cell_texture_destroy;
+   screen->resource_create = cell_resource_create;
+   screen->resource_destroy = cell_resource_destroy;
+   screen->resource_from_handle = cell_resource_from_handle;
+   screen->resource_get_handle = cell_resource_get_handle;
+   screen->user_buffer_create = cell_user_buffer_create;
 
    screen->get_tex_surface = cell_get_tex_surface;
    screen->tex_surface_destroy = cell_tex_surface_destroy;
@@ -565,10 +630,13 @@ cell_init_screen_texture_funcs(struct pipe_screen *screen)
 }
 
 void
-cell_init_texture_transfer_funcs(struct cell_context *cell)
+cell_init_transfer_funcs(struct cell_context *cell)
 {
-   cell->pipe.get_tex_transfer = cell_get_tex_transfer;
-   cell->pipe.tex_transfer_destroy = cell_tex_transfer_destroy;
+   cell->pipe.get_transfer = cell_get_transfer;
+   cell->pipe.transfer_destroy = cell_transfer_destroy;
    cell->pipe.transfer_map = cell_transfer_map;
    cell->pipe.transfer_unmap = cell_transfer_unmap;
+
+   cell->pipe.transfer_flush_region = u_default_transfer_flush_region;
+   cell->pipe.transfer_inline_write = u_default_transfer_inline_write;
 }
diff --git a/src/gallium/drivers/cell/ppu/cell_texture.h b/src/gallium/drivers/cell/ppu/cell_texture.h
index ac0b9167750..bd8224b3b7b 100644
--- a/src/gallium/drivers/cell/ppu/cell_texture.h
+++ b/src/gallium/drivers/cell/ppu/cell_texture.h
@@ -31,21 +31,21 @@
 #include "cell/common.h"
 
 struct cell_context;
-struct pipe_texture;
+struct pipe_resource;
 
 
 /**
- * Subclass of pipe_texture
+ * Subclass of pipe_resource
  */
-struct cell_texture
+struct cell_resource
 {
-   struct pipe_texture base;
+   struct pipe_resource base;
 
    unsigned long level_offset[CELL_MAX_TEXTURE_LEVELS];
    unsigned long stride[CELL_MAX_TEXTURE_LEVELS];
 
    /**
-    * Display target, for textures with the PIPE_TEXTURE_USAGE_DISPLAY_TARGET
+    * Display target, for textures with the PIPE_BIND_DISPLAY_TARGET
     * usage.
     */
    struct sw_displaytarget *dt;
@@ -55,6 +55,7 @@ struct cell_texture
     * Malloc'ed data for regular textures, or a mapping to dt above.
     */
    void *data;
+   boolean userBuffer;
 
    /* Size of the linear buffer??
     */
@@ -77,10 +78,10 @@ struct cell_transfer
 
 
 /** cast wrapper */
-static INLINE struct cell_texture *
-cell_texture(struct pipe_texture *pt)
+static INLINE struct cell_resource *
+cell_resource(struct pipe_resource *pt)
 {
-   return (struct cell_texture *) pt;
+   return (struct cell_resource *) pt;
 }
 
 
diff --git a/src/gallium/drivers/cell/spu/spu_exec.h b/src/gallium/drivers/cell/spu/spu_exec.h
index 0ca92af248d..da9626024e7 100644
--- a/src/gallium/drivers/cell/spu/spu_exec.h
+++ b/src/gallium/drivers/cell/spu/spu_exec.h
@@ -75,7 +75,7 @@ struct softpipe_tile_cache;  /**< Opaque to TGSI */
 struct spu_sampler
 {
    const struct pipe_sampler_state *state;
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    /** Get samples for four fragments in a quad */
    void (*get_samples)(struct spu_sampler *sampler,
                        const float s[QUAD_SIZE],
diff --git a/src/gallium/drivers/failover/fo_context.c b/src/gallium/drivers/failover/fo_context.c
index 659e40cbf03..325a1009541 100644
--- a/src/gallium/drivers/failover/fo_context.c
+++ b/src/gallium/drivers/failover/fo_context.c
@@ -51,7 +51,7 @@ void failover_fail_over( struct failover_context *failover )
 
 
 static void failover_draw_elements( struct pipe_context *pipe,
-                                    struct pipe_buffer *indexBuffer,
+                                    struct pipe_resource *indexResource,
                                     unsigned indexSize,
                                     unsigned prim, 
                                     unsigned start, 
@@ -70,7 +70,7 @@ static void failover_draw_elements( struct pipe_context *pipe,
     */
    if (failover->mode == FO_HW) {
       failover->hw->draw_elements( failover->hw, 
-                                   indexBuffer, 
+                                   indexResource, 
                                    indexSize, 
                                    prim, 
                                    start, 
@@ -87,7 +87,7 @@ static void failover_draw_elements( struct pipe_context *pipe,
       }
 
       failover->sw->draw_elements( failover->sw, 
-				   indexBuffer, 
+				   indexResource, 
 				   indexSize, 
 				   prim, 
 				   start, 
@@ -109,26 +109,15 @@ static void failover_draw_arrays( struct pipe_context *pipe,
 }
 
 static unsigned int
-failover_is_texture_referenced( struct pipe_context *_pipe,
-				struct pipe_texture *texture,
-				unsigned face, unsigned level)
+failover_is_resource_referenced( struct pipe_context *_pipe,
+				 struct pipe_resource *resource,
+				 unsigned face, unsigned level)
 {
    struct failover_context *failover = failover_context( _pipe );
    struct pipe_context *pipe = (failover->mode == FO_HW) ?
       failover->hw : failover->sw;
 
-   return pipe->is_texture_referenced(pipe, texture, face, level);
-}
-
-static unsigned int
-failover_is_buffer_referenced( struct pipe_context *_pipe,
-			       struct pipe_buffer *buf)
-{
-   struct failover_context *failover = failover_context( _pipe );
-   struct pipe_context *pipe = (failover->mode == FO_HW) ?
-      failover->hw : failover->sw;
-
-   return pipe->is_buffer_referenced(pipe, buf);
+   return pipe->is_resource_referenced(pipe, resource, face, level);
 }
 
 struct pipe_context *failover_create( struct pipe_context *hw,
@@ -175,8 +164,7 @@ struct pipe_context *failover_create( struct pipe_context *hw,
 #endif
 
    failover->pipe.flush = hw->flush;
-   failover->pipe.is_texture_referenced = failover_is_texture_referenced;
-   failover->pipe.is_buffer_referenced = failover_is_buffer_referenced;
+   failover->pipe.is_resource_referenced = failover_is_resource_referenced;
 
    failover->dirty = 0;
 
diff --git a/src/gallium/drivers/failover/fo_context.h b/src/gallium/drivers/failover/fo_context.h
index 73031321d98..88ae5ad60d5 100644
--- a/src/gallium/drivers/failover/fo_context.h
+++ b/src/gallium/drivers/failover/fo_context.h
@@ -134,7 +134,7 @@ failover_context( struct pipe_context *pipe )
 void
 failover_set_constant_buffer(struct pipe_context *pipe,
                              uint shader, uint index,
-                             struct pipe_buffer *buf);
+                             struct pipe_resource *resource);
 
 
 #endif /* FO_CONTEXT_H */
diff --git a/src/gallium/drivers/failover/fo_state.c b/src/gallium/drivers/failover/fo_state.c
index 25c62735705..b682ce6750e 100644
--- a/src/gallium/drivers/failover/fo_state.c
+++ b/src/gallium/drivers/failover/fo_state.c
@@ -449,7 +449,7 @@ failover_delete_sampler_state(struct pipe_context *pipe, void *sampler)
 
 static struct pipe_sampler_view *
 failover_create_sampler_view(struct pipe_context *pipe,
-                             struct pipe_texture *texture,
+                             struct pipe_resource *texture,
                              const struct pipe_sampler_view *templ)
 {
    struct fo_sampler_view *view = malloc(sizeof(struct fo_sampler_view));
@@ -461,7 +461,7 @@ failover_create_sampler_view(struct pipe_context *pipe,
    view->base = *templ;
    view->base.reference.count = 1;
    view->base.texture = NULL;
-   pipe_texture_reference(&view->base.texture, texture);
+   pipe_resource_reference(&view->base.texture, texture);
    view->base.context = pipe;
 
    return &view->base;
@@ -477,7 +477,7 @@ failover_sampler_view_destroy(struct pipe_context *pipe,
    failover->sw->sampler_view_destroy(failover->sw, fo_view->sw);
    failover->hw->sampler_view_destroy(failover->hw, fo_view->hw);
 
-   pipe_texture_reference(&fo_view->base.texture, NULL);
+   pipe_resource_reference(&fo_view->base.texture, NULL);
    free(fo_view);
 }
 
@@ -572,15 +572,15 @@ failover_set_vertex_buffers(struct pipe_context *pipe,
 void
 failover_set_constant_buffer(struct pipe_context *pipe,
                              uint shader, uint index,
-                             struct pipe_buffer *buf)
+                             struct pipe_resource *res)
 {
    struct failover_context *failover = failover_context(pipe);
 
    assert(shader < PIPE_SHADER_TYPES);
    assert(index == 0);
 
-   failover->sw->set_constant_buffer(failover->sw, shader, index, buf);
-   failover->hw->set_constant_buffer(failover->hw, shader, index, buf);
+   failover->sw->set_constant_buffer(failover->sw, shader, index, res);
+   failover->hw->set_constant_buffer(failover->hw, shader, index, res);
 }
 
 
diff --git a/src/gallium/drivers/i915/Makefile b/src/gallium/drivers/i915/Makefile
index e33c74d02f7..2cefe708500 100644
--- a/src/gallium/drivers/i915/Makefile
+++ b/src/gallium/drivers/i915/Makefile
@@ -5,7 +5,6 @@ LIBNAME = i915
 
 C_SOURCES = \
 	i915_blit.c \
-	i915_buffer.c \
 	i915_clear.c \
 	i915_flush.c \
 	i915_context.c \
@@ -20,7 +19,9 @@ C_SOURCES = \
 	i915_screen.c \
 	i915_prim_emit.c \
 	i915_prim_vbuf.c \
-	i915_texture.c \
+	i915_resource.c \
+	i915_resource_texture.c \
+	i915_resource_buffer.c \
 	i915_fpc_emit.c \
 	i915_fpc_translate.c \
 	i915_surface.c 
diff --git a/src/gallium/drivers/i915/SConscript b/src/gallium/drivers/i915/SConscript
index 5a1c47c88db..7b69681096d 100644
--- a/src/gallium/drivers/i915/SConscript
+++ b/src/gallium/drivers/i915/SConscript
@@ -6,7 +6,7 @@ i915 = env.ConvenienceLibrary(
 	target = 'i915',
 	source = [
 		'i915_blit.c',
-		'i915_buffer.c',
+		'i915_resource_buffer.c',
 		'i915_clear.c',
 		'i915_context.c',
 		'i915_debug.c',
@@ -24,7 +24,8 @@ i915 = env.ConvenienceLibrary(
 		'i915_state_immediate.c',
 		'i915_state_sampler.c',
 		'i915_surface.c',
-		'i915_texture.c',
+		'i915_resource.c',
+		'i915_resource_texture.c',
 	])
 
 Export('i915')
diff --git a/src/gallium/drivers/i915/i915_buffer.c b/src/gallium/drivers/i915/i915_buffer.c
deleted file mode 100644
index 1247de320d4..00000000000
--- a/src/gallium/drivers/i915/i915_buffer.c
+++ /dev/null
@@ -1,138 +0,0 @@
-/**************************************************************************
- *
- * Copyright © 2009 Jakob Bornecrantz
- *
- * 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, sublicense,
- * 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 NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- *
- **************************************************************************/
-
-#include "util/u_inlines.h"
-#include "util/u_memory.h"
-#include "i915_screen.h"
-#include "i915_buffer.h"
-
-struct i915_winsys_buffer;
-
-struct i915_buffer
-{
-   struct pipe_buffer base;
-
-   struct i915_winsys_buffer *ibuf; /** hw buffer */
-
-   void *data; /**< user and malloc data */
-   boolean own; /**< we own the data incase of malloc */
-};
-
-static INLINE struct i915_buffer *
-i915_buffer(struct pipe_buffer *buffer)
-{
-   return (struct i915_buffer *)buffer;
-}
-
-static struct pipe_buffer *
-i915_buffer_create(struct pipe_screen *screen,
-                   unsigned alignment,
-                   unsigned usage,
-                   unsigned size)
-{
-   struct i915_buffer *buf = CALLOC_STRUCT(i915_buffer);
-
-   if (!buf)
-      return NULL;
-
-   pipe_reference_init(&buf->base.reference, 1);
-   buf->base.alignment = alignment;
-   buf->base.screen = screen;
-   buf->base.usage = usage;
-   buf->base.size = size;
-   buf->data = MALLOC(size);
-   buf->own = TRUE;
-
-   if (!buf->data)
-      goto err;
-
-   return &buf->base;
-
-err:
-   FREE(buf);
-   return NULL;
-}
-
-static struct pipe_buffer *
-i915_user_buffer_create(struct pipe_screen *screen,
-                        void *ptr,
-                        unsigned bytes)
-{
-   struct i915_buffer *buf = CALLOC_STRUCT(i915_buffer);
-
-   if (!buf)
-      return NULL;
-
-   pipe_reference_init(&buf->base.reference, 1);
-   buf->base.alignment = 0;
-   buf->base.screen = screen;
-   buf->base.usage = 0;
-   buf->base.size = bytes;
-   buf->data = ptr;
-   buf->own = FALSE;
-
-   return &buf->base;
-}
-
-static void *
-i915_buffer_map(struct pipe_screen *screen,
-                struct pipe_buffer *buffer,
-                unsigned usage)
-{
-   struct i915_buffer *buf = i915_buffer(buffer);
-   assert(!buf->ibuf);
-   return buf->data;
-}
-
-static void
-i915_buffer_unmap(struct pipe_screen *screen,
-                  struct pipe_buffer *buffer)
-{
-   struct i915_buffer *buf = i915_buffer(buffer);
-   assert(!buf->ibuf);
-   (void) buf;
-}
-
-static void
-i915_buffer_destroy(struct pipe_buffer *buffer)
-{
-   struct i915_buffer *buf = i915_buffer(buffer);
-   assert(!buf->ibuf);
-
-   if (buf->own)
-      FREE(buf->data);
-   FREE(buf);
-}
-
-void i915_init_screen_buffer_functions(struct i915_screen *screen)
-{
-   screen->base.buffer_create = i915_buffer_create;
-   screen->base.user_buffer_create = i915_user_buffer_create;
-   screen->base.buffer_map = i915_buffer_map;
-   screen->base.buffer_map_range = NULL;
-   screen->base.buffer_flush_mapped_range = NULL;
-   screen->base.buffer_unmap = i915_buffer_unmap;
-   screen->base.buffer_destroy = i915_buffer_destroy;
-}
diff --git a/src/gallium/drivers/i915/i915_context.c b/src/gallium/drivers/i915/i915_context.c
index 130519ffa50..4ae52911158 100644
--- a/src/gallium/drivers/i915/i915_context.c
+++ b/src/gallium/drivers/i915/i915_context.c
@@ -28,7 +28,9 @@
 #include "i915_context.h"
 #include "i915_state.h"
 #include "i915_screen.h"
+#include "i915_surface.h"
 #include "i915_batch.h"
+#include "i915_resource.h"
 
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
@@ -44,7 +46,7 @@
 
 static void
 i915_draw_range_elements(struct pipe_context *pipe,
-                         struct pipe_buffer *indexBuffer,
+                         struct pipe_resource *indexBuffer,
                          unsigned indexSize,
                          unsigned min_index,
                          unsigned max_index,
@@ -61,8 +63,7 @@ i915_draw_range_elements(struct pipe_context *pipe,
     * Map vertex buffers
     */
    for (i = 0; i < i915->num_vertex_buffers; i++) {
-      void *buf = pipe_buffer_map(pipe->screen, i915->vertex_buffer[i].buffer,
-                                  PIPE_BUFFER_USAGE_CPU_READ);
+      void *buf = i915_buffer(i915->vertex_buffer[i].buffer)->data;
       draw_set_mapped_vertex_buffer(draw, i, buf);
    }
 
@@ -70,8 +71,7 @@ i915_draw_range_elements(struct pipe_context *pipe,
     * Map index buffer, if present
     */
    if (indexBuffer) {
-      void *mapped_indexes = pipe_buffer_map(pipe->screen, indexBuffer,
-                                             PIPE_BUFFER_USAGE_CPU_READ);
+      void *mapped_indexes = i915_buffer(indexBuffer)->data;
       draw_set_mapped_element_buffer_range(draw, indexSize,
                                            min_index,
                                            max_index,
@@ -95,19 +95,17 @@ i915_draw_range_elements(struct pipe_context *pipe,
     * unmap vertex/index buffers
     */
    for (i = 0; i < i915->num_vertex_buffers; i++) {
-      pipe_buffer_unmap(pipe->screen, i915->vertex_buffer[i].buffer);
       draw_set_mapped_vertex_buffer(draw, i, NULL);
    }
 
    if (indexBuffer) {
-      pipe_buffer_unmap(pipe->screen, indexBuffer);
-      draw_set_mapped_element_buffer_range(draw, 0, start, start + count - 1, NULL);
+      draw_set_mapped_element_buffer(draw, 0, NULL);
    }
 }
 
 static void
 i915_draw_elements(struct pipe_context *pipe,
-                   struct pipe_buffer *indexBuffer,
+                   struct pipe_resource *indexBuffer,
                    unsigned indexSize,
                    unsigned prim, unsigned start, unsigned count)
 {
@@ -125,37 +123,6 @@ i915_draw_arrays(struct pipe_context *pipe,
 }
 
 
-/*
- * Is referenced functions
- */
-
-
-static unsigned int
-i915_is_texture_referenced(struct pipe_context *pipe,
-                           struct pipe_texture *texture,
-                           unsigned face, unsigned level)
-{
-   /**
-    * FIXME: Return the corrent result. We can't alays return referenced
-    *        since it causes a double flush within the vbo module.
-    */
-#if 0
-   return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
-#else
-   return 0;
-#endif
-}
-
-static unsigned int
-i915_is_buffer_referenced(struct pipe_context *pipe,
-                          struct pipe_buffer *buf)
-{
-   /*
-    * Since we never expose hardware buffers to the state tracker
-    * they can never be referenced, so this isn't a lie
-    */
-   return 0;
-}
 
 
 /*
@@ -204,9 +171,6 @@ i915_create_context(struct pipe_screen *screen, void *priv)
    i915->base.draw_elements = i915_draw_elements;
    i915->base.draw_range_elements = i915_draw_range_elements;
 
-   i915->base.is_texture_referenced = i915_is_texture_referenced;
-   i915->base.is_buffer_referenced = i915_is_buffer_referenced;
-
    /*
     * Create drawing context and plug our rendering stage into it.
     */
@@ -221,7 +185,7 @@ i915_create_context(struct pipe_screen *screen, void *priv)
    i915_init_surface_functions(i915);
    i915_init_state_functions(i915);
    i915_init_flush_functions(i915);
-   i915_init_texture_functions(i915);
+   i915_init_resource_functions(i915);
 
    draw_install_aaline_stage(i915->draw, &i915->base);
    draw_install_aapoint_stage(i915->draw, &i915->base);
diff --git a/src/gallium/drivers/i915/i915_context.h b/src/gallium/drivers/i915/i915_context.h
index 8df4dce8653..acc0ffe037f 100644
--- a/src/gallium/drivers/i915/i915_context.h
+++ b/src/gallium/drivers/i915/i915_context.h
@@ -192,35 +192,6 @@ struct i915_velems_state {
    struct pipe_vertex_element velem[PIPE_MAX_ATTRIBS];
 };
 
-#define I915_MAX_TEXTURE_2D_LEVELS 11  /* max 1024x1024 */
-#define I915_MAX_TEXTURE_3D_LEVELS  8  /* max 128x128x128 */
-
-struct i915_texture {
-   struct pipe_texture base;
-
-   /* Derived from the above:
-    */
-   unsigned stride;
-   unsigned depth_stride;          /* per-image on i945? */
-   unsigned total_nblocksy;
-
-   unsigned sw_tiled; /**< tiled with software flags */
-   unsigned hw_tiled; /**< tiled with hardware fences */
-
-   unsigned nr_images[I915_MAX_TEXTURE_2D_LEVELS];
-
-   /* Explicitly store the offset of each image for each cube face or
-    * depth value.  Pretty much have to accept that hardware formats
-    * are going to be so diverse that there is no unified way to
-    * compute the offsets of depth/cube images within a mipmap level,
-    * so have to store them as a lookup table:
-    */
-   unsigned *image_offset[I915_MAX_TEXTURE_2D_LEVELS];   /**< array [depth] of offsets */
-
-   /* The data is held here:
-    */
-   struct i915_winsys_buffer *buffer;
-};
 
 struct i915_context
 {
@@ -243,7 +214,7 @@ struct i915_context
    struct pipe_stencil_ref stencil_ref;
    struct pipe_clip_state clip;
    /* XXX unneded */
-   struct pipe_buffer *constants[PIPE_SHADER_TYPES];
+   struct pipe_resource *constants[PIPE_SHADER_TYPES];
    struct pipe_framebuffer_state framebuffer;
    struct pipe_poly_stipple poly_stipple;
    struct pipe_scissor_state scissor;
@@ -333,10 +304,8 @@ void i915_clear( struct pipe_context *pipe, unsigned buffers, const float *rgba,
 
 
 /***********************************************************************
- * i915_surface.c: 
+ * 
  */
-void i915_init_surface_functions( struct i915_context *i915 );
-
 void i915_init_state_functions( struct i915_context *i915 );
 void i915_init_flush_functions( struct i915_context *i915 );
 void i915_init_string_functions( struct i915_context *i915 );
@@ -349,10 +318,6 @@ struct pipe_context *i915_create_context(struct pipe_screen *screen,
 					 void *priv);
 
 
-/***********************************************************************
- * i915_texture.c
- */
-void i915_init_texture_functions(struct i915_context *i915 );
 
 
 /***********************************************************************
diff --git a/src/gallium/drivers/i915/i915_fpc_emit.c b/src/gallium/drivers/i915/i915_fpc_emit.c
index b054ce41d39..76c24d2b2fd 100644
--- a/src/gallium/drivers/i915/i915_fpc_emit.c
+++ b/src/gallium/drivers/i915/i915_fpc_emit.c
@@ -243,7 +243,7 @@ uint i915_emit_texld( struct i915_fp_compile *p,
    }
    else {
       assert(GET_UREG_TYPE(dest) != REG_TYPE_CONST);
-      assert(dest = UREG(GET_UREG_TYPE(dest), GET_UREG_NR(dest)));
+      assert(dest == UREG(GET_UREG_TYPE(dest), GET_UREG_NR(dest)));
 
       /* is the sampler coord a texcoord input reg? */
       if (GET_UREG_TYPE(coord) != REG_TYPE_T) {
diff --git a/src/gallium/drivers/i915/i915_resource.c b/src/gallium/drivers/i915/i915_resource.c
new file mode 100644
index 00000000000..499233ceb9b
--- /dev/null
+++ b/src/gallium/drivers/i915/i915_resource.c
@@ -0,0 +1,51 @@
+#include "util/u_debug.h"
+
+#include "i915_resource.h"
+#include "i915_context.h"
+#include "i915_screen.h"
+
+
+static struct pipe_resource *
+i915_resource_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template)
+{
+   if (template->target == PIPE_BUFFER)
+      return i915_buffer_create(screen, template);
+   else
+      return i915_texture_create(screen, template);
+
+}
+
+static struct pipe_resource *
+i915_resource_from_handle(struct pipe_screen * screen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle)
+{
+   if (template->target == PIPE_BUFFER)
+      return NULL;
+   else
+      return i915_texture_from_handle(screen, template, whandle);
+}
+
+
+void
+i915_init_resource_functions(struct i915_context *i915 )
+{
+   i915->base.is_resource_referenced = u_default_is_resource_referenced;
+   i915->base.get_transfer = u_get_transfer_vtbl;
+   i915->base.transfer_map = u_transfer_map_vtbl;
+   i915->base.transfer_flush_region = u_transfer_flush_region_vtbl;
+   i915->base.transfer_unmap = u_transfer_unmap_vtbl;
+   i915->base.transfer_destroy = u_transfer_destroy_vtbl;
+   i915->base.transfer_inline_write = u_transfer_inline_write_vtbl;
+}
+
+void
+i915_init_screen_resource_functions(struct i915_screen *is)
+{
+   is->base.resource_create = i915_resource_create;
+   is->base.resource_from_handle = i915_resource_from_handle;
+   is->base.resource_get_handle = u_resource_get_handle_vtbl;
+   is->base.resource_destroy = u_resource_destroy_vtbl;
+   is->base.user_buffer_create = i915_user_buffer_create;
+}
diff --git a/src/gallium/drivers/i915/i915_resource.h b/src/gallium/drivers/i915/i915_resource.h
new file mode 100644
index 00000000000..1093e8f41f9
--- /dev/null
+++ b/src/gallium/drivers/i915/i915_resource.h
@@ -0,0 +1,114 @@
+/**************************************************************************
+ * 
+ * Copyright 2008 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 I915_RESOURCE_H
+#define I915_RESOURCE_H
+
+struct i915_screen;
+
+#include "util/u_transfer.h"
+#include "util/u_debug.h"
+
+
+struct i915_context;
+struct i915_screen;
+
+
+struct i915_buffer {
+   struct u_resource b;
+   uint8_t *data;
+   boolean free_on_destroy;
+};
+
+#define I915_MAX_TEXTURE_2D_LEVELS 11  /* max 1024x1024 */
+#define I915_MAX_TEXTURE_3D_LEVELS  8  /* max 128x128x128 */
+
+
+
+struct i915_texture {
+   struct u_resource b;
+
+   unsigned stride;
+   unsigned depth_stride;          /* per-image on i945? */
+   unsigned total_nblocksy;
+
+   unsigned sw_tiled; /**< tiled with software flags */
+   unsigned hw_tiled; /**< tiled with hardware fences */
+
+   unsigned nr_images[I915_MAX_TEXTURE_2D_LEVELS];
+
+   /* Explicitly store the offset of each image for each cube face or
+    * depth value.
+    */
+   unsigned *image_offset[I915_MAX_TEXTURE_2D_LEVELS];   /**< array [depth] of offsets */
+
+   /* The data is held here:
+    */
+   struct i915_winsys_buffer *buffer;
+};
+
+void i915_init_screen_resource_functions(struct i915_screen *is);
+void i915_init_resource_functions(struct i915_context *i915);
+
+extern struct u_resource_vtbl i915_buffer_vtbl;
+extern struct u_resource_vtbl i915_texture_vtbl;
+
+static INLINE struct i915_texture *i915_texture(struct pipe_resource *resource)
+{
+   struct i915_texture *tex = (struct i915_texture *)resource;
+   assert(tex->b.vtbl == &i915_texture_vtbl);
+   return tex;
+}
+
+static INLINE struct i915_buffer *i915_buffer(struct pipe_resource *resource)
+{
+   struct i915_buffer *tex = (struct i915_buffer *)resource;
+   assert(tex->b.vtbl == &i915_buffer_vtbl);
+   return tex;
+}
+
+struct pipe_resource *
+i915_texture_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template);
+
+struct pipe_resource *
+i915_texture_from_handle(struct pipe_screen * screen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle);
+
+
+struct pipe_resource *
+i915_user_buffer_create(struct pipe_screen *screen,
+                        void *ptr,
+                        unsigned bytes,
+			unsigned usage);
+
+struct pipe_resource *
+i915_buffer_create(struct pipe_screen *screen,
+		   const struct pipe_resource *template);
+
+#endif /* I915_RESOURCE_H */
diff --git a/src/gallium/drivers/i915/i915_resource_buffer.c b/src/gallium/drivers/i915/i915_resource_buffer.c
new file mode 100644
index 00000000000..d2f8afeee7c
--- /dev/null
+++ b/src/gallium/drivers/i915/i915_resource_buffer.c
@@ -0,0 +1,161 @@
+/**************************************************************************
+ * 
+ * Copyright 2006 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.
+ * 
+ **************************************************************************/
+ /*
+  * Authors:
+  *   Keith Whitwell <keith@tungstengraphics.com>
+  *   Michel Dänzer <michel@tungstengraphics.com>
+  */
+
+#include "pipe/p_context.h"
+#include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+
+#include "i915_context.h"
+#include "i915_resource.h"
+
+
+
+static boolean
+i915_buffer_get_handle(struct pipe_screen *screen,
+		       struct pipe_resource *resource,
+		       struct winsys_handle *handle)
+{
+   return FALSE;
+}
+
+static void
+i915_buffer_destroy(struct pipe_screen *screen,
+		    struct pipe_resource *resource)
+{
+   struct i915_buffer *buffer = i915_buffer(resource);
+   if (buffer->free_on_destroy)
+      align_free(buffer->data);
+   FREE(buffer);
+}
+
+
+static void *
+i915_buffer_transfer_map( struct pipe_context *pipe,
+			  struct pipe_transfer *transfer )
+{
+   struct i915_buffer *buffer = i915_buffer(transfer->resource);
+   return buffer->data + transfer->box.x;
+}
+
+
+static void
+i915_buffer_transfer_inline_write( struct pipe_context *rm_ctx,
+				   struct pipe_resource *resource,
+				   struct pipe_subresource sr,
+				   unsigned usage,
+				   const struct pipe_box *box,
+				   const void *data,
+				   unsigned stride,
+				   unsigned slice_stride)
+{
+   struct i915_buffer *buffer = i915_buffer(resource);
+
+   memcpy(buffer->data + box->x,
+	  data,
+	  box->width);
+}
+
+
+struct u_resource_vtbl i915_buffer_vtbl = 
+{
+   i915_buffer_get_handle,	     /* get_handle */
+   i915_buffer_destroy,		     /* resource_destroy */
+   NULL,			     /* is_resource_referenced */
+   u_default_get_transfer,	     /* get_transfer */
+   u_default_transfer_destroy,	     /* transfer_destroy */
+   i915_buffer_transfer_map,	     /* transfer_map */
+   u_default_transfer_flush_region,  /* transfer_flush_region */
+   u_default_transfer_unmap,	     /* transfer_unmap */
+   i915_buffer_transfer_inline_write /* transfer_inline_write */
+};
+
+
+
+struct pipe_resource *
+i915_buffer_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template)
+{
+   struct i915_buffer *buf = CALLOC_STRUCT(i915_buffer);
+
+   if (!buf)
+      return NULL;
+
+   buf->b.b = *template;
+   buf->b.vtbl = &i915_buffer_vtbl;
+   pipe_reference_init(&buf->b.b.reference, 1);
+   buf->b.b.screen = screen;
+   
+   buf->data = MALLOC(template->width0);
+   buf->free_on_destroy = TRUE;
+
+   if (!buf->data)
+      goto err;
+
+   return &buf->b.b;
+
+err:
+   FREE(buf);
+   return NULL;
+}
+
+
+
+struct pipe_resource *
+i915_user_buffer_create(struct pipe_screen *screen,
+                        void *ptr,
+                        unsigned bytes,
+			unsigned bind)
+{
+   struct i915_buffer *buf = CALLOC_STRUCT(i915_buffer);
+
+   if (!buf)
+      return NULL;
+
+   pipe_reference_init(&buf->b.b.reference, 1);
+   buf->b.vtbl = &i915_buffer_vtbl;
+   buf->b.b.screen = screen;
+   buf->b.b.format = PIPE_FORMAT_R8_UNORM; /* ?? */
+   buf->b.b._usage = PIPE_USAGE_IMMUTABLE;
+   buf->b.b.bind = bind;
+   buf->b.b.flags = 0;
+   buf->b.b.width0 = bytes;
+   buf->b.b.height0 = 1;
+   buf->b.b.depth0 = 1;
+
+   buf->data = ptr;
+   buf->free_on_destroy = FALSE;
+
+   return &buf->b.b;
+}
diff --git a/src/gallium/drivers/i915/i915_texture.c b/src/gallium/drivers/i915/i915_resource_texture.c
index 8c405c2443e..144671228d6 100644
--- a/src/gallium/drivers/i915/i915_texture.c
+++ b/src/gallium/drivers/i915/i915_resource_texture.c
@@ -39,7 +39,7 @@
 #include "util/u_memory.h"
 
 #include "i915_context.h"
-#include "i915_texture.h"
+#include "i915_resource.h"
 #include "i915_screen.h"
 #include "i915_winsys.h"
 
@@ -91,10 +91,10 @@ power_of_two(unsigned x)
 
 
 static void
-i915_miptree_set_level_info(struct i915_texture *tex,
-                             unsigned level,
-                             unsigned nr_images,
-                             unsigned w, unsigned h, unsigned d)
+i915_texture_set_level_info(struct i915_texture *tex,
+                            unsigned level,
+                            unsigned nr_images,
+                            unsigned w, unsigned h, unsigned d)
 {
    assert(level < Elements(tex->nr_images));
 
@@ -120,7 +120,7 @@ i915_miptree_set_level_info(struct i915_texture *tex,
 }
 
 static void
-i915_miptree_set_image_offset(struct i915_texture *tex,
+i915_texture_set_image_offset(struct i915_texture *tex,
                               unsigned level, unsigned img, unsigned x, unsigned y)
 {
    if (img == 0 && level == 0)
@@ -128,7 +128,7 @@ i915_miptree_set_image_offset(struct i915_texture *tex,
 
    assert(img < tex->nr_images[level]);
 
-   tex->image_offset[level][img] = y * tex->stride + x * util_format_get_blocksize(tex->base.format);
+   tex->image_offset[level][img] = y * tex->stride + x * util_format_get_blocksize(tex->b.b.format);
 
    /*
    printf("%s level %d img %d pos %d,%d image_offset %x\n",
@@ -138,7 +138,7 @@ i915_miptree_set_image_offset(struct i915_texture *tex,
 
 
 /*
- * i915 layout functions, some used by i945
+ * Shared layout functions
  */
 
 
@@ -146,18 +146,18 @@ i915_miptree_set_image_offset(struct i915_texture *tex,
  * Special case to deal with scanout textures.
  */
 static boolean
-i915_scanout_layout(struct i915_texture *tex)
+i9x5_scanout_layout(struct i915_texture *tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
 
    if (pt->last_level > 0 || util_format_get_blocksize(pt->format) != 4)
       return FALSE;
 
-   i915_miptree_set_level_info(tex, 0, 1,
+   i915_texture_set_level_info(tex, 0, 1,
                                pt->width0,
                                pt->height0,
                                1);
-   i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
+   i915_texture_set_image_offset(tex, 0, 0, 0, 0);
 
    if (pt->width0 >= 240) {
       tex->stride = power_of_two(util_format_get_stride(pt->format, pt->width0));
@@ -181,9 +181,9 @@ i915_scanout_layout(struct i915_texture *tex)
  * Special case to deal with shared textures.
  */
 static boolean
-i915_display_target_layout(struct i915_texture *tex)
+i9x5_display_target_layout(struct i915_texture *tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
 
    if (pt->last_level > 0 || util_format_get_blocksize(pt->format) != 4)
       return FALSE;
@@ -192,11 +192,11 @@ i915_display_target_layout(struct i915_texture *tex)
    if (pt->width0 < 240)
       return FALSE;
 
-   i915_miptree_set_level_info(tex, 0, 1,
+   i915_texture_set_level_info(tex, 0, 1,
                                pt->width0,
                                pt->height0,
                                1);
-   i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
+   i915_texture_set_image_offset(tex, 0, 0, 0, 0);
 
    tex->stride = power_of_two(util_format_get_stride(pt->format, pt->width0));
    tex->total_nblocksy = align(util_format_get_nblocksy(pt->format, pt->height0), 8);
@@ -209,31 +209,42 @@ i915_display_target_layout(struct i915_texture *tex)
    return TRUE;
 }
 
+
+/*
+ * i915 layout functions
+ */
+
+
 static void
-i915_miptree_layout_2d(struct i915_texture *tex)
+i915_texture_layout_2d(struct i915_texture *tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
    unsigned level;
    unsigned width = pt->width0;
    unsigned height = pt->height0;
    unsigned nblocksy = util_format_get_nblocksy(pt->format, pt->width0);
 
    /* used for scanouts that need special layouts */
-   if (pt->tex_usage & PIPE_TEXTURE_USAGE_SCANOUT)
-      if (i915_scanout_layout(tex))
+   if (pt->bind & PIPE_BIND_SCANOUT)
+      if (i9x5_scanout_layout(tex))
          return;
 
-   /* shared buffers needs to be compatible with X servers */
-   if (pt->tex_usage & PIPE_TEXTURE_USAGE_SHARED)
-      if (i915_display_target_layout(tex))
+   /* shared buffers needs to be compatible with X servers 
+    * 
+    * XXX: need a better name than shared for this if it is to be part
+    * of core gallium, and probably move the flag to resource.flags,
+    * rather than bindings.
+    */
+   if (pt->bind & (PIPE_BIND_SHARED | PIPE_BIND_DISPLAY_TARGET))
+      if (i9x5_display_target_layout(tex))
          return;
 
    tex->stride = align(util_format_get_stride(pt->format, pt->width0), 4);
    tex->total_nblocksy = 0;
 
    for (level = 0; level <= pt->last_level; level++) {
-      i915_miptree_set_level_info(tex, level, 1, width, height, 1);
-      i915_miptree_set_image_offset(tex, level, 0, 0, tex->total_nblocksy);
+      i915_texture_set_level_info(tex, level, 1, width, height, 1);
+      i915_texture_set_image_offset(tex, level, 0, 0, tex->total_nblocksy);
 
       nblocksy = align(MAX2(2, nblocksy), 2);
 
@@ -246,9 +257,9 @@ i915_miptree_layout_2d(struct i915_texture *tex)
 }
 
 static void
-i915_miptree_layout_3d(struct i915_texture *tex)
+i915_texture_layout_3d(struct i915_texture *tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
    unsigned level;
 
    unsigned width = pt->width0;
@@ -264,7 +275,7 @@ i915_miptree_layout_3d(struct i915_texture *tex)
    /* XXX: hardware expects/requires 9 levels at minimum.
     */
    for (level = 0; level <= MAX2(8, pt->last_level); level++) {
-      i915_miptree_set_level_info(tex, level, depth, width, height, depth);
+      i915_texture_set_level_info(tex, level, depth, width, height, depth);
 
       stack_nblocksy += MAX2(2, nblocksy);
 
@@ -278,7 +289,7 @@ i915_miptree_layout_3d(struct i915_texture *tex)
    for (level = 0; level <= pt->last_level; level++) {
       unsigned i;
       for (i = 0; i < depth; i++) 
-         i915_miptree_set_image_offset(tex, level, i, 0, i * stack_nblocksy);
+         i915_texture_set_image_offset(tex, level, i, 0, i * stack_nblocksy);
 
       depth = u_minify(depth, 1);
    }
@@ -291,9 +302,9 @@ i915_miptree_layout_3d(struct i915_texture *tex)
 }
 
 static void
-i915_miptree_layout_cube(struct i915_texture *tex)
+i915_texture_layout_cube(struct i915_texture *tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
    unsigned width = pt->width0, height = pt->height0;
    const unsigned nblocks = util_format_get_nblocksx(pt->format, pt->width0);
    unsigned level;
@@ -306,7 +317,7 @@ i915_miptree_layout_cube(struct i915_texture *tex)
    tex->total_nblocksy = nblocks * 4;
 
    for (level = 0; level <= pt->last_level; level++) {
-      i915_miptree_set_level_info(tex, level, 6, width, height, 1);
+      i915_texture_set_level_info(tex, level, 6, width, height, 1);
       width /= 2;
       height /= 2;
    }
@@ -317,7 +328,7 @@ i915_miptree_layout_cube(struct i915_texture *tex)
       unsigned d = nblocks;
 
       for (level = 0; level <= pt->last_level; level++) {
-         i915_miptree_set_image_offset(tex, level, face, x, y);
+         i915_texture_set_image_offset(tex, level, face, x, y);
          d >>= 1;
          x += step_offsets[face][0] * d;
          y += step_offsets[face][1] * d;
@@ -326,20 +337,20 @@ i915_miptree_layout_cube(struct i915_texture *tex)
 }
 
 static boolean
-i915_miptree_layout(struct i915_texture * tex)
+i915_texture_layout(struct i915_texture * tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
 
    switch (pt->target) {
    case PIPE_TEXTURE_1D:
    case PIPE_TEXTURE_2D:
-      i915_miptree_layout_2d(tex);
+      i915_texture_layout_2d(tex);
       break;
    case PIPE_TEXTURE_3D:
-      i915_miptree_layout_3d(tex);
+      i915_texture_layout_3d(tex);
       break;
    case PIPE_TEXTURE_CUBE:
-      i915_miptree_layout_cube(tex);
+      i915_texture_layout_cube(tex);
       break;
    default:
       assert(0);
@@ -356,9 +367,9 @@ i915_miptree_layout(struct i915_texture * tex)
 
 
 static void
-i945_miptree_layout_2d(struct i915_texture *tex)
+i945_texture_layout_2d(struct i915_texture *tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
    const int align_x = 2, align_y = 4;
    unsigned level;
    unsigned x = 0;
@@ -369,13 +380,13 @@ i945_miptree_layout_2d(struct i915_texture *tex)
    unsigned nblocksy = util_format_get_nblocksy(pt->format, pt->height0);
 
    /* used for scanouts that need special layouts */
-   if (tex->base.tex_usage & PIPE_TEXTURE_USAGE_SCANOUT)
-      if (i915_scanout_layout(tex))
+   if (tex->b.b.bind & PIPE_BIND_SCANOUT)
+      if (i9x5_scanout_layout(tex))
          return;
 
    /* shared buffers needs to be compatible with X servers */
-   if (tex->base.tex_usage & PIPE_TEXTURE_USAGE_SHARED)
-      if (i915_display_target_layout(tex))
+   if (tex->b.b.bind & (PIPE_BIND_SHARED | PIPE_BIND_DISPLAY_TARGET))
+      if (i9x5_display_target_layout(tex))
          return;
 
    tex->stride = align(util_format_get_stride(pt->format, pt->width0), 4);
@@ -400,8 +411,8 @@ i945_miptree_layout_2d(struct i915_texture *tex)
    tex->total_nblocksy = 0;
 
    for (level = 0; level <= pt->last_level; level++) {
-      i915_miptree_set_level_info(tex, level, 1, width, height, 1);
-      i915_miptree_set_image_offset(tex, level, 0, x, y);
+      i915_texture_set_level_info(tex, level, 1, width, height, 1);
+      i915_texture_set_image_offset(tex, level, 0, x, y);
 
       nblocksy = align(nblocksy, align_y);
 
@@ -414,8 +425,7 @@ i945_miptree_layout_2d(struct i915_texture *tex)
        */
       if (level == 1) {
          x += align(nblocksx, align_x);
-      }
-      else {
+      } else {
          y += nblocksy;
       }
 
@@ -427,9 +437,9 @@ i945_miptree_layout_2d(struct i915_texture *tex)
 }
 
 static void
-i945_miptree_layout_3d(struct i915_texture *tex)
+i945_texture_layout_3d(struct i915_texture *tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
    unsigned width = pt->width0;
    unsigned height = pt->height0;
    unsigned depth = pt->depth0;
@@ -450,11 +460,11 @@ i945_miptree_layout_3d(struct i915_texture *tex)
       int y = 0;
       unsigned q, j;
 
-      i915_miptree_set_level_info(tex, level, depth, width, height, depth);
+      i915_texture_set_level_info(tex, level, depth, width, height, depth);
 
       for (q = 0; q < depth;) {
          for (j = 0; j < pack_x_nr && q < depth; j++, q++) {
-            i915_miptree_set_image_offset(tex, level, q, x, y + tex->total_nblocksy);
+            i915_texture_set_image_offset(tex, level, q, x, y + tex->total_nblocksy);
             x += pack_x_pitch;
          }
 
@@ -482,9 +492,9 @@ i945_miptree_layout_3d(struct i915_texture *tex)
 }
 
 static void
-i945_miptree_layout_cube(struct i915_texture *tex)
+i945_texture_layout_cube(struct i915_texture *tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
    unsigned level;
 
    const unsigned nblocks = util_format_get_nblocksx(pt->format, pt->width0);
@@ -516,7 +526,7 @@ i945_miptree_layout_cube(struct i915_texture *tex)
    /* Set all the levels to effectively occupy the whole rectangular region.
    */
    for (level = 0; level <= pt->last_level; level++) {
-      i915_miptree_set_level_info(tex, level, 6, width, height, 1);
+      i915_texture_set_level_info(tex, level, 6, width, height, 1);
       width /= 2;
       height /= 2;
    }
@@ -538,7 +548,7 @@ i945_miptree_layout_cube(struct i915_texture *tex)
 #endif
 
       for (level = 0; level <= pt->last_level; level++) {
-         i915_miptree_set_image_offset(tex, level, face, x, y);
+         i915_texture_set_image_offset(tex, level, face, x, y);
 
          d >>= 1;
 
@@ -583,20 +593,20 @@ i945_miptree_layout_cube(struct i915_texture *tex)
 }
 
 static boolean
-i945_miptree_layout(struct i915_texture * tex)
+i945_texture_layout(struct i915_texture * tex)
 {
-   struct pipe_texture *pt = &tex->base;
+   struct pipe_resource *pt = &tex->b.b;
 
    switch (pt->target) {
    case PIPE_TEXTURE_1D:
    case PIPE_TEXTURE_2D:
-      i945_miptree_layout_2d(tex);
+      i945_texture_layout_2d(tex);
       break;
    case PIPE_TEXTURE_3D:
-      i945_miptree_layout_3d(tex);
+      i945_texture_layout_3d(tex);
       break;
    case PIPE_TEXTURE_CUBE:
-      i945_miptree_layout_cube(tex);
+      i945_texture_layout_cube(tex);
       break;
    default:
       assert(0);
@@ -607,14 +617,132 @@ i945_miptree_layout(struct i915_texture * tex)
 }
 
 
+
 /*
  * Screen texture functions
  */
 
 
-static struct pipe_texture *
+
+static boolean
+i915_texture_get_handle(struct pipe_screen * screen,
+                        struct pipe_resource *texture,
+                        struct winsys_handle *whandle)
+{
+   struct i915_screen *is = i915_screen(screen);
+   struct i915_texture *tex = i915_texture(texture);
+   struct i915_winsys *iws = is->iws;
+
+   return iws->buffer_get_handle(iws, tex->buffer, whandle, tex->stride);
+}
+
+
+static void
+i915_texture_destroy(struct pipe_screen *screen,
+		     struct pipe_resource *pt)
+{
+   struct i915_texture *tex = i915_texture(pt);
+   struct i915_winsys *iws = i915_screen(screen)->iws;
+   uint i;
+
+   /*
+     DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
+   */
+
+   iws->buffer_destroy(iws, tex->buffer);
+
+   for (i = 0; i < Elements(tex->image_offset); i++)
+      if (tex->image_offset[i])
+         FREE(tex->image_offset[i]);
+
+   FREE(tex);
+}
+
+static struct pipe_transfer * 
+i915_texture_get_transfer(struct pipe_context *context,
+			  struct pipe_resource *resource,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box)
+{
+   struct i915_texture *tex = i915_texture(resource);
+   struct pipe_transfer *transfer = CALLOC_STRUCT(pipe_transfer);
+   if (transfer == NULL)
+      return NULL;
+
+   transfer->resource = resource;
+   transfer->sr = sr;
+   transfer->usage = usage;
+   transfer->box = *box;
+   transfer->stride = tex->stride;
+
+   return transfer;
+}
+
+
+static void *
+i915_texture_transfer_map(struct pipe_context *pipe,
+			  struct pipe_transfer *transfer)
+{
+   struct pipe_resource *resource = transfer->resource;
+   struct i915_texture *tex = i915_texture(resource);
+   struct i915_winsys *iws = i915_screen(pipe->screen)->iws;
+   struct pipe_subresource sr = transfer->sr;
+   struct pipe_box *box = &transfer->box;
+   enum pipe_format format = resource->format;
+   unsigned offset;
+   char *map;
+
+   if (resource->target == PIPE_TEXTURE_CUBE) {
+      offset = tex->image_offset[sr.level][sr.face];
+   } else if (resource->target == PIPE_TEXTURE_3D) {
+      offset = tex->image_offset[sr.level][box->z];
+   } else {
+      offset = tex->image_offset[sr.level][0];
+      assert(sr.face == 0);
+      assert(box->z == 0);
+   }
+
+   map = iws->buffer_map(iws, tex->buffer,
+                         (transfer->usage & PIPE_TRANSFER_WRITE) ? TRUE : FALSE);
+   if (map == NULL)
+      return NULL;
+
+   return map + offset +
+      box->y / util_format_get_blockheight(format) * transfer->stride +
+      box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
+}
+
+static void
+i915_texture_transfer_unmap(struct pipe_context *pipe,
+			    struct pipe_transfer *transfer)
+{
+   struct i915_texture *tex = i915_texture(transfer->resource);
+   struct i915_winsys *iws = i915_screen(tex->b.b.screen)->iws;
+   iws->buffer_unmap(iws, tex->buffer);
+}
+
+
+
+struct u_resource_vtbl i915_texture_vtbl = 
+{
+   i915_texture_get_handle,	      /* get_handle */
+   i915_texture_destroy,	      /* resource_destroy */
+   NULL,			      /* is_resource_referenced */
+   i915_texture_get_transfer,	      /* get_transfer */
+   u_default_transfer_destroy,	      /* transfer_destroy */
+   i915_texture_transfer_map,	      /* transfer_map */
+   u_default_transfer_flush_region,   /* transfer_flush_region */
+   i915_texture_transfer_unmap,	      /* transfer_unmap */
+   u_default_transfer_inline_write    /* transfer_inline_write */
+};
+
+
+
+
+struct pipe_resource *
 i915_texture_create(struct pipe_screen *screen,
-                    const struct pipe_texture *templat)
+                    const struct pipe_resource *template)
 {
    struct i915_screen *is = i915_screen(screen);
    struct i915_winsys *iws = is->iws;
@@ -625,24 +753,27 @@ i915_texture_create(struct pipe_screen *screen,
    if (!tex)
       return NULL;
 
-   tex->base = *templat;
-   pipe_reference_init(&tex->base.reference, 1);
-   tex->base.screen = screen;
+   tex->b.b = *template;
+   tex->b.vtbl = &i915_texture_vtbl;
+   pipe_reference_init(&tex->b.b.reference, 1);
+   tex->b.b.screen = screen;
 
    if (is->is_i945) {
-      if (!i945_miptree_layout(tex))
+      if (!i945_texture_layout(tex))
          goto fail;
    } else {
-      if (!i915_miptree_layout(tex))
+      if (!i915_texture_layout(tex))
          goto fail;
    }
 
    tex_size = tex->stride * tex->total_nblocksy;
 
-
-
    /* for scanouts and cursors, cursors arn't scanouts */
-   if (templat->tex_usage & PIPE_TEXTURE_USAGE_SCANOUT && templat->width0 != 64)
+
+   /* XXX: use a custom flag for cursors, don't rely on magically
+    * guessing that this is Xorg asking for a cursor
+    */
+   if ((template->bind & PIPE_BIND_SCANOUT) && template->width0 != 64)
       buf_usage = I915_NEW_SCANOUT;
    else
       buf_usage = I915_NEW_TEXTURE;
@@ -665,17 +796,17 @@ i915_texture_create(struct pipe_screen *screen,
    ws->buffer_unmap(ws, tex->buffer);
 #endif
 
-   return &tex->base;
+   return &tex->b.b;
 
 fail:
    FREE(tex);
    return NULL;
 }
 
-static struct pipe_texture *
+struct pipe_resource *
 i915_texture_from_handle(struct pipe_screen * screen,
-                         const struct pipe_texture *templat,
-                         struct winsys_handle *whandle)
+			  const struct pipe_resource *template,
+			  struct winsys_handle *whandle)
 {
    struct i915_screen *is = i915_screen(screen);
    struct i915_texture *tex;
@@ -688,9 +819,9 @@ i915_texture_from_handle(struct pipe_screen * screen,
    buffer = iws->buffer_from_handle(iws, whandle, &stride);
 
    /* Only supports one type */
-   if (templat->target != PIPE_TEXTURE_2D ||
-       templat->last_level != 0 ||
-       templat->depth0 != 1) {
+   if (template->target != PIPE_TEXTURE_2D ||
+       template->last_level != 0 ||
+       template->depth0 != 1) {
       return NULL;
    }
 
@@ -698,204 +829,18 @@ i915_texture_from_handle(struct pipe_screen * screen,
    if (!tex)
       return NULL;
 
-   tex->base = *templat;
-   pipe_reference_init(&tex->base.reference, 1);
-   tex->base.screen = screen;
+   tex->b.b = *template;
+   tex->b.vtbl = &i915_texture_vtbl;
+   pipe_reference_init(&tex->b.b.reference, 1);
+   tex->b.b.screen = screen;
 
    tex->stride = stride;
 
-   i915_miptree_set_level_info(tex, 0, 1, templat->width0, templat->height0, 1);
-   i915_miptree_set_image_offset(tex, 0, 0, 0, 0);
+   i915_texture_set_level_info(tex, 0, 1, template->width0, template->height0, 1);
+   i915_texture_set_image_offset(tex, 0, 0, 0, 0);
 
    tex->buffer = buffer;
 
-   return &tex->base;
-}
-
-static boolean
-i915_texture_get_handle(struct pipe_screen * screen,
-                        struct pipe_texture *texture,
-                        struct winsys_handle *whandle)
-{
-   struct i915_screen *is = i915_screen(screen);
-   struct i915_texture *tex = (struct i915_texture *)texture;
-   struct i915_winsys *iws = is->iws;
-
-   return iws->buffer_get_handle(iws, tex->buffer, whandle, tex->stride);
-}
-
-
-static void
-i915_texture_destroy(struct pipe_texture *pt)
-{
-   struct i915_texture *tex = (struct i915_texture *)pt;
-   struct i915_winsys *iws = i915_screen(pt->screen)->iws;
-   uint i;
-
-   /*
-     DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
-   */
-
-   iws->buffer_destroy(iws, tex->buffer);
-
-   for (i = 0; i < Elements(tex->image_offset); i++)
-      if (tex->image_offset[i])
-         FREE(tex->image_offset[i]);
-
-   FREE(tex);
+   return &tex->b.b;
 }
 
-
-/*
- * Screen surface functions
- */
-
-
-static struct pipe_surface *
-i915_get_tex_surface(struct pipe_screen *screen,
-                     struct pipe_texture *pt,
-                     unsigned face, unsigned level, unsigned zslice,
-                     unsigned flags)
-{
-   struct i915_texture *tex = (struct i915_texture *)pt;
-   struct pipe_surface *ps;
-   unsigned offset;  /* in bytes */
-
-   if (pt->target == PIPE_TEXTURE_CUBE) {
-      offset = tex->image_offset[level][face];
-   }
-   else if (pt->target == PIPE_TEXTURE_3D) {
-      offset = tex->image_offset[level][zslice];
-   }
-   else {
-      offset = tex->image_offset[level][0];
-      assert(face == 0);
-      assert(zslice == 0);
-   }
-
-   ps = CALLOC_STRUCT(pipe_surface);
-   if (ps) {
-      pipe_reference_init(&ps->reference, 1);
-      pipe_texture_reference(&ps->texture, pt);
-      ps->format = pt->format;
-      ps->width = u_minify(pt->width0, level);
-      ps->height = u_minify(pt->height0, level);
-      ps->offset = offset;
-      ps->usage = flags;
-   }
-   return ps;
-}
-
-static void
-i915_tex_surface_destroy(struct pipe_surface *surf)
-{
-   pipe_texture_reference(&surf->texture, NULL);
-   FREE(surf);
-}
-
-
-/*
- * Texture transfer functions
- */
-
-
-static struct pipe_transfer *
-i915_get_tex_transfer(struct pipe_context *pipe,
-                      struct pipe_texture *texture,
-                      unsigned face, unsigned level, unsigned zslice,
-                      enum pipe_transfer_usage usage, unsigned x, unsigned y,
-                      unsigned w, unsigned h)
-{
-   struct i915_texture *tex = (struct i915_texture *)texture;
-   struct i915_transfer *trans;
-   unsigned offset;  /* in bytes */
-
-   if (texture->target == PIPE_TEXTURE_CUBE) {
-      offset = tex->image_offset[level][face];
-   }
-   else if (texture->target == PIPE_TEXTURE_3D) {
-      offset = tex->image_offset[level][zslice];
-   }
-   else {
-      offset = tex->image_offset[level][0];
-      assert(face == 0);
-      assert(zslice == 0);
-   }
-
-   trans = CALLOC_STRUCT(i915_transfer);
-   if (trans) {
-      pipe_texture_reference(&trans->base.texture, texture);
-      trans->base.x = x;
-      trans->base.y = y;
-      trans->base.width = w;
-      trans->base.height = h;
-      trans->base.stride = tex->stride;
-      trans->offset = offset;
-      trans->base.usage = usage;
-   }
-   return &trans->base;
-}
-
-static void *
-i915_transfer_map(struct pipe_context *pipe,
-                  struct pipe_transfer *transfer)
-{
-   struct i915_texture *tex = (struct i915_texture *)transfer->texture;
-   struct i915_winsys *iws = i915_screen(tex->base.screen)->iws;
-   char *map;
-   boolean write = FALSE;
-   enum pipe_format format = tex->base.format;
-
-   if (transfer->usage & PIPE_TRANSFER_WRITE)
-      write = TRUE;
-
-   map = iws->buffer_map(iws, tex->buffer, write);
-   if (map == NULL)
-      return NULL;
-
-   return map + i915_transfer(transfer)->offset +
-      transfer->y / util_format_get_blockheight(format) * transfer->stride +
-      transfer->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
-}
-
-static void
-i915_transfer_unmap(struct pipe_context *pipe,
-                    struct pipe_transfer *transfer)
-{
-   struct i915_texture *tex = (struct i915_texture *)transfer->texture;
-   struct i915_winsys *iws = i915_screen(tex->base.screen)->iws;
-   iws->buffer_unmap(iws, tex->buffer);
-}
-
-static void
-i915_tex_transfer_destroy(struct pipe_context *pipe,
-                          struct pipe_transfer *trans)
-{
-   pipe_texture_reference(&trans->texture, NULL);
-   FREE(trans);
-}
-
-
-/*
- * Other texture functions
- */
-
-void
-i915_init_texture_functions(struct i915_context *i915 )
-{
-   i915->base.get_tex_transfer = i915_get_tex_transfer;
-   i915->base.transfer_map = i915_transfer_map;
-   i915->base.transfer_unmap = i915_transfer_unmap;
-   i915->base.tex_transfer_destroy = i915_tex_transfer_destroy;
-}
-
-void
-i915_init_screen_texture_functions(struct i915_screen *is)
-{
-   is->base.texture_create = i915_texture_create;
-   is->base.texture_from_handle = i915_texture_from_handle;
-   is->base.texture_get_handle = i915_texture_get_handle;
-   is->base.texture_destroy = i915_texture_destroy;
-   is->base.get_tex_surface = i915_get_tex_surface;
-   is->base.tex_surface_destroy = i915_tex_surface_destroy;
-}
diff --git a/src/gallium/drivers/i915/i915_screen.c b/src/gallium/drivers/i915/i915_screen.c
index 4ccc66b0373..9086f9fc3b1 100644
--- a/src/gallium/drivers/i915/i915_screen.c
+++ b/src/gallium/drivers/i915/i915_screen.c
@@ -33,8 +33,8 @@
 #include "i915_reg.h"
 #include "i915_context.h"
 #include "i915_screen.h"
-#include "i915_buffer.h"
-#include "i915_texture.h"
+#include "i915_surface.h"
+#include "i915_resource.h"
 #include "i915_winsys.h"
 
 
@@ -190,7 +190,7 @@ i915_is_format_supported(struct pipe_screen *screen,
    const enum pipe_format *list;
    uint i;
 
-   if(tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
+   if(tex_usage & PIPE_BIND_RENDER_TARGET)
       list = surface_supported;
    else
       list = tex_supported;
@@ -308,8 +308,8 @@ i915_create_screen(struct i915_winsys *iws, uint pci_id)
    is->base.fence_signalled = i915_fence_signalled;
    is->base.fence_finish = i915_fence_finish;
 
-   i915_init_screen_texture_functions(is);
-   i915_init_screen_buffer_functions(is);
+   i915_init_screen_resource_functions(is);
+   i915_init_screen_surface_functions(is);
 
    return &is->base;
 }
diff --git a/src/gallium/drivers/i915/i915_state.c b/src/gallium/drivers/i915/i915_state.c
index 0f7395246cc..397647204b4 100644
--- a/src/gallium/drivers/i915/i915_state.c
+++ b/src/gallium/drivers/i915/i915_state.c
@@ -39,6 +39,7 @@
 #include "i915_reg.h"
 #include "i915_state_inlines.h"
 #include "i915_fpc.h"
+#include "i915_resource.h"
 
 /* The i915 (and related graphics cores) do not support GL_CLAMP.  The
  * Intel drivers for "other operating systems" implement GL_CLAMP as
@@ -523,10 +524,9 @@ static void i915_delete_vs_state(struct pipe_context *pipe, void *shader)
 
 static void i915_set_constant_buffer(struct pipe_context *pipe,
                                      uint shader, uint index,
-                                     struct pipe_buffer *buf)
+                                     struct pipe_resource *buf)
 {
    struct i915_context *i915 = i915_context(pipe);
-   struct pipe_screen *screen = pipe->screen;
    draw_flush(i915->draw);
 
    assert(shader < PIPE_SHADER_TYPES);
@@ -542,19 +542,15 @@ static void i915_set_constant_buffer(struct pipe_context *pipe,
     * N constants, leaving any extras from shader translation alone.
     */
    if (buf) {
-      void *mapped;
-      if (buf->size &&
-          (mapped = pipe_buffer_map(screen, buf,
-                                    PIPE_BUFFER_USAGE_CPU_READ))) {
-         memcpy(i915->current.constants[shader], mapped, buf->size);
-         pipe_buffer_unmap(screen, buf);
-         i915->current.num_user_constants[shader]
-            = buf->size / (4 * sizeof(float));
-      }
-      else {
-         i915->current.num_user_constants[shader] = 0;
-      }
+      struct i915_buffer *ir = i915_buffer(buf);
+      memcpy(i915->current.constants[shader], ir->data, ir->b.b.width0);
+      i915->current.num_user_constants[shader] = (ir->b.b.width0 /
+						  4 * sizeof(float));
    }
+   else {
+      i915->current.num_user_constants[shader] = 0;
+   }
+
 
    i915->dirty |= I915_NEW_CONSTANTS;
 }
@@ -593,7 +589,7 @@ static void i915_set_fragment_sampler_views(struct pipe_context *pipe,
 
 static struct pipe_sampler_view *
 i915_create_sampler_view(struct pipe_context *pipe,
-                         struct pipe_texture *texture,
+                         struct pipe_resource *texture,
                          const struct pipe_sampler_view *templ)
 {
    struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
@@ -602,7 +598,7 @@ i915_create_sampler_view(struct pipe_context *pipe,
       *view = *templ;
       view->reference.count = 1;
       view->texture = NULL;
-      pipe_texture_reference(&view->texture, texture);
+      pipe_resource_reference(&view->texture, texture);
       view->context = pipe;
    }
 
@@ -614,7 +610,7 @@ static void
 i915_sampler_view_destroy(struct pipe_context *pipe,
                           struct pipe_sampler_view *view)
 {
-   pipe_texture_reference(&view->texture, NULL);
+   pipe_resource_reference(&view->texture, NULL);
    FREE(view);
 }
 
diff --git a/src/gallium/drivers/i915/i915_state_emit.c b/src/gallium/drivers/i915/i915_state_emit.c
index 2d212abfb9d..4d069fffa85 100644
--- a/src/gallium/drivers/i915/i915_state_emit.c
+++ b/src/gallium/drivers/i915/i915_state_emit.c
@@ -30,6 +30,7 @@
 #include "i915_context.h"
 #include "i915_batch.h"
 #include "i915_reg.h"
+#include "i915_resource.h"
 
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
@@ -211,8 +212,7 @@ i915_emit_hardware_state(struct i915_context *i915 )
 
       if (cbuf_surface) {
          unsigned ctile = BUF_3D_USE_FENCE;
-         struct i915_texture *tex = (struct i915_texture *)
-                                    cbuf_surface->texture;
+         struct i915_texture *tex = i915_texture(cbuf_surface->texture);
          assert(tex);
 
          if (tex && tex->sw_tiled) {
@@ -234,8 +234,7 @@ i915_emit_hardware_state(struct i915_context *i915 )
        */
       if (depth_surface) {
          unsigned ztile = BUF_3D_USE_FENCE;
-         struct i915_texture *tex = (struct i915_texture *)
-                                    depth_surface->texture;
+         struct i915_texture *tex = i915_texture(depth_surface->texture);
          assert(tex);
 
          if (tex && tex->sw_tiled) {
@@ -290,7 +289,7 @@ i915_emit_hardware_state(struct i915_context *i915 )
             OUT_BATCH(enabled);
             for (unit = 0; unit < I915_TEX_UNITS; unit++) {
                if (enabled & (1 << unit)) {
-                  struct i915_texture *texture = (struct i915_texture *)i915->fragment_sampler_views[unit]->texture;
+                  struct i915_texture *texture = i915_texture(i915->fragment_sampler_views[unit]->texture);
                   struct i915_winsys_buffer *buf = texture->buffer;
                   uint offset = 0;
                   assert(buf);
diff --git a/src/gallium/drivers/i915/i915_state_sampler.c b/src/gallium/drivers/i915/i915_state_sampler.c
index 270d4f21e10..73e61b66240 100644
--- a/src/gallium/drivers/i915/i915_state_sampler.c
+++ b/src/gallium/drivers/i915/i915_state_sampler.c
@@ -32,6 +32,7 @@
 #include "i915_context.h"
 #include "i915_reg.h"
 #include "i915_state.h"
+#include "i915_resource.h"
 
 
 /*
@@ -77,7 +78,7 @@ static void update_sampler(struct i915_context *i915,
 			   const struct i915_texture *tex,
 			   unsigned state[3] )
 {
-   const struct pipe_texture *pt = &tex->base;
+   const struct pipe_resource *pt = &tex->b.b;
    unsigned minlod, lastlod;
 
    /* Need to do this after updating the maps, which call the
@@ -149,7 +150,7 @@ void i915_update_samplers( struct i915_context *i915 )
       /* determine unit enable/disable by looking for a bound texture */
       /* could also examine the fragment program? */
       if (i915->fragment_sampler_views[unit]) {
-         struct i915_texture *texture = (struct i915_texture *)i915->fragment_sampler_views[unit]->texture;
+         struct i915_texture *texture = i915_texture(i915->fragment_sampler_views[unit]->texture);
 
 	 update_sampler( i915,
 	                 unit,
@@ -238,7 +239,7 @@ i915_update_texture(struct i915_context *i915,
                     const struct i915_sampler_state *sampler,
                     uint state[6])
 {
-   const struct pipe_texture *pt = &tex->base;
+   const struct pipe_resource *pt = &tex->b.b;
    uint format, pitch;
    const uint width = pt->width0, height = pt->height0, depth = pt->depth0;
    const uint num_levels = pt->last_level;
@@ -296,7 +297,7 @@ i915_update_textures(struct i915_context *i915)
       /* determine unit enable/disable by looking for a bound texture */
       /* could also examine the fragment program? */
       if (i915->fragment_sampler_views[unit]) {
-         struct i915_texture *texture = (struct i915_texture *)i915->fragment_sampler_views[unit]->texture;
+         struct i915_texture *texture = i915_texture(i915->fragment_sampler_views[unit]->texture);
 
 	 i915_update_texture( i915,
 	                      unit,
diff --git a/src/gallium/drivers/i915/i915_surface.c b/src/gallium/drivers/i915/i915_surface.c
index 1ff6b9f4c63..453437b8090 100644
--- a/src/gallium/drivers/i915/i915_surface.c
+++ b/src/gallium/drivers/i915/i915_surface.c
@@ -25,10 +25,15 @@
  * 
  **************************************************************************/
 
-#include "i915_context.h"
+#include "i915_surface.h"
+#include "i915_resource.h"
 #include "i915_blit.h"
+#include "i915_screen.h"
 #include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+#include "util/u_math.h"
 #include "util/u_format.h"
+#include "util/u_memory.h"
 
 
 /* Assumes all values are within bounds -- no checking at this level -
@@ -41,10 +46,10 @@ i915_surface_copy(struct pipe_context *pipe,
 		  struct pipe_surface *src,
 		  unsigned srcx, unsigned srcy, unsigned width, unsigned height)
 {
-   struct i915_texture *dst_tex = (struct i915_texture *)dst->texture;
-   struct i915_texture *src_tex = (struct i915_texture *)src->texture;
-   struct pipe_texture *dpt = &dst_tex->base;
-   struct pipe_texture *spt = &src_tex->base;
+   struct i915_texture *dst_tex = i915_texture(dst->texture);
+   struct i915_texture *src_tex = i915_texture(src->texture);
+   struct pipe_resource *dpt = &dst_tex->b.b;
+   struct pipe_resource *spt = &src_tex->b.b;
 
    assert( dst != src );
    assert( util_format_get_blocksize(dpt->format) == util_format_get_blocksize(spt->format) );
@@ -68,8 +73,8 @@ i915_surface_fill(struct pipe_context *pipe,
 		  unsigned dstx, unsigned dsty,
 		  unsigned width, unsigned height, unsigned value)
 {
-   struct i915_texture *tex = (struct i915_texture *)dst->texture;
-   struct pipe_texture *pt = &tex->base;
+   struct i915_texture *tex = i915_texture(dst->texture);
+   struct pipe_resource *pt = &tex->b.b;
 
    assert(util_format_get_blockwidth(pt->format) == 1);
    assert(util_format_get_blockheight(pt->format) == 1);
@@ -84,9 +89,68 @@ i915_surface_fill(struct pipe_context *pipe,
 }
 
 
+/*
+ * Screen surface functions
+ */
+
+
+static struct pipe_surface *
+i915_get_tex_surface(struct pipe_screen *screen,
+                     struct pipe_resource *pt,
+                     unsigned face, unsigned level, unsigned zslice,
+                     unsigned flags)
+{
+   struct i915_texture *tex = i915_texture(pt);
+   struct pipe_surface *ps;
+   unsigned offset;  /* in bytes */
+
+   if (pt->target == PIPE_TEXTURE_CUBE) {
+      offset = tex->image_offset[level][face];
+   }
+   else if (pt->target == PIPE_TEXTURE_3D) {
+      offset = tex->image_offset[level][zslice];
+   }
+   else {
+      offset = tex->image_offset[level][0];
+      assert(face == 0);
+      assert(zslice == 0);
+   }
+
+   ps = CALLOC_STRUCT(pipe_surface);
+   if (ps) {
+      pipe_reference_init(&ps->reference, 1);
+      pipe_resource_reference(&ps->texture, pt);
+      ps->format = pt->format;
+      ps->width = u_minify(pt->width0, level);
+      ps->height = u_minify(pt->height0, level);
+      ps->offset = offset;
+      ps->usage = flags;
+   }
+   return ps;
+}
+
+static void
+i915_tex_surface_destroy(struct pipe_surface *surf)
+{
+   pipe_resource_reference(&surf->texture, NULL);
+   FREE(surf);
+}
+
+
+/* Probably going to make blits work on textures rather than surfaces.
+ */
 void
 i915_init_surface_functions(struct i915_context *i915)
 {
    i915->base.surface_copy = i915_surface_copy;
    i915->base.surface_fill = i915_surface_fill;
 }
+
+/* No good reason for these to be in the screen.
+ */
+void
+i915_init_screen_surface_functions(struct i915_screen *is)
+{
+   is->base.get_tex_surface = i915_get_tex_surface;
+   is->base.tex_surface_destroy = i915_tex_surface_destroy;
+}
diff --git a/src/gallium/drivers/i915/i915_texture.h b/src/gallium/drivers/i915/i915_surface.h
index 51a1dd984c8..448106d5662 100644
--- a/src/gallium/drivers/i915/i915_texture.h
+++ b/src/gallium/drivers/i915/i915_surface.h
@@ -25,12 +25,14 @@
  * 
  **************************************************************************/
 
-#ifndef I915_TEXTURE_H
-#define I915_TEXTURE_H
+#ifndef I915_SURFACE_H
+#define I915_SURFACE_H
 
+struct i915_context;
 struct i915_screen;
 
-extern void
-i915_init_screen_texture_functions(struct i915_screen *is);
+void i915_init_surface_functions( struct i915_context *i915 );
+void i915_init_screen_surface_functions( struct i915_screen *is );
 
-#endif /* I915_TEXTURE_H */
+
+#endif /* I915_SCREEN_H */
diff --git a/src/gallium/drivers/i915/i915_winsys.h b/src/gallium/drivers/i915/i915_winsys.h
index 246e95b00d6..8a6f579ad97 100644
--- a/src/gallium/drivers/i915/i915_winsys.h
+++ b/src/gallium/drivers/i915/i915_winsys.h
@@ -31,7 +31,7 @@
 struct i915_winsys;
 struct i915_winsys_buffer;
 struct i915_winsys_batchbuffer;
-struct pipe_texture;
+struct pipe_resource;
 struct pipe_fence_handle;
 struct winsys_handle;
 
@@ -133,7 +133,7 @@ struct i915_winsys {
 
    /**
     * Creates a buffer from a handle.
-    * Used to implement pipe_screen::texture_from_handle.
+    * Used to implement pipe_screen::resource_from_handle.
     * Also provides the stride information needed for the
     * texture via the stride argument.
     */
@@ -143,7 +143,7 @@ struct i915_winsys {
                             unsigned *stride);
 
    /**
-    * Used to implement pipe_screen::texture_get_handle.
+    * Used to implement pipe_screen::resource_get_handle.
     * The winsys might need the stride information.
     */
    boolean (*buffer_get_handle)(struct i915_winsys *iws,
diff --git a/src/gallium/drivers/i965/Makefile b/src/gallium/drivers/i965/Makefile
index 95fd3cd69bd..b0b09703384 100644
--- a/src/gallium/drivers/i965/Makefile
+++ b/src/gallium/drivers/i965/Makefile
@@ -36,6 +36,7 @@ C_SOURCES = \
 	brw_pipe_vertex.c \
 	brw_pipe_clear.c \
 	brw_pipe_rast.c \
+	brw_resource.c \
 	brw_sf.c \
 	brw_sf_emit.c \
 	brw_sf_state.c \
@@ -46,7 +47,6 @@ C_SOURCES = \
 	brw_structs_dump.c \
 	brw_swtnl.c \
 	brw_urb.c \
-	brw_util.c \
 	brw_vs.c \
 	brw_vs_emit.c \
 	brw_vs_state.c \
@@ -63,9 +63,9 @@ C_SOURCES = \
 	brw_wm_state.c \
 	brw_wm_surface_state.c \
 	brw_screen.c \
-	brw_screen_buffers.c \
-	brw_screen_tex_layout.c \
-	brw_screen_texture.c \
+	brw_resource_buffer.c \
+	brw_resource_texture.c \
+	brw_resource_texture_layout.c \
 	brw_screen_surface.c \
 	brw_batchbuffer.c \
 	brw_winsys_debug.c \
diff --git a/src/gallium/drivers/i965/SConscript b/src/gallium/drivers/i965/SConscript
index d900ea25968..85c4d7ed22e 100644
--- a/src/gallium/drivers/i965/SConscript
+++ b/src/gallium/drivers/i965/SConscript
@@ -38,11 +38,12 @@ i965 = env.ConvenienceLibrary(
 		'brw_pipe_sampler.c',
 		'brw_pipe_shader.c',
 		'brw_pipe_vertex.c',
-		'brw_screen_buffers.c',
+		'brw_resource.c',
+		'brw_resource_buffer.c',
+		'brw_resource_texture.c',
+		'brw_resource_texture_layout.c',
 		'brw_screen.c',
 		'brw_screen_surface.c',
-		'brw_screen_tex_layout.c',
-		'brw_screen_texture.c',
 		'brw_structs_dump.c',
 		'brw_sf.c',
 		'brw_sf_emit.c',
@@ -53,7 +54,6 @@ i965 = env.ConvenienceLibrary(
 		'brw_state_upload.c',
 		'brw_swtnl.c',
 		'brw_urb.c',
-		'brw_util.c',
 		'brw_vs.c',
 		'brw_vs_emit.c',
 		'brw_vs_state.c',
diff --git a/src/gallium/drivers/i965/brw_context.c b/src/gallium/drivers/i965/brw_context.c
index 4bcdcdd17eb..227bc790deb 100644
--- a/src/gallium/drivers/i965/brw_context.c
+++ b/src/gallium/drivers/i965/brw_context.c
@@ -39,6 +39,7 @@
 #include "brw_state.h"
 #include "brw_batchbuffer.h"
 #include "brw_winsys.h"
+#include "brw_resource.h"
 #include "brw_screen.h"
 
 
@@ -118,7 +119,7 @@ struct pipe_context *brw_create_context(struct pipe_screen *screen,
    brw->sws = brw_screen(screen)->sws;
    brw->chipset = brw_screen(screen)->chipset;
 
-   brw_tex_init( brw );
+   brw_init_resource_functions( brw );
    brw_pipe_blend_init( brw );
    brw_pipe_depth_stencil_init( brw );
    brw_pipe_framebuffer_init( brw );
diff --git a/src/gallium/drivers/i965/brw_context.h b/src/gallium/drivers/i965/brw_context.h
index dab881fea24..94c9c443f05 100644
--- a/src/gallium/drivers/i965/brw_context.h
+++ b/src/gallium/drivers/i965/brw_context.h
@@ -561,8 +561,8 @@ struct brw_context
       struct pipe_stencil_ref stencil_ref;
       struct pipe_framebuffer_state fb;
       struct pipe_clip_state ucp;
-      struct pipe_buffer *vertex_constants;
-      struct pipe_buffer *fragment_constants;
+      struct pipe_resource *vertex_constants;
+      struct pipe_resource *fragment_constants;
 
       struct brw_blend_constant_color bcc;
       struct brw_cc1 cc1_stencil_ref;
@@ -574,7 +574,7 @@ struct brw_context
        *
        * Updates are signaled by PIPE_NEW_INDEX_BUFFER.
        */
-      struct pipe_buffer *index_buffer;
+      struct pipe_resource *index_buffer;
       unsigned index_size;
 
       /* Updates are signalled by PIPE_NEW_INDEX_RANGE:
diff --git a/src/gallium/drivers/i965/brw_curbe.c b/src/gallium/drivers/i965/brw_curbe.c
index 4b215a001c4..323af16b145 100644
--- a/src/gallium/drivers/i965/brw_curbe.c
+++ b/src/gallium/drivers/i965/brw_curbe.c
@@ -160,7 +160,6 @@ static GLfloat fixed_plane[6][4] = {
  */
 static enum pipe_error prepare_curbe_buffer(struct brw_context *brw)
 {
-   struct pipe_screen *screen = brw->base.screen;
    const GLuint sz = brw->curbe.total_size;
    const GLuint bufsz = sz * 16 * sizeof(GLfloat);
    enum pipe_error ret;
@@ -196,15 +195,11 @@ static enum pipe_error prepare_curbe_buffer(struct brw_context *brw)
       nr_const = fs->info.file_max[TGSI_FILE_CONSTANT] + 1;
 /*      nr_const = brw->wm.prog_data->nr_params; */
       if (nr_const) {
-         const GLfloat *value = screen->buffer_map( screen,
-                                                    brw->curr.fragment_constants,
-                                                    PIPE_BUFFER_USAGE_CPU_READ);
-
-         memcpy(&buf[offset], value,
-                nr_const * 4 * sizeof(float));
-         
-         screen->buffer_unmap( screen, 
-                               brw->curr.fragment_constants );
+	 pipe_buffer_read( &brw->base,
+			   brw->curr.fragment_constants,
+			   0,
+			   nr_const * 4 * sizeof(float),
+			   &buf[offset]);
       }
    }
 
@@ -258,15 +253,14 @@ static enum pipe_error prepare_curbe_buffer(struct brw_context *brw)
           * buffer objects.  If we want to keep on putting them into the
           * curbe, makes sense to treat constbuf's specially with malloc.
           */
-         const GLfloat *value = screen->buffer_map( screen,
-                                                    brw->curr.vertex_constants,
-                                                    PIPE_BUFFER_USAGE_CPU_READ);
          
          /* XXX: what if user's constant buffer is too small?
           */
-         memcpy(&buf[offset], value, nr_const * 4 * sizeof(float));
-         
-         screen->buffer_unmap( screen, brw->curr.vertex_constants );
+	 pipe_buffer_read(&brw->base,
+			  brw->curr.vertex_constants,
+			  0,
+			  nr_const * 4 * sizeof(float),
+			  &buf[offset]);
       }
    }
 
diff --git a/src/gallium/drivers/i965/brw_draw.c b/src/gallium/drivers/i965/brw_draw.c
index 9bad61ef72e..eb73ec2f272 100644
--- a/src/gallium/drivers/i965/brw_draw.c
+++ b/src/gallium/drivers/i965/brw_draw.c
@@ -142,7 +142,7 @@ static int brw_emit_prim(struct brw_context *brw,
  */
 static int
 try_draw_range_elements(struct brw_context *brw,
-			struct pipe_buffer *index_buffer,
+			struct pipe_resource *index_buffer,
 			unsigned hw_prim, 
 			unsigned start, unsigned count)
 {
@@ -178,7 +178,7 @@ try_draw_range_elements(struct brw_context *brw,
 
 static void
 brw_draw_range_elements(struct pipe_context *pipe,
-			struct pipe_buffer *index_buffer,
+			struct pipe_resource *index_buffer,
 			unsigned index_size,
 			unsigned min_index,
 			unsigned max_index,
@@ -201,7 +201,7 @@ brw_draw_range_elements(struct pipe_context *pipe,
     */
    if (brw->curr.index_buffer != index_buffer ||
        brw->curr.index_size != index_size) {
-      pipe_buffer_reference( &brw->curr.index_buffer, index_buffer );
+      pipe_resource_reference( &brw->curr.index_buffer, index_buffer );
       brw->curr.index_size = index_size;
       brw->state.dirty.mesa |= PIPE_NEW_INDEX_BUFFER;
    }
@@ -232,7 +232,7 @@ brw_draw_range_elements(struct pipe_context *pipe,
 
 static void
 brw_draw_elements(struct pipe_context *pipe,
-		  struct pipe_buffer *index_buffer,
+		  struct pipe_resource *index_buffer,
 		  unsigned index_size,
 		  unsigned mode, 
 		  unsigned start, unsigned count)
@@ -263,17 +263,17 @@ boolean brw_draw_init( struct brw_context *brw )
 
    /* Create helpers for uploading data in user buffers:
     */
-   brw->vb.upload_vertex = u_upload_create( brw->base.screen,
+   brw->vb.upload_vertex = u_upload_create( &brw->base,
 					    128 * 1024,
 					    64,
-					    PIPE_BUFFER_USAGE_VERTEX );
+					    PIPE_BIND_VERTEX_BUFFER );
    if (brw->vb.upload_vertex == NULL)
       return FALSE;
 
-   brw->vb.upload_index = u_upload_create( brw->base.screen,
+   brw->vb.upload_index = u_upload_create( &brw->base,
 					   32 * 1024,
 					   64,
-					   PIPE_BUFFER_USAGE_INDEX );
+					   PIPE_BIND_INDEX_BUFFER );
    if (brw->vb.upload_index == NULL)
       return FALSE;
 
diff --git a/src/gallium/drivers/i965/brw_draw_upload.c b/src/gallium/drivers/i965/brw_draw_upload.c
index 0820ba20a08..337eee8cd9c 100644
--- a/src/gallium/drivers/i965/brw_draw_upload.c
+++ b/src/gallium/drivers/i965/brw_draw_upload.c
@@ -38,6 +38,7 @@
 #include "brw_screen.h"
 #include "brw_batchbuffer.h"
 #include "brw_debug.h"
+#include "brw_resource.h"
 
 
 
@@ -67,7 +68,7 @@ static int brw_prepare_vertices(struct brw_context *brw)
    for (i = 0; i < brw->curr.num_vertex_buffers; i++) {
       struct pipe_vertex_buffer *vb = &brw->curr.vertex_buffer[i];
       struct brw_winsys_buffer *bo;
-      struct pipe_buffer *upload_buf = NULL;
+      struct pipe_resource *upload_buf = NULL;
       unsigned offset;
       
       if (BRW_DEBUG & DEBUG_VERTS)
@@ -75,7 +76,7 @@ static int brw_prepare_vertices(struct brw_context *brw)
 		      __FUNCTION__, i,
 		      brw_buffer_is_user_buffer(vb->buffer),
 		      vb->buffer_offset,
-		      vb->buffer->size,
+		      vb->buffer->width0,
 		      vb->stride);
 
       if (brw_buffer_is_user_buffer(vb->buffer)) {
@@ -85,8 +86,8 @@ static int brw_prepare_vertices(struct brw_context *brw)
 	  * add support for >1 constant buffer) instead.
 	  */
 	 unsigned size = (vb->stride == 0 ? 
-			  vb->buffer->size - vb->buffer_offset :
-			  MAX2(vb->buffer->size - vb->buffer_offset,
+			  vb->buffer->width0 - vb->buffer_offset :
+			  MAX2(vb->buffer->width0 - vb->buffer_offset,
 			       vb->stride * (max_index + 1 - min_index)));
 
 	 ret = u_upload_buffer( brw->vb.upload_vertex, 
@@ -123,7 +124,7 @@ static int brw_prepare_vertices(struct brw_context *brw)
       /* Don't need to retain this reference.  We have a reference on
        * the underlying winsys buffer:
        */
-      pipe_buffer_reference( &upload_buf, NULL );
+      pipe_resource_reference( &upload_buf, NULL );
    }
 
    brw->vb.nr_vb = i;
@@ -226,8 +227,8 @@ const struct brw_tracked_state brw_vertices = {
 
 static int brw_prepare_indices(struct brw_context *brw)
 {
-   struct pipe_buffer *index_buffer = brw->curr.index_buffer;
-   struct pipe_buffer *upload_buf = NULL;
+   struct pipe_resource *index_buffer = brw->curr.index_buffer;
+   struct pipe_resource *upload_buf = NULL;
    struct brw_winsys_buffer *bo = NULL;
    GLuint offset;
    GLuint index_size;
@@ -241,9 +242,9 @@ static int brw_prepare_indices(struct brw_context *brw)
       debug_printf("%s: index_size:%d index_buffer->size:%d\n",
 		   __FUNCTION__,
 		   brw->curr.index_size,
-		   brw->curr.index_buffer->size);
+		   brw->curr.index_buffer->width0);
 
-   ib_size = index_buffer->size;
+   ib_size = index_buffer->width0;
    index_size = brw->curr.index_size;
 
    /* Turn userbuffer into a proper hardware buffer?
@@ -297,7 +298,7 @@ static int brw_prepare_indices(struct brw_context *brw)
       brw->state.dirty.brw |= BRW_NEW_INDEX_BUFFER;
    }
 
-   pipe_buffer_reference( &upload_buf, NULL );
+   pipe_resource_reference( &upload_buf, NULL );
    brw_add_validated_bo(brw, brw->ib.bo);
    return 0;
 }
diff --git a/src/gallium/drivers/i965/brw_pipe_flush.c b/src/gallium/drivers/i965/brw_pipe_flush.c
index fdc4814b221..0ae1a6be9e5 100644
--- a/src/gallium/drivers/i965/brw_pipe_flush.c
+++ b/src/gallium/drivers/i965/brw_pipe_flush.c
@@ -1,10 +1,10 @@
 
-#include "util/u_upload_mgr.h"
-
 #include "brw_context.h"
-#include "brw_screen.h"
 #include "brw_batchbuffer.h"
 
+#include "util/u_upload_mgr.h"
+
+
 
 
 /* All batchbuffer flushes must go through this function.
@@ -46,35 +46,9 @@ brw_flush( struct pipe_context *pipe,
       *fence = NULL;
 }
 
-static unsigned brw_is_buffer_referenced(struct pipe_context *pipe,
-                                  struct pipe_buffer *buffer)
-{
-   struct brw_context *brw = brw_context(pipe);
-   struct brw_screen *bscreen = brw_screen(brw->base.screen);
-
-   return brw_is_buffer_referenced_by_bo( bscreen,
-                                          buffer,
-                                          brw->batch->buf );
-}
-
-static unsigned brw_is_texture_referenced(struct pipe_context *pipe,
-                                   struct pipe_texture *texture,
-                                   unsigned face,
-                                   unsigned level)
-{
-   struct brw_context *brw = brw_context(pipe);
-   struct brw_screen *bscreen = brw_screen(brw->base.screen);
-
-   return brw_is_texture_referenced_by_bo( bscreen,
-                                           texture, face, level,
-                                           brw->batch->buf );
-}
-
 void brw_pipe_flush_init( struct brw_context *brw )
 {
    brw->base.flush = brw_flush;
-   brw->base.is_buffer_referenced = brw_is_buffer_referenced;
-   brw->base.is_texture_referenced = brw_is_texture_referenced;
 }
 
 
diff --git a/src/gallium/drivers/i965/brw_pipe_sampler.c b/src/gallium/drivers/i965/brw_pipe_sampler.c
index d2aa2bc9f35..3fe753ec42c 100644
--- a/src/gallium/drivers/i965/brw_pipe_sampler.c
+++ b/src/gallium/drivers/i965/brw_pipe_sampler.c
@@ -214,7 +214,7 @@ static void brw_bind_vertex_sampler_state(struct pipe_context *pipe,
 
 static struct pipe_sampler_view *
 brw_create_sampler_view(struct pipe_context *pipe,
-                        struct pipe_texture *texture,
+                        struct pipe_resource *texture,
                         const struct pipe_sampler_view *templ)
 {
    struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
@@ -223,7 +223,7 @@ brw_create_sampler_view(struct pipe_context *pipe,
       *view = *templ;
       view->reference.count = 1;
       view->texture = NULL;
-      pipe_texture_reference(&view->texture, texture);
+      pipe_resource_reference(&view->texture, texture);
       view->context = pipe;
    }
 
@@ -235,7 +235,7 @@ static void
 brw_sampler_view_destroy(struct pipe_context *pipe,
                          struct pipe_sampler_view *view)
 {
-   pipe_texture_reference(&view->texture, NULL);
+   pipe_resource_reference(&view->texture, NULL);
    FREE(view);
 }
 
diff --git a/src/gallium/drivers/i965/brw_pipe_shader.c b/src/gallium/drivers/i965/brw_pipe_shader.c
index fe445b9982e..d9bee96c11f 100644
--- a/src/gallium/drivers/i965/brw_pipe_shader.c
+++ b/src/gallium/drivers/i965/brw_pipe_shader.c
@@ -262,20 +262,20 @@ static void brw_delete_vs_state( struct pipe_context *pipe, void *prog )
 
 static void brw_set_constant_buffer(struct pipe_context *pipe,
                                      uint shader, uint index,
-                                     struct pipe_buffer *buf)
+                                     struct pipe_resource *buf)
 {
    struct brw_context *brw = brw_context(pipe);
 
    assert(index == 0);
 
    if (shader == PIPE_SHADER_FRAGMENT) {
-      pipe_buffer_reference( &brw->curr.fragment_constants,
+      pipe_resource_reference( &brw->curr.fragment_constants,
                              buf );
 
       brw->state.dirty.mesa |= PIPE_NEW_FRAGMENT_CONSTANTS;
    }
    else {
-      pipe_buffer_reference( &brw->curr.vertex_constants,
+      pipe_resource_reference( &brw->curr.vertex_constants,
                              buf );
 
       brw->state.dirty.mesa |= PIPE_NEW_VERTEX_CONSTANTS;
@@ -298,6 +298,6 @@ void brw_pipe_shader_init( struct brw_context *brw )
 
 void brw_pipe_shader_cleanup( struct brw_context *brw )
 {
-   pipe_buffer_reference( &brw->curr.fragment_constants, NULL );
-   pipe_buffer_reference( &brw->curr.vertex_constants, NULL );
+   pipe_resource_reference( &brw->curr.fragment_constants, NULL );
+   pipe_resource_reference( &brw->curr.vertex_constants, NULL );
 }
diff --git a/src/gallium/drivers/i965/brw_pipe_vertex.c b/src/gallium/drivers/i965/brw_pipe_vertex.c
index d6a840857ec..4a120a51dad 100644
--- a/src/gallium/drivers/i965/brw_pipe_vertex.c
+++ b/src/gallium/drivers/i965/brw_pipe_vertex.c
@@ -259,11 +259,11 @@ static void brw_set_vertex_buffers(struct pipe_context *pipe,
 
    /* Adjust refcounts */
    for (i = 0; i < count; i++) 
-      pipe_buffer_reference(&brw->curr.vertex_buffer[i].buffer, 
+      pipe_resource_reference(&brw->curr.vertex_buffer[i].buffer, 
                             buffers[i].buffer);
 
    for ( ; i < brw->curr.num_vertex_buffers; i++)
-      pipe_buffer_reference(&brw->curr.vertex_buffer[i].buffer,
+      pipe_resource_reference(&brw->curr.vertex_buffer[i].buffer,
                             NULL);
 
    /* Copy remaining data */
diff --git a/src/gallium/drivers/i965/brw_reg.h b/src/gallium/drivers/i965/brw_reg.h
index a63403b6afd..ba10f9d5df1 100644
--- a/src/gallium/drivers/i965/brw_reg.h
+++ b/src/gallium/drivers/i965/brw_reg.h
@@ -109,7 +109,7 @@ struct brw_chipset {
 /* XXX: hacks
  */
 #define VERT_RESULT_HPOS 0	/* not always true */
-#define VERT_RESULT_PSIZ 10000	/* disabled */
+#define VERT_RESULT_PSIZ 127	/* disabled */
 
 
 #endif
diff --git a/src/gallium/drivers/i965/brw_resource.c b/src/gallium/drivers/i965/brw_resource.c
new file mode 100644
index 00000000000..d601f42dd16
--- /dev/null
+++ b/src/gallium/drivers/i965/brw_resource.c
@@ -0,0 +1,50 @@
+#include "util/u_debug.h"
+
+#include "brw_resource.h"
+#include "brw_context.h"
+#include "brw_screen.h"
+
+
+static struct pipe_resource *
+brw_resource_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template)
+{
+   if (template->target == PIPE_BUFFER)
+      return brw_buffer_create(screen, template);
+   else
+      return brw_resource_create(screen, template);
+
+}
+
+static struct pipe_resource *
+brw_resource_from_handle(struct pipe_screen * screen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle)
+{
+   if (template->target == PIPE_BUFFER)
+      return NULL;
+   else
+      return brw_texture_from_handle(screen, template, whandle);
+}
+
+
+void
+brw_init_resource_functions(struct brw_context *brw )
+{
+   brw->base.get_transfer = u_get_transfer_vtbl;
+   brw->base.transfer_map = u_transfer_map_vtbl;
+   brw->base.transfer_flush_region = u_transfer_flush_region_vtbl;
+   brw->base.transfer_unmap = u_transfer_unmap_vtbl;
+   brw->base.transfer_destroy = u_transfer_destroy_vtbl;
+   brw->base.transfer_inline_write = u_transfer_inline_write_vtbl;
+}
+
+void
+brw_init_screen_resource_functions(struct brw_screen *is)
+{
+   is->base.resource_create = brw_resource_create;
+   is->base.resource_from_handle = brw_resource_from_handle;
+   is->base.resource_get_handle = u_resource_get_handle_vtbl;
+   is->base.resource_destroy = u_resource_destroy_vtbl;
+   is->base.user_buffer_create = brw_user_buffer_create;
+}
diff --git a/src/gallium/drivers/i965/brw_resource.h b/src/gallium/drivers/i965/brw_resource.h
new file mode 100644
index 00000000000..3390c270d42
--- /dev/null
+++ b/src/gallium/drivers/i965/brw_resource.h
@@ -0,0 +1,151 @@
+/**************************************************************************
+ * 
+ * Copyright 2008 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 BRW_RESOURCE_H
+#define BRW_RESOURCE_H
+
+struct brw_screen;
+
+#include "util/u_transfer.h"
+#include "util/u_debug.h"
+
+#include "brw_screen.h"		/* for brw_surface */
+
+struct brw_context;
+struct brw_screen;
+
+
+struct brw_buffer {
+   struct u_resource b;
+
+   /* One of either bo or user_buffer will be non-null, depending on
+    * whether this is a hardware or user buffer.
+    */
+   struct brw_winsys_buffer *bo;
+   void *user_buffer;
+
+   /* Mapped pointer??
+    */
+   void *ptr;
+};
+
+#define BRW_MAX_TEXTURE_2D_LEVELS 11  /* max 1024x1024 */
+#define BRW_MAX_TEXTURE_3D_LEVELS  8  /* max 128x128x128 */
+
+
+
+struct brw_texture {
+   struct u_resource b;
+   struct brw_winsys_buffer *bo;
+   struct brw_surface_state ss;
+
+   unsigned *image_offset[BRW_MAX_TEXTURE_2D_LEVELS];
+   unsigned nr_images[BRW_MAX_TEXTURE_2D_LEVELS];
+   unsigned level_offset[BRW_MAX_TEXTURE_2D_LEVELS];
+
+   boolean compressed;
+   unsigned brw_target;
+   unsigned pitch;
+   unsigned tiling;
+   unsigned cpp;
+   unsigned total_height;
+
+   struct brw_surface views[2];
+};
+
+
+void brw_init_screen_resource_functions(struct brw_screen *is);
+void brw_init_resource_functions(struct brw_context *brw );
+
+extern struct u_resource_vtbl brw_buffer_vtbl;
+extern struct u_resource_vtbl brw_texture_vtbl;
+
+static INLINE struct brw_texture *brw_texture( struct pipe_resource *resource )
+{
+   struct brw_texture *tex = (struct brw_texture *)resource;
+   assert(tex->b.vtbl == &brw_texture_vtbl);
+   return tex;
+}
+
+static INLINE struct brw_buffer *brw_buffer( struct pipe_resource *resource )
+{
+   struct brw_buffer *tex = (struct brw_buffer *)resource;
+   assert(tex->b.vtbl == &brw_buffer_vtbl);
+   return tex;
+}
+
+struct pipe_resource *
+brw_texture_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template);
+
+struct pipe_resource *
+brw_texture_from_handle(struct pipe_screen * screen,
+			const struct pipe_resource *template,
+			struct winsys_handle *whandle);
+
+
+struct pipe_resource *
+brw_user_buffer_create(struct pipe_screen *screen,
+                        void *ptr,
+                        unsigned bytes,
+			unsigned usage);
+
+struct pipe_resource *
+brw_buffer_create(struct pipe_screen *screen,
+		   const struct pipe_resource *template);
+
+
+/*
+boolean
+brw_is_format_supported( struct pipe_screen *screen,
+			 enum pipe_format format,
+			 enum pipe_texture_target target,
+			 unsigned tex_usage, 
+			 unsigned geom_flags );
+*/
+
+/* Pipe buffer helpers
+ */
+static INLINE boolean
+brw_buffer_is_user_buffer( const struct pipe_resource *buf )
+{
+   return ((const struct brw_buffer *)buf)->user_buffer != NULL;
+}
+
+
+/***********************************************************************
+ * Internal functions 
+ */
+GLboolean brw_texture_layout(struct brw_screen *brw_screen,
+			     struct brw_texture *tex );
+
+void brw_update_texture( struct brw_screen *brw_screen,
+			 struct brw_texture *tex );
+
+
+
+#endif /* BRW_RESOURCE_H */
diff --git a/src/gallium/drivers/i965/brw_resource_buffer.c b/src/gallium/drivers/i965/brw_resource_buffer.c
new file mode 100644
index 00000000000..488fe13c714
--- /dev/null
+++ b/src/gallium/drivers/i965/brw_resource_buffer.c
@@ -0,0 +1,201 @@
+
+#include "util/u_memory.h"
+#include "util/u_math.h"
+
+#include "pipe/p_state.h"
+#include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+
+#include "brw_resource.h"
+#include "brw_context.h"
+#include "brw_batchbuffer.h"
+#include "brw_winsys.h"
+
+static boolean
+brw_buffer_get_handle(struct pipe_screen *screen,
+		      struct pipe_resource *resource,
+		      struct winsys_handle *handle)
+{
+   return FALSE;
+}
+
+
+static void
+brw_buffer_destroy(struct pipe_screen *screen,
+		    struct pipe_resource *resource)
+{
+   struct brw_buffer *buf = brw_buffer( resource );
+
+   bo_reference(&buf->bo, NULL);
+   FREE(buf);
+}
+
+
+static void *
+brw_buffer_transfer_map( struct pipe_context *pipe,
+			 struct pipe_transfer *transfer)
+{
+   struct brw_screen *bscreen = brw_screen(pipe->screen); 
+   struct brw_winsys_screen *sws = bscreen->sws;
+   struct brw_buffer *buf = brw_buffer(transfer->resource);
+   unsigned offset = transfer->box.x;
+   unsigned length = transfer->box.width;
+   unsigned usage = transfer->usage;
+   uint8_t *map;
+
+   if (buf->user_buffer)
+      map = buf->user_buffer;
+   else
+      map = sws->bo_map( buf->bo, 
+			 BRW_DATA_OTHER,
+			 offset,
+			 length,
+			 (usage & PIPE_TRANSFER_WRITE) ? TRUE : FALSE,
+			 (usage & PIPE_TRANSFER_DISCARD) ? TRUE : FALSE,
+			 (usage & PIPE_TRANSFER_FLUSH_EXPLICIT) ? TRUE : FALSE);
+
+   return map + offset;
+}
+
+
+static void
+brw_buffer_transfer_flush_region( struct pipe_context *pipe,
+				  struct pipe_transfer *transfer,
+				  const struct pipe_box *box)
+{
+   struct brw_screen *bscreen = brw_screen(pipe->screen); 
+   struct brw_winsys_screen *sws = bscreen->sws;
+   struct brw_buffer *buf = brw_buffer(transfer->resource);
+   unsigned offset = box->x;
+   unsigned length = box->width;
+
+   if (buf->user_buffer)
+      return;
+
+   sws->bo_flush_range( buf->bo, 
+                        offset,
+                        length );
+}
+
+
+static void
+brw_buffer_transfer_unmap( struct pipe_context *pipe,
+			   struct pipe_transfer *transfer)
+{
+   struct brw_screen *bscreen = brw_screen(pipe->screen); 
+   struct brw_winsys_screen *sws = bscreen->sws;
+   struct brw_buffer *buf = brw_buffer( transfer->resource );
+   
+   if (buf->bo)
+      sws->bo_unmap(buf->bo);
+}
+
+
+static unsigned brw_buffer_is_referenced( struct pipe_context *pipe,
+					 struct pipe_resource *resource,
+					 unsigned face,
+					 unsigned level)
+{
+   struct brw_context *brw = brw_context(pipe);
+   struct brw_winsys_buffer *batch_bo = brw->batch->buf;
+   struct brw_buffer *buf = brw_buffer(resource);
+
+   if (buf->bo == NULL)
+      return PIPE_UNREFERENCED;
+
+   if (!brw_screen(pipe->screen)->sws->bo_references( batch_bo, buf->bo ))
+      return PIPE_UNREFERENCED;
+
+   return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+}
+
+
+struct u_resource_vtbl brw_buffer_vtbl = 
+{
+   brw_buffer_get_handle,	     /* get_handle */
+   brw_buffer_destroy,		     /* resource_destroy */
+   brw_buffer_is_referenced,	     /* is_resource_referenced */
+   u_default_get_transfer,	     /* get_transfer */
+   u_default_transfer_destroy,	     /* transfer_destroy */
+   brw_buffer_transfer_map,	     /* transfer_map */
+   brw_buffer_transfer_flush_region,  /* transfer_flush_region */
+   brw_buffer_transfer_unmap,	     /* transfer_unmap */
+   u_default_transfer_inline_write   /* transfer_inline_write */
+};
+
+
+struct pipe_resource *
+brw_buffer_create(struct pipe_screen *screen,
+		  const struct pipe_resource *template)
+{
+   struct brw_screen *bscreen = brw_screen(screen);
+   struct brw_winsys_screen *sws = bscreen->sws;
+   struct brw_buffer *buf;
+   unsigned buffer_type;
+   enum pipe_error ret;
+   
+   buf = CALLOC_STRUCT(brw_buffer);
+   if (!buf)
+      return NULL;
+      
+   buf->b.b = *template;
+   buf->b.vtbl = &brw_buffer_vtbl;
+   pipe_reference_init(&buf->b.b.reference, 1);
+   buf->b.b.screen = screen;
+
+   switch (template->bind & (PIPE_BIND_VERTEX_BUFFER |
+			      PIPE_BIND_INDEX_BUFFER |
+			      PIPE_BIND_CONSTANT_BUFFER))
+   {
+   case PIPE_BIND_VERTEX_BUFFER:
+   case PIPE_BIND_INDEX_BUFFER:
+   case (PIPE_BIND_VERTEX_BUFFER|PIPE_BIND_INDEX_BUFFER):
+      buffer_type = BRW_BUFFER_TYPE_VERTEX;
+      break;
+      
+   case PIPE_BIND_CONSTANT_BUFFER:
+      buffer_type = BRW_BUFFER_TYPE_SHADER_CONSTANTS;
+      break;
+
+   default:
+      buffer_type = BRW_BUFFER_TYPE_GENERIC;
+      break;
+   }
+   
+   ret = sws->bo_alloc( sws, buffer_type,
+                        template->width0,
+			64,	/* alignment */
+                        &buf->bo );
+   if (ret != PIPE_OK)
+      return NULL;
+      
+   return &buf->b.b; 
+}
+
+
+struct pipe_resource *
+brw_user_buffer_create(struct pipe_screen *screen,
+                       void *ptr,
+                       unsigned bytes,
+		       unsigned bind)
+{
+   struct brw_buffer *buf;
+   
+   buf = CALLOC_STRUCT(brw_buffer);
+   if (!buf)
+      return NULL;
+   
+   pipe_reference_init(&buf->b.b.reference, 1);
+   buf->b.vtbl = &brw_buffer_vtbl;
+   buf->b.b.screen = screen;
+   buf->b.b.format = PIPE_FORMAT_R8_UNORM; /* ?? */
+   buf->b.b._usage = PIPE_USAGE_IMMUTABLE;
+   buf->b.b.bind = bind;
+   buf->b.b.width0 = bytes;
+   buf->b.b.height0 = 1;
+   buf->b.b.depth0 = 1;
+
+   buf->user_buffer = ptr;
+   
+   return &buf->b.b; 
+}
diff --git a/src/gallium/drivers/i965/brw_screen_texture.c b/src/gallium/drivers/i965/brw_resource_texture.c
index 17bf3152dcc..a6f27b8a413 100644
--- a/src/gallium/drivers/i965/brw_screen_texture.c
+++ b/src/gallium/drivers/i965/brw_resource_texture.c
@@ -37,9 +37,26 @@
 #include "brw_defines.h"
 #include "brw_structs.h"
 #include "brw_winsys.h"
+#include "brw_batchbuffer.h"
 #include "brw_context.h"
+#include "brw_resource.h"
 
 
+/**
+ * Subclass of pipe_transfer
+ */
+struct brw_transfer
+{
+   struct pipe_transfer base;
+
+   unsigned offset;
+};
+
+static INLINE struct brw_transfer *
+brw_transfer(struct pipe_transfer *transfer)
+{
+   return (struct brw_transfer *)transfer;
+}
 
 
 static GLuint translate_tex_target( unsigned target )
@@ -182,12 +199,176 @@ static GLuint translate_tex_format( enum pipe_format pf )
 }
 
 
+static boolean
+brw_texture_get_handle(struct pipe_screen *screen,
+                       struct pipe_resource *texture,
+                       struct winsys_handle *whandle)
+{
+   struct brw_screen *bscreen = brw_screen(screen);
+   struct brw_texture *tex = brw_texture(texture);
+   unsigned stride;
+
+   stride = tex->pitch * tex->cpp;
+
+   return bscreen->sws->bo_get_handle(tex->bo, whandle, stride);
+}
+
+
+
+static void brw_texture_destroy(struct pipe_screen *screen,
+				struct pipe_resource *pt)
+{
+   struct brw_texture *tex = brw_texture(pt);
+   bo_reference(&tex->bo, NULL);
+   FREE(pt);
+}
+
+
+
+
+static unsigned brw_texture_is_referenced( struct pipe_context *pipe,
+					   struct pipe_resource *texture,
+					   unsigned face, 
+					   unsigned level )
+{
+   struct brw_context *brw = brw_context(pipe);
+   struct brw_screen *bscreen = brw_screen(pipe->screen);
+   struct brw_winsys_buffer *batch_bo = brw->batch->buf;
+   struct brw_texture *tex = brw_texture(texture);
+   struct brw_surface *surf;
+   int i;
+
+   /* XXX: this is subject to false positives if the underlying
+    * texture BO is referenced, we can't tell whether the sub-region
+    * we care about participates in that.
+    */
+   if (bscreen->sws->bo_references( batch_bo, tex->bo ))
+      return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+
+   /* Find any view on this texture for this face/level and see if it
+    * is referenced:
+    */
+   for (i = 0; i < 2; i++) {
+      foreach (surf, &tex->views[i]) {
+         if (surf->bo == tex->bo)
+            continue;
+
+         if (surf->id.bits.face != face ||
+             surf->id.bits.level != level)
+            continue;
+         
+         if (bscreen->sws->bo_references( batch_bo, surf->bo))
+            return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+      }
+   }
+
+   return PIPE_UNREFERENCED;
+}
+
+
+/*
+ * Transfer functions
+ */
+
+
+static struct pipe_transfer * 
+brw_texture_get_transfer(struct pipe_context *context,
+			  struct pipe_resource *resource,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box)
+{
+   struct brw_texture *tex = brw_texture(resource);
+   struct pipe_transfer *transfer = CALLOC_STRUCT(pipe_transfer);
+   if (transfer == NULL)
+      return NULL;
+
+   transfer->resource = resource;
+   transfer->sr = sr;
+   transfer->usage = usage;
+   transfer->box = *box;
+   transfer->stride = tex->pitch * tex->cpp;
+
+   return transfer;
+}
+
+
+static void *
+brw_texture_transfer_map(struct pipe_context *pipe,
+                 struct pipe_transfer *transfer)
+{
+   struct pipe_resource *resource = transfer->resource;
+   struct brw_texture *tex = brw_texture(transfer->resource);
+   struct brw_winsys_screen *sws = brw_screen(pipe->screen)->sws;
+   struct pipe_subresource sr = transfer->sr;
+   struct pipe_box *box = &transfer->box;
+   enum pipe_format format = resource->format;
+   unsigned usage = transfer->usage;
+   unsigned offset;
+   char *map;
+
+   if (resource->target == PIPE_TEXTURE_CUBE) {
+      offset = tex->image_offset[sr.level][sr.face];
+   }
+   else if (resource->target == PIPE_TEXTURE_3D) {
+      offset = tex->image_offset[sr.level][box->z];
+   }
+   else {
+      offset = tex->image_offset[sr.level][0];
+      assert(sr.face == 0);
+      assert(box->z == 0);
+   }
+
+   map = sws->bo_map(tex->bo, 
+                     BRW_DATA_OTHER,
+                     0,
+                     tex->bo->size,
+                     (usage & PIPE_TRANSFER_WRITE) ? TRUE : FALSE,
+                     (usage & 0) ? TRUE : FALSE,
+                     (usage & 0) ? TRUE : FALSE);
+
+   if (!map)
+      return NULL;
+
+   return map + offset +
+      box->y / util_format_get_blockheight(format) * transfer->stride +
+      box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
+}
+
+static void
+brw_texture_transfer_unmap(struct pipe_context *pipe,
+                   struct pipe_transfer *transfer)
+{
+   struct brw_texture *tex = brw_texture(transfer->resource);
+   struct brw_winsys_screen *sws = brw_screen(pipe->screen)->sws;
+
+   sws->bo_unmap(tex->bo);
+}
+
+
+
+
+
+struct u_resource_vtbl brw_texture_vtbl = 
+{
+   brw_texture_get_handle,	      /* get_handle */
+   brw_texture_destroy,	      /* resource_destroy */
+   brw_texture_is_referenced,	      /* is_resource_referenced */
+   brw_texture_get_transfer,	      /* get_transfer */
+   u_default_transfer_destroy,	      /* transfer_destroy */
+   brw_texture_transfer_map,	      /* transfer_map */
+   u_default_transfer_flush_region,   /* transfer_flush_region */
+   brw_texture_transfer_unmap,	      /* transfer_unmap */
+   u_default_transfer_inline_write    /* transfer_inline_write */
+};
 
 
 
-static struct pipe_texture *brw_texture_create( struct pipe_screen *screen,
-						const struct pipe_texture *templ )
 
+
+struct pipe_resource *
+brw_texture_create( struct pipe_screen *screen,
+		    const struct pipe_resource *template )
 {  
    struct brw_screen *bscreen = brw_screen(screen);
    struct brw_texture *tex;
@@ -199,14 +380,15 @@ static struct pipe_texture *brw_texture_create( struct pipe_screen *screen,
    if (tex == NULL)
       return NULL;
 
-   memcpy(&tex->base, templ, sizeof *templ);
-   pipe_reference_init(&tex->base.reference, 1);
-   tex->base.screen = screen;
+   tex->b.b = *template;
+   tex->b.vtbl = &brw_texture_vtbl;
+   pipe_reference_init(&tex->b.b.reference, 1);
+   tex->b.b.screen = screen;
 
    /* XXX: compressed textures need special treatment here
     */
-   tex->cpp = util_format_get_blocksize(tex->base.format);
-   tex->compressed = util_format_is_s3tc(tex->base.format);
+   tex->cpp = util_format_get_blocksize(tex->b.b.format);
+   tex->compressed = util_format_is_s3tc(tex->b.b.format);
 
    make_empty_list(&tex->views[0]);
    make_empty_list(&tex->views[1]);
@@ -217,7 +399,7 @@ static struct pipe_texture *brw_texture_create( struct pipe_screen *screen,
        !bscreen->no_tiling) 
    {
       if (bscreen->chipset.is_965 &&
-	  util_format_is_depth_or_stencil(templ->format))
+	  util_format_is_depth_or_stencil(template->format))
 	 tex->tiling = BRW_TILING_Y;
       else
 	 tex->tiling = BRW_TILING_X;
@@ -227,14 +409,12 @@ static struct pipe_texture *brw_texture_create( struct pipe_screen *screen,
    }
 
 
-
-
    if (!brw_texture_layout( bscreen, tex ))
       goto fail;
 
    
-   if (templ->tex_usage & (PIPE_TEXTURE_USAGE_SCANOUT |
-                           PIPE_TEXTURE_USAGE_SHARED)) {
+   if (template->bind & (PIPE_BIND_SCANOUT |
+                           PIPE_BIND_SHARED)) {
       buffer_type = BRW_BUFFER_TYPE_SCANOUT;
    }
    else {
@@ -250,9 +430,9 @@ static struct pipe_texture *brw_texture_create( struct pipe_screen *screen,
       goto fail;
 
    tex->ss.ss0.mipmap_layout_mode = BRW_SURFACE_MIPMAPLAYOUT_BELOW;
-   tex->ss.ss0.surface_type = translate_tex_target(tex->base.target);
+   tex->ss.ss0.surface_type = translate_tex_target(tex->b.b.target);
 
-   format = translate_tex_format(tex->base.format);
+   format = translate_tex_format(tex->b.b.format);
    assert(format != BRW_SURFACEFORMAT_INVALID);
    tex->ss.ss0.surface_format = format;
 
@@ -264,9 +444,9 @@ static struct pipe_texture *brw_texture_create( struct pipe_screen *screen,
    /* XXX: what happens when tex->bo->offset changes???
     */
    tex->ss.ss1.base_addr = 0; /* reloc */
-   tex->ss.ss2.mip_count = tex->base.last_level;
-   tex->ss.ss2.width = tex->base.width0 - 1;
-   tex->ss.ss2.height = tex->base.height0 - 1;
+   tex->ss.ss2.mip_count = tex->b.b.last_level;
+   tex->ss.ss2.width = tex->b.b.width0 - 1;
+   tex->ss.ss2.height = tex->b.b.height0 - 1;
 
    switch (tex->tiling) {
    case BRW_TILING_NONE:
@@ -284,11 +464,11 @@ static struct pipe_texture *brw_texture_create( struct pipe_screen *screen,
    }
 
    tex->ss.ss3.pitch = (tex->pitch * tex->cpp) - 1;
-   tex->ss.ss3.depth = tex->base.depth0 - 1;
+   tex->ss.ss3.depth = tex->b.b.depth0 - 1;
 
    tex->ss.ss4.min_lod = 0;
  
-   if (tex->base.target == PIPE_TEXTURE_CUBE) {
+   if (tex->b.b.target == PIPE_TEXTURE_CUBE) {
       tex->ss.ss0.cube_pos_x = 1;
       tex->ss.ss0.cube_pos_y = 1;
       tex->ss.ss0.cube_pos_z = 1;
@@ -297,7 +477,7 @@ static struct pipe_texture *brw_texture_create( struct pipe_screen *screen,
       tex->ss.ss0.cube_neg_z = 1;
    }
 
-   return &tex->base;
+   return &tex->b.b;
 
 fail:
    bo_reference(&tex->bo, NULL);
@@ -305,9 +485,10 @@ fail:
    return NULL;
 }
 
-static struct pipe_texture * 
+
+struct pipe_resource * 
 brw_texture_from_handle(struct pipe_screen *screen,
-                        const struct pipe_texture *templ,
+                        const struct pipe_resource *template,
                         struct winsys_handle *whandle)
 {
    struct brw_screen *bscreen = brw_screen(screen);
@@ -317,12 +498,12 @@ brw_texture_from_handle(struct pipe_screen *screen,
    unsigned pitch;
    GLuint format;
 
-   if (templ->target != PIPE_TEXTURE_2D ||
-       templ->last_level != 0 ||
-       templ->depth0 != 1)
+   if (template->target != PIPE_TEXTURE_2D ||
+       template->last_level != 0 ||
+       template->depth0 != 1)
       return NULL;
 
-   if (util_format_is_s3tc(templ->format))
+   if (util_format_is_s3tc(template->format))
       return NULL;
 
    tex = CALLOC_STRUCT(brw_texture);
@@ -332,13 +513,14 @@ brw_texture_from_handle(struct pipe_screen *screen,
    if (bscreen->sws->bo_from_handle(bscreen->sws, whandle, &pitch, &tiling, &buffer) != PIPE_OK)
       goto fail;
 
-   memcpy(&tex->base, templ, sizeof *templ);
-   pipe_reference_init(&tex->base.reference, 1);
-   tex->base.screen = screen;
+   tex->b.b = *template;
+   tex->b.vtbl = &brw_texture_vtbl;
+   pipe_reference_init(&tex->b.b.reference, 1);
+   tex->b.b.screen = screen;
 
    /* XXX: cpp vs. blocksize
     */
-   tex->cpp = util_format_get_blocksize(tex->base.format);
+   tex->cpp = util_format_get_blocksize(tex->b.b.format);
    tex->tiling = tiling;
 
    make_empty_list(&tex->views[0]);
@@ -362,11 +544,12 @@ brw_texture_from_handle(struct pipe_screen *screen,
 #endif
 
    tex->ss.ss0.mipmap_layout_mode = BRW_SURFACE_MIPMAPLAYOUT_BELOW;
-   tex->ss.ss0.surface_type = translate_tex_target(tex->base.target);
+   tex->ss.ss0.surface_type = translate_tex_target(tex->b.b.target);
 
-   format = translate_tex_format(tex->base.format);
+   format = translate_tex_format(tex->b.b.format);
    assert(format != BRW_SURFACEFORMAT_INVALID);
    tex->ss.ss0.surface_format = format;
+   assert(tex->ss.ss0.surface_format != BRW_SURFACEFORMAT_INVALID);
 
    /* This is ok for all textures with channel width 8bit or less:
     */
@@ -376,9 +559,9 @@ brw_texture_from_handle(struct pipe_screen *screen,
    /* XXX: what happens when tex->bo->offset changes???
     */
    tex->ss.ss1.base_addr = 0; /* reloc */
-   tex->ss.ss2.mip_count = tex->base.last_level;
-   tex->ss.ss2.width = tex->base.width0 - 1;
-   tex->ss.ss2.height = tex->base.height0 - 1;
+   tex->ss.ss2.mip_count = tex->b.b.last_level;
+   tex->ss.ss2.width = tex->b.b.width0 - 1;
+   tex->ss.ss2.height = tex->b.b.height0 - 1;
 
    switch (tex->tiling) {
    case BRW_TILING_NONE:
@@ -396,187 +579,25 @@ brw_texture_from_handle(struct pipe_screen *screen,
    }
 
    tex->ss.ss3.pitch = (tex->pitch * tex->cpp) - 1;
-   tex->ss.ss3.depth = tex->base.depth0 - 1;
+   tex->ss.ss3.depth = tex->b.b.depth0 - 1;
 
    tex->ss.ss4.min_lod = 0;
 
-   return &tex->base;
+   return &tex->b.b;
 
 fail:
    FREE(tex);
    return NULL;
 }
 
-static boolean
-brw_texture_get_handle(struct pipe_screen *screen,
-                       struct pipe_texture *texture,
-                       struct winsys_handle *whandle)
-{
-   struct brw_screen *bscreen = brw_screen(screen);
-   struct brw_texture *tex = brw_texture(texture);
-   unsigned stride;
-
-   stride = tex->pitch * tex->cpp;
 
-   return bscreen->sws->bo_get_handle(tex->bo, whandle, stride);
-}
-
-
-
-static void brw_texture_destroy(struct pipe_texture *pt)
-{
-   struct brw_texture *tex = brw_texture(pt);
-   bo_reference(&tex->bo, NULL);
-   FREE(pt);
-}
-
-
-static boolean brw_is_format_supported( struct pipe_screen *screen,
-					enum pipe_format format,
-					enum pipe_texture_target target,
-					unsigned tex_usage, 
-					unsigned geom_flags )
+#if 0
+boolean brw_is_format_supported( struct pipe_screen *screen,
+				 enum pipe_format format,
+				 enum pipe_texture_target target,
+				 unsigned tex_usage, 
+				 unsigned geom_flags )
 {
    return translate_tex_format(format) != BRW_SURFACEFORMAT_INVALID;
 }
-
-
-boolean brw_is_texture_referenced_by_bo( struct brw_screen *brw_screen,
-                                      struct pipe_texture *texture,
-                                      unsigned face, 
-                                      unsigned level,
-                                      struct brw_winsys_buffer *bo )
-{
-   struct brw_texture *tex = brw_texture(texture);
-   struct brw_surface *surf;
-   int i;
-
-   /* XXX: this is subject to false positives if the underlying
-    * texture BO is referenced, we can't tell whether the sub-region
-    * we care about participates in that.
-    */
-   if (brw_screen->sws->bo_references( bo, tex->bo ))
-      return TRUE;
-
-   /* Find any view on this texture for this face/level and see if it
-    * is referenced:
-    */
-   for (i = 0; i < 2; i++) {
-      foreach (surf, &tex->views[i]) {
-         if (surf->bo == tex->bo)
-            continue;
-
-         if (surf->id.bits.face != face ||
-             surf->id.bits.level != level)
-            continue;
-         
-         if (brw_screen->sws->bo_references( bo, surf->bo))
-            return TRUE;
-      }
-   }
-
-   return FALSE;
-}
-
-
-/*
- * Transfer functions
- */
-
-static struct pipe_transfer*
-brw_get_tex_transfer(struct pipe_context *pipe,
-                     struct pipe_texture *texture,
-                     unsigned face, unsigned level, unsigned zslice,
-                     enum pipe_transfer_usage usage, unsigned x, unsigned y,
-                     unsigned w, unsigned h)
-{
-   struct brw_texture *tex = brw_texture(texture);
-   struct brw_transfer *trans;
-   unsigned offset;  /* in bytes */
-
-   if (texture->target == PIPE_TEXTURE_CUBE) {
-      offset = tex->image_offset[level][face];
-   } else if (texture->target == PIPE_TEXTURE_3D) {
-      offset = tex->image_offset[level][zslice];
-   } else {
-      offset = tex->image_offset[level][0];
-      assert(face == 0);
-      assert(zslice == 0);
-   }
-
-   trans = CALLOC_STRUCT(brw_transfer);
-   if (trans) {
-      pipe_texture_reference(&trans->base.texture, texture);
-      trans->base.x = x;
-      trans->base.y = y;
-      trans->base.width = w;
-      trans->base.height = h;
-      trans->base.stride = tex->pitch * tex->cpp;
-      trans->offset = offset;
-      trans->base.usage = usage;
-   }
-   return &trans->base;
-}
-
-static void *
-brw_transfer_map(struct pipe_context *pipe,
-                 struct pipe_transfer *transfer)
-{
-   struct brw_texture *tex = brw_texture(transfer->texture);
-   struct brw_winsys_screen *sws = brw_screen(pipe->screen)->sws;
-   char *map;
-   unsigned usage = transfer->usage;
-
-   map = sws->bo_map(tex->bo, 
-                     BRW_DATA_OTHER,
-                     0,
-                     tex->bo->size,
-                     (usage & PIPE_TRANSFER_WRITE) ? TRUE : FALSE,
-                     (usage & 0) ? TRUE : FALSE,
-                     (usage & 0) ? TRUE : FALSE);
-
-   if (!map)
-      return NULL;
-
-   /* XXX: blocksize and compressed textures
-    */
-   return map + brw_transfer(transfer)->offset +
-      transfer->y /* / transfer->block.height */ * transfer->stride +
-      transfer->x /* / transfer->block.width */ * brw_texture(transfer->texture)->cpp;
-}
-
-static void
-brw_transfer_unmap(struct pipe_context *pipe,
-                   struct pipe_transfer *transfer)
-{
-   struct brw_texture *tex = brw_texture(transfer->texture);
-   struct brw_winsys_screen *sws = brw_screen(pipe->screen)->sws;
-
-   sws->bo_unmap(tex->bo);
-}
-
-static void
-brw_tex_transfer_destroy(struct pipe_context *pipe,
-                         struct pipe_transfer *trans)
-{
-   pipe_texture_reference(&trans->texture, NULL);
-   FREE(trans);
-}
-
-
-void brw_tex_init( struct brw_context *brw )
-{
-   brw->base.get_tex_transfer = brw_get_tex_transfer;
-   brw->base.transfer_map = brw_transfer_map;
-   brw->base.transfer_unmap = brw_transfer_unmap;
-   brw->base.tex_transfer_destroy = brw_tex_transfer_destroy;
-}
-
-void brw_screen_tex_init( struct brw_screen *brw_screen )
-{
-   brw_screen->base.is_format_supported = brw_is_format_supported;
-   brw_screen->base.texture_create = brw_texture_create;
-   brw_screen->base.texture_from_handle = brw_texture_from_handle;
-   brw_screen->base.texture_get_handle = brw_texture_get_handle;
-   brw_screen->base.texture_destroy = brw_texture_destroy;
-}
+#endif
diff --git a/src/gallium/drivers/i965/brw_screen_tex_layout.c b/src/gallium/drivers/i965/brw_resource_texture_layout.c
index 894f4bea401..2187bdd82ce 100644
--- a/src/gallium/drivers/i965/brw_screen_tex_layout.c
+++ b/src/gallium/drivers/i965/brw_resource_texture_layout.c
@@ -30,7 +30,7 @@
 #include "util/u_math.h"
 #include "util/u_memory.h"
 
-#include "brw_screen.h"
+#include "brw_resource.h"
 #include "brw_debug.h"
 #include "brw_winsys.h"
 
@@ -143,14 +143,14 @@ static void brw_layout_2d( struct brw_texture *tex )
    GLuint level;
    GLuint x = 0;
    GLuint y = 0;
-   GLuint width = tex->base.width0;
-   GLuint height = tex->base.height0;
+   GLuint width = tex->b.b.width0;
+   GLuint height = tex->b.b.height0;
 
-   tex->pitch = tex->base.width0;
-   brw_tex_alignment_unit(tex->base.format, &align_w, &align_h);
+   tex->pitch = tex->b.b.width0;
+   brw_tex_alignment_unit(tex->b.b.format, &align_w, &align_h);
 
    if (tex->compressed) {
-       tex->pitch = align(tex->base.width0, align_w);
+       tex->pitch = align(tex->b.b.width0, align_w);
    }
 
    /* May need to adjust pitch to accomodate the placement of
@@ -158,15 +158,15 @@ static void brw_layout_2d( struct brw_texture *tex )
     * constraints of mipmap placement push the right edge of the
     * 2nd mipmap out past the width of its parent.
     */
-   if (tex->base.last_level > 0) {
+   if (tex->b.b.last_level > 0) {
        GLuint mip1_width;
 
        if (tex->compressed) {
-          mip1_width = (align(u_minify(tex->base.width0, 1), align_w) + 
-                        align(u_minify(tex->base.width0, 2), align_w));
+          mip1_width = (align(u_minify(tex->b.b.width0, 1), align_w) + 
+                        align(u_minify(tex->b.b.width0, 2), align_w));
        } else {
-          mip1_width = (align(u_minify(tex->base.width0, 1), align_w) + 
-                        u_minify(tex->base.width0, 2));
+          mip1_width = (align(u_minify(tex->b.b.width0, 1), align_w) + 
+                        u_minify(tex->b.b.width0, 2));
        }
 
        if (mip1_width > tex->pitch) {
@@ -180,7 +180,7 @@ static void brw_layout_2d( struct brw_texture *tex )
    tex->pitch = brw_tex_pitch_align (tex, tex->pitch);
    tex->total_height = 0;
 
-   for ( level = 0 ; level <= tex->base.last_level ; level++ ) {
+   for ( level = 0 ; level <= tex->b.b.last_level ; level++ ) {
       GLuint img_height;
 
       brw_tex_set_level_info(tex, level, 1, x, y, width, height, 1);
@@ -218,28 +218,28 @@ brw_layout_cubemap_idgng( struct brw_texture *tex )
    GLuint level;
    GLuint x = 0;
    GLuint y = 0;
-   GLuint width = tex->base.width0;
-   GLuint height = tex->base.height0;
+   GLuint width = tex->b.b.width0;
+   GLuint height = tex->b.b.height0;
    GLuint qpitch = 0;
    GLuint y_pitch = 0;
 
-   tex->pitch = tex->base.width0;
-   brw_tex_alignment_unit(tex->base.format, &align_w, &align_h);
+   tex->pitch = tex->b.b.width0;
+   brw_tex_alignment_unit(tex->b.b.format, &align_w, &align_h);
    y_pitch = align(height, align_h);
 
    if (tex->compressed) {
-      tex->pitch = align(tex->base.width0, align_w);
+      tex->pitch = align(tex->b.b.width0, align_w);
    }
 
-   if (tex->base.last_level != 0) {
+   if (tex->b.b.last_level != 0) {
       GLuint mip1_width;
 
       if (tex->compressed) {
-	 mip1_width = (align(u_minify(tex->base.width0, 1), align_w) +
-		       align(u_minify(tex->base.width0, 2), align_w));
+	 mip1_width = (align(u_minify(tex->b.b.width0, 1), align_w) +
+		       align(u_minify(tex->b.b.width0, 2), align_w));
       } else {
-	 mip1_width = (align(u_minify(tex->base.width0, 1), align_w) +
-		       u_minify(tex->base.width0, 2));
+	 mip1_width = (align(u_minify(tex->b.b.width0, 1), align_w) +
+		       u_minify(tex->b.b.width0, 2));
       }
 
       if (mip1_width > tex->pitch) {
@@ -267,7 +267,7 @@ brw_layout_cubemap_idgng( struct brw_texture *tex )
 			   11 * align_h) * 6;
    }
 
-   for (level = 0; level <= tex->base.last_level; level++) {
+   for (level = 0; level <= tex->b.b.last_level; level++) {
       GLuint img_height;
       GLuint nr_images = 6;
       GLuint q = 0;
@@ -300,9 +300,9 @@ brw_layout_cubemap_idgng( struct brw_texture *tex )
 static boolean
 brw_layout_3d_cube( struct brw_texture *tex )
 {
-   GLuint width  = tex->base.width0;
-   GLuint height = tex->base.height0;
-   GLuint depth = tex->base.depth0;
+   GLuint width  = tex->b.b.width0;
+   GLuint height = tex->b.b.height0;
+   GLuint depth = tex->b.b.depth0;
    GLuint pack_x_pitch, pack_x_nr;
    GLuint pack_y_pitch;
    GLuint level;
@@ -310,21 +310,21 @@ brw_layout_3d_cube( struct brw_texture *tex )
    GLuint align_w = 4;
 
    tex->total_height = 0;
-   brw_tex_alignment_unit(tex->base.format, &align_w, &align_h);
+   brw_tex_alignment_unit(tex->b.b.format, &align_w, &align_h);
 
    if (tex->compressed) {
       tex->pitch = align(width, align_w);
       pack_y_pitch = (height + 3) / 4;
    } else {
-      tex->pitch = brw_tex_pitch_align(tex, tex->base.width0);
-      pack_y_pitch = align(tex->base.height0, align_h);
+      tex->pitch = brw_tex_pitch_align(tex, tex->b.b.width0);
+      pack_y_pitch = align(tex->b.b.height0, align_h);
    }
 
    pack_x_pitch = width;
    pack_x_nr = 1;
 
-   for (level = 0 ; level <= tex->base.last_level ; level++) {
-      GLuint nr_images = tex->base.target == PIPE_TEXTURE_3D ? depth : 6;
+   for (level = 0 ; level <= tex->b.b.last_level ; level++) {
+      GLuint nr_images = tex->b.b.target == PIPE_TEXTURE_3D ? depth : 6;
       GLint x = 0;
       GLint y = 0;
       GLint q, j;
@@ -375,7 +375,7 @@ brw_layout_3d_cube( struct brw_texture *tex )
     * memory.  As a result, the docs say in Surface Padding Requirements:
     * Sampling Engine Surfaces that two extra rows of padding are required.
     */
-   if (tex->base.target == PIPE_TEXTURE_CUBE)
+   if (tex->b.b.target == PIPE_TEXTURE_CUBE)
       tex->total_height += 2;
 
    return TRUE;
@@ -386,7 +386,7 @@ brw_layout_3d_cube( struct brw_texture *tex )
 GLboolean brw_texture_layout(struct brw_screen *brw_screen,
 			     struct brw_texture *tex )
 {
-   switch (tex->base.target) {
+   switch (tex->b.b.target) {
    case PIPE_TEXTURE_CUBE:
       if (brw_screen->chipset.is_igdng)
 	 brw_layout_cubemap_idgng( tex );
diff --git a/src/gallium/drivers/i965/brw_screen.c b/src/gallium/drivers/i965/brw_screen.c
index ba30e63f20c..0a7151bde44 100644
--- a/src/gallium/drivers/i965/brw_screen.c
+++ b/src/gallium/drivers/i965/brw_screen.c
@@ -35,6 +35,7 @@
 #include "brw_screen.h"
 #include "brw_winsys.h"
 #include "brw_debug.h"
+#include "brw_resource.h"
 
 #ifdef DEBUG
 static const struct debug_named_value debug_names[] = {
@@ -275,9 +276,9 @@ brw_is_format_supported(struct pipe_screen *screen,
    const enum pipe_format *list;
    uint i;
 
-   if (tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL)
+   if (tex_usage & PIPE_BIND_DEPTH_STENCIL)
       list = depth_supported;
-   else if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
+   else if (tex_usage & PIPE_BIND_RENDER_TARGET)
       list = render_supported;
    else
       list = tex_supported;
@@ -406,9 +407,8 @@ brw_create_screen(struct brw_winsys_screen *sws, uint pci_id)
    bscreen->base.fence_signalled = brw_fence_signalled;
    bscreen->base.fence_finish = brw_fence_finish;
 
-   brw_screen_tex_init(bscreen);
+   brw_init_screen_resource_functions(bscreen);
    brw_screen_tex_surface_init(bscreen);
-   brw_screen_buffer_init(bscreen);
 
    bscreen->no_tiling = debug_get_option("BRW_NO_TILING", FALSE) != NULL;
    
diff --git a/src/gallium/drivers/i965/brw_screen.h b/src/gallium/drivers/i965/brw_screen.h
index e3a7c64d489..522a3bf8995 100644
--- a/src/gallium/drivers/i965/brw_screen.h
+++ b/src/gallium/drivers/i965/brw_screen.h
@@ -48,30 +48,6 @@ struct brw_screen
    boolean no_tiling;
 };
 
-/**
- * Subclass of pipe_transfer
- */
-struct brw_transfer
-{
-   struct pipe_transfer base;
-
-   unsigned offset;
-};
-
-struct brw_buffer
-{
-   struct pipe_buffer base;
-
-   /* One of either bo or user_buffer will be non-null, depending on
-    * whether this is a hardware or user buffer.
-    */
-   struct brw_winsys_buffer *bo;
-   void *user_buffer;
-
-   /* Mapped pointer??
-    */
-   void *ptr;
-};
 
 
 union brw_surface_id {
@@ -100,31 +76,6 @@ struct brw_surface
 };
 
 
-#define BRW_MAX_TEXTURE_2D_LEVELS 11  /* max 1024x1024 */
-#define BRW_MAX_TEXTURE_3D_LEVELS  8  /* max 128x128x128 */
-
-
-struct brw_texture
-{
-   struct pipe_texture base;
-   struct brw_winsys_buffer *bo;
-   struct brw_surface_state ss;
-
-   unsigned *image_offset[BRW_MAX_TEXTURE_2D_LEVELS];
-   unsigned nr_images[BRW_MAX_TEXTURE_2D_LEVELS];
-   unsigned level_offset[BRW_MAX_TEXTURE_2D_LEVELS];
-
-   boolean compressed;
-   unsigned brw_target;
-   unsigned pitch;
-   unsigned tiling;
-   unsigned cpp;
-   unsigned total_height;
-
-   struct brw_surface views[2];
-};
-
-
 
 /*
  * Cast wrappers
@@ -135,11 +86,6 @@ brw_screen(struct pipe_screen *pscreen)
    return (struct brw_screen *) pscreen;
 }
 
-static INLINE struct brw_transfer *
-brw_transfer(struct pipe_transfer *transfer)
-{
-   return (struct brw_transfer *)transfer;
-}
 
 static INLINE struct brw_surface *
 brw_surface(struct pipe_surface *surface)
@@ -147,60 +93,10 @@ brw_surface(struct pipe_surface *surface)
    return (struct brw_surface *)surface;
 }
 
-static INLINE struct brw_buffer *
-brw_buffer(struct pipe_buffer *buffer)
-{
-   return (struct brw_buffer *)buffer;
-}
-
-static INLINE struct brw_texture *
-brw_texture(struct pipe_texture *texture)
-{
-   return (struct brw_texture *)texture;
-}
-
-
-/* Pipe buffer helpers
- */
-static INLINE boolean
-brw_buffer_is_user_buffer( const struct pipe_buffer *buf )
-{
-   return ((const struct brw_buffer *)buf)->user_buffer != NULL;
-}
-
 unsigned
 brw_surface_pitch( const struct pipe_surface *surface );
 
-/***********************************************************************
- * Internal functions 
- */
-GLboolean brw_texture_layout(struct brw_screen *brw_screen,
-			     struct brw_texture *tex );
-
-void brw_update_texture( struct brw_screen *brw_screen,
-			 struct brw_texture *tex );
-
-
-/* brw_screen_texture.h
- */
-struct brw_context;
-void brw_tex_init( struct brw_context *brw );
-void brw_screen_tex_init( struct brw_screen *brw_screen );
 void brw_screen_tex_surface_init( struct brw_screen *brw_screen );
 
-void brw_screen_buffer_init(struct brw_screen *brw_screen);
-
-
-boolean brw_is_texture_referenced_by_bo( struct brw_screen *brw_screen,
-                                         struct pipe_texture *texture,
-                                         unsigned face, 
-                                         unsigned level,
-                                         struct brw_winsys_buffer *bo );
-
-boolean brw_is_buffer_referenced_by_bo( struct brw_screen *brw_screen,
-                                        struct pipe_buffer *buffer,
-                                        struct brw_winsys_buffer *bo );
-
-
 
 #endif /* BRW_SCREEN_H */
diff --git a/src/gallium/drivers/i965/brw_screen_buffers.c b/src/gallium/drivers/i965/brw_screen_buffers.c
deleted file mode 100644
index 0b38885f40c..00000000000
--- a/src/gallium/drivers/i965/brw_screen_buffers.c
+++ /dev/null
@@ -1,202 +0,0 @@
-
-#include "util/u_memory.h"
-#include "util/u_math.h"
-
-#include "pipe/p_state.h"
-#include "pipe/p_defines.h"
-#include "util/u_inlines.h"
-
-#include "brw_screen.h"
-#include "brw_winsys.h"
-
-
-
-static void *
-brw_buffer_map_range( struct pipe_screen *screen,
-                      struct pipe_buffer *buffer,
-                      unsigned offset,
-                      unsigned length,
-                      unsigned usage )
-{
-   struct brw_screen *bscreen = brw_screen(screen); 
-   struct brw_winsys_screen *sws = bscreen->sws;
-   struct brw_buffer *buf = brw_buffer( buffer );
-
-   if (buf->user_buffer)
-      return buf->user_buffer;
-
-   return sws->bo_map( buf->bo, 
-                       BRW_DATA_OTHER,
-                       offset,
-                       length,
-                       (usage & PIPE_BUFFER_USAGE_CPU_WRITE) ? TRUE : FALSE,
-                       (usage & PIPE_BUFFER_USAGE_DISCARD) ? TRUE : FALSE,
-                       (usage & PIPE_BUFFER_USAGE_FLUSH_EXPLICIT) ? TRUE : FALSE);
-}
-
-static void *
-brw_buffer_map( struct pipe_screen *screen,
-                struct pipe_buffer *buffer,
-                unsigned usage )
-{
-   struct brw_screen *bscreen = brw_screen(screen); 
-   struct brw_winsys_screen *sws = bscreen->sws;
-   struct brw_buffer *buf = brw_buffer( buffer );
-
-   if (buf->user_buffer)
-      return buf->user_buffer;
-
-   return sws->bo_map( buf->bo, 
-                       BRW_DATA_OTHER,
-                       0,
-                       buf->base.size,
-                       (usage & PIPE_BUFFER_USAGE_CPU_WRITE) ? TRUE : FALSE,
-                       FALSE,
-                       FALSE);
-}
-
-
-static void 
-brw_buffer_flush_mapped_range( struct pipe_screen *screen,
-                               struct pipe_buffer *buffer,
-                               unsigned offset,
-                               unsigned length )
-{
-   struct brw_screen *bscreen = brw_screen(screen); 
-   struct brw_winsys_screen *sws = bscreen->sws;
-   struct brw_buffer *buf = brw_buffer( buffer );
-
-   if (buf->user_buffer)
-      return;
-
-   sws->bo_flush_range( buf->bo, 
-                        offset,
-                        length );
-}
-
-
-static void 
-brw_buffer_unmap( struct pipe_screen *screen,
-                   struct pipe_buffer *buffer )
-{
-   struct brw_screen *bscreen = brw_screen(screen); 
-   struct brw_winsys_screen *sws = bscreen->sws;
-   struct brw_buffer *buf = brw_buffer( buffer );
-   
-   if (buf->bo)
-      sws->bo_unmap(buf->bo);
-}
-
-static void
-brw_buffer_destroy( struct pipe_buffer *buffer )
-{
-   struct brw_buffer *buf = brw_buffer( buffer );
-
-   assert(!p_atomic_read(&buffer->reference.count));
-
-   bo_reference(&buf->bo, NULL);
-   FREE(buf);
-}
-
-
-static struct pipe_buffer *
-brw_buffer_create(struct pipe_screen *screen,
-                   unsigned alignment,
-                   unsigned usage,
-                   unsigned size)
-{
-   struct brw_screen *bscreen = brw_screen(screen);
-   struct brw_winsys_screen *sws = bscreen->sws;
-   struct brw_buffer *buf;
-   unsigned buffer_type;
-   enum pipe_error ret;
-   
-   buf = CALLOC_STRUCT(brw_buffer);
-   if (!buf)
-      return NULL;
-      
-   pipe_reference_init(&buf->base.reference, 1);
-   buf->base.screen = screen;
-   buf->base.alignment = alignment;
-   buf->base.usage = usage;
-   buf->base.size = size;
-
-   switch (usage & (PIPE_BUFFER_USAGE_VERTEX |
-                    PIPE_BUFFER_USAGE_INDEX |
-                    PIPE_BUFFER_USAGE_PIXEL |
-                    PIPE_BUFFER_USAGE_CONSTANT))
-   {
-   case PIPE_BUFFER_USAGE_VERTEX:
-   case PIPE_BUFFER_USAGE_INDEX:
-   case (PIPE_BUFFER_USAGE_VERTEX|PIPE_BUFFER_USAGE_INDEX):
-      buffer_type = BRW_BUFFER_TYPE_VERTEX;
-      break;
-      
-   case PIPE_BUFFER_USAGE_PIXEL:
-      buffer_type = BRW_BUFFER_TYPE_PIXEL;
-      break;
-
-   case PIPE_BUFFER_USAGE_CONSTANT:
-      buffer_type = BRW_BUFFER_TYPE_SHADER_CONSTANTS;
-      break;
-
-   default:
-      buffer_type = BRW_BUFFER_TYPE_GENERIC;
-      break;
-   }
-   
-   ret = sws->bo_alloc( sws, buffer_type,
-                        size, alignment,
-                        &buf->bo );
-   if (ret != PIPE_OK)
-      return NULL;
-      
-   return &buf->base; 
-}
-
-
-static struct pipe_buffer *
-brw_user_buffer_create(struct pipe_screen *screen,
-                       void *ptr,
-                       unsigned bytes)
-{
-   struct brw_buffer *buf;
-   
-   buf = CALLOC_STRUCT(brw_buffer);
-   if (!buf)
-      return NULL;
-      
-   buf->user_buffer = ptr;
-   
-   pipe_reference_init(&buf->base.reference, 1);
-   buf->base.screen = screen;
-   buf->base.alignment = 1;
-   buf->base.usage = 0;
-   buf->base.size = bytes;
-   
-   return &buf->base; 
-}
-
-
-boolean brw_is_buffer_referenced_by_bo( struct brw_screen *brw_screen,
-                                     struct pipe_buffer *buffer,
-                                     struct brw_winsys_buffer *bo )
-{
-   struct brw_buffer *buf = brw_buffer(buffer);
-   if (buf->bo == NULL)
-      return FALSE;
-
-   return brw_screen->sws->bo_references( bo, buf->bo );
-}
-
-   
-void brw_screen_buffer_init(struct brw_screen *brw_screen)
-{
-   brw_screen->base.buffer_create = brw_buffer_create;
-   brw_screen->base.user_buffer_create = brw_user_buffer_create;
-   brw_screen->base.buffer_map = brw_buffer_map;
-   brw_screen->base.buffer_map_range = brw_buffer_map_range;
-   brw_screen->base.buffer_flush_mapped_range = brw_buffer_flush_mapped_range;
-   brw_screen->base.buffer_unmap = brw_buffer_unmap;
-   brw_screen->base.buffer_destroy = brw_buffer_destroy;
-}
diff --git a/src/gallium/drivers/i965/brw_screen_surface.c b/src/gallium/drivers/i965/brw_screen_surface.c
index 904df813dda..f288fdbcd37 100644
--- a/src/gallium/drivers/i965/brw_screen_surface.c
+++ b/src/gallium/drivers/i965/brw_screen_surface.c
@@ -36,6 +36,7 @@
 #include "pipe/p_screen.h"
 #include "brw_screen.h"
 #include "brw_defines.h"
+#include "brw_resource.h"
 #include "brw_winsys.h"
 
 enum {
@@ -138,9 +139,9 @@ static struct brw_surface *create_in_place_view( struct brw_screen *brw_screen,
     */
    assert(id.bits.zslice == 0);
 
-   surface->base.format = tex->base.format;
-   surface->base.width = u_minify(tex->base.width0, id.bits.level);
-   surface->base.height = u_minify(tex->base.height0, id.bits.level);
+   surface->base.format = tex->b.b.format;
+   surface->base.width = u_minify(tex->b.b.width0, id.bits.level);
+   surface->base.height = u_minify(tex->b.b.height0, id.bits.level);
    surface->base.offset = tex->image_offset[id.bits.level][id.bits.face];
    surface->base.usage = usage;
    surface->base.zslice = id.bits.zslice;
@@ -152,7 +153,7 @@ static struct brw_surface *create_in_place_view( struct brw_screen *brw_screen,
    surface->tiling = tex->tiling;
 
    bo_reference( &surface->bo, tex->bo );
-   pipe_texture_reference( &surface->base.texture, &tex->base );
+   pipe_resource_reference( &surface->base.texture, &tex->b.b );
 
    surface->ss.ss0.surface_format = tex->ss.ss0.surface_format;
    surface->ss.ss0.surface_type = BRW_SURFACE_2D;
@@ -198,7 +199,7 @@ static struct brw_surface *create_in_place_view( struct brw_screen *brw_screen,
 /* Get a surface which is view into a texture 
  */
 static struct pipe_surface *brw_get_tex_surface(struct pipe_screen *screen,
-						struct pipe_texture *pt,
+						struct pipe_resource *pt,
 						unsigned face, unsigned level,
 						unsigned zslice,
 						unsigned usage )
@@ -246,7 +247,7 @@ static void brw_tex_surface_destroy( struct pipe_surface *surf )
     */
    remove_from_list(surface);
    bo_reference(&surface->bo, NULL);
-   pipe_texture_reference( &surface->base.texture, NULL );
+   pipe_resource_reference( &surface->base.texture, NULL );
 
 
    FREE(surface);
diff --git a/src/gallium/drivers/i965/brw_util.c b/src/gallium/drivers/i965/brw_util.c
deleted file mode 100644
index 1fd2e297137..00000000000
--- a/src/gallium/drivers/i965/brw_util.c
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- Copyright (C) Intel Corp.  2006.  All Rights Reserved.
- Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
- develop this 3D driver.
- 
- 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, sublicense, 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 NONINFRINGEMENT.
- IN NO EVENT SHALL THE COPYRIGHT OWNER(S) 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.
- 
- **********************************************************************/
- /*
-  * Authors:
-  *   Keith Whitwell <keith@tungstengraphics.com>
-  */
-         
-
-
-
-
-
diff --git a/src/gallium/drivers/i965/brw_vs_surface_state.c b/src/gallium/drivers/i965/brw_vs_surface_state.c
index 004e3cb4e6f..424bb0d0dfb 100644
--- a/src/gallium/drivers/i965/brw_vs_surface_state.c
+++ b/src/gallium/drivers/i965/brw_vs_surface_state.c
@@ -82,7 +82,7 @@ brw_update_vs_constant_surface( struct brw_context *brw,
                                 GLuint surf)
 {
    struct brw_surface_key key;
-   struct pipe_buffer *cb = brw->curr.vs_constants;
+   struct pipe_resource *cb = brw->curr.vs_constants;
    enum pipe_error ret;
 
    assert(surf == 0);
diff --git a/src/gallium/drivers/i965/brw_wm.c b/src/gallium/drivers/i965/brw_wm.c
index 7ed2378ec04..5d66e61fbc1 100644
--- a/src/gallium/drivers/i965/brw_wm.c
+++ b/src/gallium/drivers/i965/brw_wm.c
@@ -35,6 +35,7 @@
 #include "brw_wm.h"
 #include "brw_state.h"
 #include "brw_debug.h"
+#include "brw_resource.h"
 #include "brw_pipe_rast.h"
 
 
@@ -254,10 +255,10 @@ static void brw_wm_populate_key( struct brw_context *brw,
    for (i = 0; i < brw->curr.num_fragment_sampler_views; i++) {
       const struct brw_texture *tex = brw_texture(brw->curr.fragment_sampler_views[i]->texture);
 	 
-      if (tex->base.format == PIPE_FORMAT_UYVY)
+      if (tex->b.b.format == PIPE_FORMAT_UYVY)
 	 key->yuvtex_mask |= 1 << i;
 
-      if (tex->base.format == PIPE_FORMAT_YUYV)
+      if (tex->b.b.format == PIPE_FORMAT_YUYV)
 	 key->yuvtex_swap_mask |= 1 << i;
 
       /* XXX: shadow texture
diff --git a/src/gallium/drivers/i965/brw_wm_constant_buffer.c b/src/gallium/drivers/i965/brw_wm_constant_buffer.c
index 6434c6acf73..df5cd0398c9 100644
--- a/src/gallium/drivers/i965/brw_wm_constant_buffer.c
+++ b/src/gallium/drivers/i965/brw_wm_constant_buffer.c
@@ -62,7 +62,7 @@ brw_update_wm_constant_surface( struct brw_context *brw,
 {
    struct brw_surface_key key;
    struct brw_fragment_shader *fp = brw->curr.fragment_shader;
-   struct pipe_buffer *cbuf = brw->curr.fragment_constants;
+   struct pipe_resource *cbuf = brw->curr.fragment_constants;
    int pitch = cbuf->size / (4 * sizeof(float));
    enum pipe_error ret;
 
diff --git a/src/gallium/drivers/i965/brw_wm_sampler_state.c b/src/gallium/drivers/i965/brw_wm_sampler_state.c
index 3f18062c584..8406a1a9e20 100644
--- a/src/gallium/drivers/i965/brw_wm_sampler_state.c
+++ b/src/gallium/drivers/i965/brw_wm_sampler_state.c
@@ -35,7 +35,7 @@
 #include "brw_context.h"
 #include "brw_state.h"
 #include "brw_defines.h"
-#include "brw_screen.h"
+#include "brw_resource.h"
 
 
 /* Samplers aren't strictly wm state from the hardware's perspective,
@@ -94,7 +94,7 @@ brw_wm_sampler_populate_key(struct brw_context *brw,
       /* Cube-maps on 965 and later must use the same wrap mode for all 3
        * coordinate dimensions.  Futher, only CUBE and CLAMP are valid.
        */
-      if (tex->base.target == PIPE_TEXTURE_CUBE) {
+      if (tex->b.b.target == PIPE_TEXTURE_CUBE) {
 	 if (FALSE &&
 	     (sampler->ss0.min_filter != BRW_MAPFILTER_NEAREST || 
 	      sampler->ss0.mag_filter != BRW_MAPFILTER_NEAREST)) {
@@ -106,7 +106,7 @@ brw_wm_sampler_populate_key(struct brw_context *brw,
 	    entry->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
 	    entry->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
 	 }
-      } else if (tex->base.target == PIPE_TEXTURE_1D) {
+      } else if (tex->b.b.target == PIPE_TEXTURE_1D) {
 	 /* There's a bug in 1D texture sampling - it actually pays
 	  * attention to the wrap_t value, though it should not.
 	  * Override the wrap_t value here to GL_REPEAT to keep
@@ -137,7 +137,7 @@ brw_wm_sampler_update_default_colors(struct brw_context *brw)
          sampler->border_color[0]
       };
       
-      if (util_format_is_depth_or_stencil(tex->base.format)) {
+      if (util_format_is_depth_or_stencil(tex->b.b.format)) {
          bc = bordercolor;
       }
       else {
diff --git a/src/gallium/drivers/i965/brw_wm_surface_state.c b/src/gallium/drivers/i965/brw_wm_surface_state.c
index 2368ae3f808..0d80a0114af 100644
--- a/src/gallium/drivers/i965/brw_wm_surface_state.c
+++ b/src/gallium/drivers/i965/brw_wm_surface_state.c
@@ -34,7 +34,7 @@
 #include "brw_batchbuffer.h"
 #include "brw_context.h"
 #include "brw_state.h"
-#include "brw_screen.h"
+#include "brw_resource.h"
 
 
 
diff --git a/src/gallium/drivers/identity/id_context.c b/src/gallium/drivers/identity/id_context.c
index 00a542215ad..3b7eaecc02f 100644
--- a/src/gallium/drivers/identity/id_context.c
+++ b/src/gallium/drivers/identity/id_context.c
@@ -28,6 +28,7 @@
 
 #include "pipe/p_context.h"
 #include "util/u_memory.h"
+#include "util/u_inlines.h"
 
 #include "id_context.h"
 #include "id_objects.h"
@@ -61,19 +62,19 @@ identity_draw_arrays(struct pipe_context *_pipe,
 
 static void
 identity_draw_elements(struct pipe_context *_pipe,
-                       struct pipe_buffer *_indexBuffer,
+                       struct pipe_resource *_indexResource,
                        unsigned indexSize,
                        unsigned prim,
                        unsigned start,
                        unsigned count)
 {
    struct identity_context *id_pipe = identity_context(_pipe);
-   struct identity_buffer *id_buffer = identity_buffer(_indexBuffer);
+   struct identity_resource *id_resource = identity_resource(_indexResource);
    struct pipe_context *pipe = id_pipe->pipe;
-   struct pipe_buffer *indexBuffer = id_buffer->buffer;
+   struct pipe_resource *indexResource = id_resource->resource;
 
    pipe->draw_elements(pipe,
-                       indexBuffer,
+                       indexResource,
                        indexSize,
                        prim,
                        start,
@@ -82,7 +83,7 @@ identity_draw_elements(struct pipe_context *_pipe,
 
 static void
 identity_draw_range_elements(struct pipe_context *_pipe,
-                             struct pipe_buffer *_indexBuffer,
+                             struct pipe_resource *_indexResource,
                              unsigned indexSize,
                              unsigned minIndex,
                              unsigned maxIndex,
@@ -91,12 +92,12 @@ identity_draw_range_elements(struct pipe_context *_pipe,
                              unsigned count)
 {
    struct identity_context *id_pipe = identity_context(_pipe);
-   struct identity_buffer *id_buffer = identity_buffer(_indexBuffer);
+   struct identity_resource *id_resource = identity_resource(_indexResource);
    struct pipe_context *pipe = id_pipe->pipe;
-   struct pipe_buffer *indexBuffer = id_buffer->buffer;
+   struct pipe_resource *indexResource = id_resource->resource;
 
    pipe->draw_range_elements(pipe,
-                             indexBuffer,
+                             indexResource,
                              indexSize,
                              minIndex,
                              maxIndex,
@@ -450,23 +451,23 @@ static void
 identity_set_constant_buffer(struct pipe_context *_pipe,
                              uint shader,
                              uint index,
-                             struct pipe_buffer *_buffer)
+                             struct pipe_resource *_resource)
 {
    struct identity_context *id_pipe = identity_context(_pipe);
    struct pipe_context *pipe = id_pipe->pipe;
-   struct pipe_buffer *unwrapped_buffer;
-   struct pipe_buffer *buffer = NULL;
+   struct pipe_resource *unwrapped_resource;
+   struct pipe_resource *resource = NULL;
 
    /* XXX hmm? unwrap the input state */
-   if (_buffer) {
-      unwrapped_buffer = identity_buffer_unwrap(_buffer);
-      buffer = unwrapped_buffer;
+   if (_resource) {
+      unwrapped_resource = identity_resource_unwrap(_resource);
+      resource = unwrapped_resource;
    }
 
    pipe->set_constant_buffer(pipe,
                              shader,
                              index,
-                             buffer);
+                             resource);
 }
 
 static void
@@ -587,7 +588,7 @@ identity_set_vertex_buffers(struct pipe_context *_pipe,
    if (num_buffers) {
       memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers));
       for (i = 0; i < num_buffers; i++)
-         unwrapped_buffers[i].buffer = identity_buffer_unwrap(_buffers[i].buffer);
+         unwrapped_buffers[i].buffer = identity_resource_unwrap(_buffers[i].buffer);
       buffers = unwrapped_buffers;
    }
 
@@ -678,44 +679,31 @@ identity_flush(struct pipe_context *_pipe,
 }
 
 static unsigned int
-identity_is_texture_referenced(struct pipe_context *_pipe,
-                               struct pipe_texture *_texture,
+identity_is_resource_referenced(struct pipe_context *_pipe,
+                               struct pipe_resource *_resource,
                                unsigned face,
                                unsigned level)
 {
    struct identity_context *id_pipe = identity_context(_pipe);
-   struct identity_texture *id_texture = identity_texture(_texture);
+   struct identity_resource *id_resource = identity_resource(_resource);
    struct pipe_context *pipe = id_pipe->pipe;
-   struct pipe_texture *texture = id_texture->texture;
+   struct pipe_resource *texture = id_resource->resource;
 
-   return pipe->is_texture_referenced(pipe,
+   return pipe->is_resource_referenced(pipe,
                                       texture,
                                       face,
                                       level);
 }
 
-static unsigned int
-identity_is_buffer_referenced(struct pipe_context *_pipe,
-                              struct pipe_buffer *_buffer)
-{
-   struct identity_context *id_pipe = identity_context(_pipe);
-   struct identity_buffer *id_buffer = identity_buffer(_buffer);
-   struct pipe_context *pipe = id_pipe->pipe;
-   struct pipe_buffer *buffer = id_buffer->buffer;
-
-   return pipe->is_buffer_referenced(pipe,
-                                     buffer);
-}
-
 static struct pipe_sampler_view *
 identity_create_sampler_view(struct pipe_context *pipe,
-                             struct pipe_texture *texture,
+                             struct pipe_resource *texture,
                              const struct pipe_sampler_view *templ)
 {
    struct identity_context *id_pipe = identity_context(pipe);
-   struct identity_texture *id_texture = identity_texture(texture);
+   struct identity_resource *id_resource = identity_resource(texture);
    struct pipe_context *pipe_unwrapped = id_pipe->pipe;
-   struct pipe_texture *texture_unwrapped = id_texture->texture;
+   struct pipe_resource *texture_unwrapped = id_resource->resource;
    struct identity_sampler_view *view = malloc(sizeof(struct identity_sampler_view));
 
    view->sampler_view = pipe_unwrapped->create_sampler_view(pipe_unwrapped,
@@ -725,7 +713,7 @@ identity_create_sampler_view(struct pipe_context *pipe,
    view->base = *templ;
    view->base.reference.count = 1;
    view->base.texture = NULL;
-   pipe_texture_reference(&view->base.texture, texture);
+   pipe_resource_reference(&view->base.texture, texture);
    view->base.context = pipe;
 
    return &view->base;
@@ -743,47 +731,36 @@ identity_sampler_view_destroy(struct pipe_context *pipe,
    pipe_unwrapped->sampler_view_destroy(pipe_unwrapped,
                                         view_unwrapped);
 
-   pipe_texture_reference(&view->texture, NULL);
+   pipe_resource_reference(&view->texture, NULL);
    free(view);
 }
 
-
 static struct pipe_transfer *
-identity_context_get_tex_transfer(struct pipe_context *_context,
-				  struct pipe_texture *_texture,
-                                 unsigned face,
-                                 unsigned level,
-                                 unsigned zslice,
-                                 enum pipe_transfer_usage usage,
-                                 unsigned x,
-                                 unsigned y,
-                                 unsigned w,
-                                 unsigned h)
+identity_context_get_transfer(struct pipe_context *_context,
+			      struct pipe_resource *_resource,
+			      struct pipe_subresource sr,
+			      unsigned usage,
+			      const struct pipe_box *box)
 {
    struct identity_context *id_context = identity_context(_context);
-   struct identity_texture *id_texture = identity_texture(_texture);
+   struct identity_resource *id_resource = identity_resource(_resource);
    struct pipe_context *context = id_context->pipe;
-   struct pipe_texture *texture = id_texture->texture;
+   struct pipe_resource *texture = id_resource->resource;
    struct pipe_transfer *result;
 
-   result = context->get_tex_transfer(context,
-                                     texture,
-                                     face,
-                                     level,
-                                     zslice,
-                                     usage,
-                                     x,
-                                     y,
-                                     w,
-                                     h);
+   result = context->get_transfer(context,
+				  texture,
+				  sr,
+				  usage,
+				  box);
 
    if (result)
-      return identity_transfer_create(id_context, id_texture, result);
+      return identity_transfer_create(id_context, id_resource, result);
    return NULL;
 }
 
 static void
-identity_context_tex_transfer_destroy(struct pipe_context *_pipe,
+identity_context_transfer_destroy(struct pipe_context *_pipe,
                                       struct pipe_transfer *_transfer)
 {
    identity_transfer_destroy(identity_context(_pipe),
@@ -803,6 +780,24 @@ identity_context_transfer_map(struct pipe_context *_context,
 				transfer);
 }
 
+
+
+static void
+identity_context_transfer_flush_region( struct pipe_context *_context,
+					struct pipe_transfer *_transfer,
+					const struct pipe_box *box)
+{
+   struct identity_context *id_context = identity_context(_context);
+   struct identity_transfer *id_transfer = identity_transfer(_transfer);
+   struct pipe_context *context = id_context->pipe;
+   struct pipe_transfer *transfer = id_transfer->transfer;
+
+   context->transfer_flush_region(context,
+				  transfer,
+				  box);
+}
+
+
 static void
 identity_context_transfer_unmap(struct pipe_context *_context,
                                struct pipe_transfer *_transfer)
@@ -816,6 +811,33 @@ identity_context_transfer_unmap(struct pipe_context *_context,
                           transfer);
 }
 
+
+static void 
+identity_context_transfer_inline_write( struct pipe_context *_context,
+					struct pipe_resource *_resource,
+					struct pipe_subresource sr,
+					unsigned usage,
+					const struct pipe_box *box,
+					const void *data,
+					unsigned stride,
+					unsigned slice_stride)
+{
+   struct identity_context *id_context = identity_context(_context);
+   struct identity_resource *id_resource = identity_resource(_resource);
+   struct pipe_context *context = id_context->pipe;
+   struct pipe_resource *texture = id_resource->resource;
+
+   context->transfer_inline_write(context,
+				  texture,
+				  sr,
+				  usage,
+				  box,
+				  data,
+				  stride,
+				  slice_stride);
+}
+
+
 struct pipe_context *
 identity_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
 {
@@ -878,14 +900,15 @@ identity_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
    id_pipe->base.surface_fill = identity_surface_fill;
    id_pipe->base.clear = identity_clear;
    id_pipe->base.flush = identity_flush;
-   id_pipe->base.is_texture_referenced = identity_is_texture_referenced;
-   id_pipe->base.is_buffer_referenced = identity_is_buffer_referenced;
+   id_pipe->base.is_resource_referenced = identity_is_resource_referenced;
    id_pipe->base.create_sampler_view = identity_create_sampler_view;
    id_pipe->base.sampler_view_destroy = identity_sampler_view_destroy;
-   id_pipe->base.get_tex_transfer = identity_context_get_tex_transfer;
-   id_pipe->base.tex_transfer_destroy = identity_context_tex_transfer_destroy;
+   id_pipe->base.get_transfer = identity_context_get_transfer;
+   id_pipe->base.transfer_destroy = identity_context_transfer_destroy;
    id_pipe->base.transfer_map = identity_context_transfer_map;
    id_pipe->base.transfer_unmap = identity_context_transfer_unmap;
+   id_pipe->base.transfer_flush_region = identity_context_transfer_flush_region;
+   id_pipe->base.transfer_inline_write = identity_context_transfer_inline_write;
 
    id_pipe->pipe = pipe;
 
diff --git a/src/gallium/drivers/identity/id_objects.c b/src/gallium/drivers/identity/id_objects.c
index d37fb0042e5..d50914e7d5d 100644
--- a/src/gallium/drivers/identity/id_objects.c
+++ b/src/gallium/drivers/identity/id_objects.c
@@ -32,80 +32,46 @@
 #include "id_objects.h"
 #include "id_context.h"
 
-struct pipe_buffer *
-identity_buffer_create(struct identity_screen *id_screen,
-                       struct pipe_buffer *buffer)
-{
-   struct identity_buffer *id_buffer;
-
-   if(!buffer)
-      goto error;
-
-   assert(buffer->screen == id_screen->screen);
-
-   id_buffer = CALLOC_STRUCT(identity_buffer);
-   if(!id_buffer)
-      goto error;
-
-   memcpy(&id_buffer->base, buffer, sizeof(struct pipe_buffer));
-
-   pipe_reference_init(&id_buffer->base.reference, 1);
-   id_buffer->base.screen = &id_screen->base;
-   id_buffer->buffer = buffer;
-
-   return &id_buffer->base;
-
-error:
-   pipe_buffer_reference(&buffer, NULL);
-   return NULL;
-}
-
-void
-identity_buffer_destroy(struct identity_buffer *id_buffer)
-{
-   pipe_buffer_reference(&id_buffer->buffer, NULL);
-   FREE(id_buffer);
-}
 
 
-struct pipe_texture *
-identity_texture_create(struct identity_screen *id_screen,
-                        struct pipe_texture *texture)
+struct pipe_resource *
+identity_resource_create(struct identity_screen *id_screen,
+                        struct pipe_resource *resource)
 {
-   struct identity_texture *id_texture;
+   struct identity_resource *id_resource;
 
-   if(!texture)
+   if(!resource)
       goto error;
 
-   assert(texture->screen == id_screen->screen);
+   assert(resource->screen == id_screen->screen);
 
-   id_texture = CALLOC_STRUCT(identity_texture);
-   if(!id_texture)
+   id_resource = CALLOC_STRUCT(identity_resource);
+   if(!id_resource)
       goto error;
 
-   memcpy(&id_texture->base, texture, sizeof(struct pipe_texture));
+   memcpy(&id_resource->base, resource, sizeof(struct pipe_resource));
 
-   pipe_reference_init(&id_texture->base.reference, 1);
-   id_texture->base.screen = &id_screen->base;
-   id_texture->texture = texture;
+   pipe_reference_init(&id_resource->base.reference, 1);
+   id_resource->base.screen = &id_screen->base;
+   id_resource->resource = resource;
 
-   return &id_texture->base;
+   return &id_resource->base;
 
 error:
-   pipe_texture_reference(&texture, NULL);
+   pipe_resource_reference(&resource, NULL);
    return NULL;
 }
 
 void
-identity_texture_destroy(struct identity_texture *id_texture)
+identity_resource_destroy(struct identity_resource *id_resource)
 {
-   pipe_texture_reference(&id_texture->texture, NULL);
-   FREE(id_texture);
+   pipe_resource_reference(&id_resource->resource, NULL);
+   FREE(id_resource);
 }
 
 
 struct pipe_surface *
-identity_surface_create(struct identity_texture *id_texture,
+identity_surface_create(struct identity_resource *id_resource,
                         struct pipe_surface *surface)
 {
    struct identity_surface *id_surface;
@@ -113,7 +79,7 @@ identity_surface_create(struct identity_texture *id_texture,
    if(!surface)
       goto error;
 
-   assert(surface->texture == id_texture->texture);
+   assert(surface->texture == id_resource->resource);
 
    id_surface = CALLOC_STRUCT(identity_surface);
    if(!id_surface)
@@ -123,7 +89,7 @@ identity_surface_create(struct identity_texture *id_texture,
 
    pipe_reference_init(&id_surface->base.reference, 1);
    id_surface->base.texture = NULL;
-   pipe_texture_reference(&id_surface->base.texture, &id_texture->base);
+   pipe_resource_reference(&id_surface->base.texture, &id_resource->base);
    id_surface->surface = surface;
 
    return &id_surface->base;
@@ -136,7 +102,7 @@ error:
 void
 identity_surface_destroy(struct identity_surface *id_surface)
 {
-   pipe_texture_reference(&id_surface->base.texture, NULL);
+   pipe_resource_reference(&id_surface->base.texture, NULL);
    pipe_surface_reference(&id_surface->surface, NULL);
    FREE(id_surface);
 }
@@ -144,7 +110,7 @@ identity_surface_destroy(struct identity_surface *id_surface)
 
 struct pipe_transfer *
 identity_transfer_create(struct identity_context *id_context,
-			 struct identity_texture *id_texture,
+			 struct identity_resource *id_resource,
                          struct pipe_transfer *transfer)
 {
    struct identity_transfer *id_transfer;
@@ -152,7 +118,7 @@ identity_transfer_create(struct identity_context *id_context,
    if(!transfer)
       goto error;
 
-   assert(transfer->texture == id_texture->texture);
+   assert(transfer->resource == id_resource->resource);
 
    id_transfer = CALLOC_STRUCT(identity_transfer);
    if(!id_transfer)
@@ -160,16 +126,16 @@ identity_transfer_create(struct identity_context *id_context,
 
    memcpy(&id_transfer->base, transfer, sizeof(struct pipe_transfer));
 
-   id_transfer->base.texture = NULL;
+   id_transfer->base.resource = NULL;
    id_transfer->transfer = transfer;
 
-   pipe_texture_reference(&id_transfer->base.texture, &id_texture->base);
-   assert(id_transfer->base.texture == &id_texture->base);
+   pipe_resource_reference(&id_transfer->base.resource, &id_resource->base);
+   assert(id_transfer->base.resource == &id_resource->base);
 
    return &id_transfer->base;
 
 error:
-   id_context->pipe->tex_transfer_destroy(id_context->pipe, transfer);
+   id_context->pipe->transfer_destroy(id_context->pipe, transfer);
    return NULL;
 }
 
@@ -177,47 +143,9 @@ void
 identity_transfer_destroy(struct identity_context *id_context,
                           struct identity_transfer *id_transfer)
 {
-   pipe_texture_reference(&id_transfer->base.texture, NULL);
-   id_context->pipe->tex_transfer_destroy(id_context->pipe,
-                                          id_transfer->transfer);
+   pipe_resource_reference(&id_transfer->base.resource, NULL);
+   id_context->pipe->transfer_destroy(id_context->pipe,
+				      id_transfer->transfer);
    FREE(id_transfer);
 }
 
-struct pipe_video_surface *
-identity_video_surface_create(struct identity_screen *id_screen,
-                              struct pipe_video_surface *video_surface)
-{
-   struct identity_video_surface *id_video_surface;
-
-   if (!video_surface) {
-      goto error;
-   }
-
-   assert(video_surface->screen == id_screen->screen);
-
-   id_video_surface = CALLOC_STRUCT(identity_video_surface);
-   if (!id_video_surface) {
-      goto error;
-   }
-
-   memcpy(&id_video_surface->base,
-          video_surface,
-          sizeof(struct pipe_video_surface));
-
-   pipe_reference_init(&id_video_surface->base.reference, 1);
-   id_video_surface->base.screen = &id_screen->base;
-   id_video_surface->video_surface = video_surface;
-
-   return &id_video_surface->base;
-
-error:
-   pipe_video_surface_reference(&video_surface, NULL);
-   return NULL;
-}
-
-void
-identity_video_surface_destroy(struct identity_video_surface *id_video_surface)
-{
-   pipe_video_surface_reference(&id_video_surface->video_surface, NULL);
-   FREE(id_video_surface);
-}
diff --git a/src/gallium/drivers/identity/id_objects.h b/src/gallium/drivers/identity/id_objects.h
index 9a07ebe8d72..058cf3009df 100644
--- a/src/gallium/drivers/identity/id_objects.h
+++ b/src/gallium/drivers/identity/id_objects.h
@@ -31,25 +31,17 @@
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_state.h"
-#include "pipe/p_video_state.h"
 
 #include "id_screen.h"
 
 struct identity_context;
 
-struct identity_buffer
-{
-   struct pipe_buffer base;
-
-   struct pipe_buffer *buffer;
-};
-
 
-struct identity_texture
+struct identity_resource
 {
-   struct pipe_texture base;
+   struct pipe_resource base;
 
-   struct pipe_texture *texture;
+   struct pipe_resource *resource;
 };
 
 
@@ -78,30 +70,13 @@ struct identity_transfer
 };
 
 
-struct identity_video_surface
-{
-   struct pipe_video_surface base;
-
-   struct pipe_video_surface *video_surface;
-};
-
-
-static INLINE struct identity_buffer *
-identity_buffer(struct pipe_buffer *_buffer)
+static INLINE struct identity_resource *
+identity_resource(struct pipe_resource *_resource)
 {
-   if(!_buffer)
+   if(!_resource)
       return NULL;
-   (void)identity_screen(_buffer->screen);
-   return (struct identity_buffer *)_buffer;
-}
-
-static INLINE struct identity_texture *
-identity_texture(struct pipe_texture *_texture)
-{
-   if(!_texture)
-      return NULL;
-   (void)identity_screen(_texture->screen);
-   return (struct identity_texture *)_texture;
+   (void)identity_screen(_resource->screen);
+   return (struct identity_resource *)_resource;
 }
 
 static INLINE struct identity_sampler_view *
@@ -118,7 +93,7 @@ identity_surface(struct pipe_surface *_surface)
 {
    if(!_surface)
       return NULL;
-   (void)identity_texture(_surface->texture);
+   (void)identity_resource(_surface->texture);
    return (struct identity_surface *)_surface;
 }
 
@@ -127,34 +102,16 @@ identity_transfer(struct pipe_transfer *_transfer)
 {
    if(!_transfer)
       return NULL;
-   (void)identity_texture(_transfer->texture);
+   (void)identity_resource(_transfer->resource);
    return (struct identity_transfer *)_transfer;
 }
 
-static INLINE struct identity_video_surface *
-identity_video_surface(struct pipe_video_surface *_video_surface)
-{
-   if (!_video_surface) {
-      return NULL;
-   }
-   (void)identity_screen(_video_surface->screen);
-   return (struct identity_video_surface *)_video_surface;
-}
-
-static INLINE struct pipe_buffer *
-identity_buffer_unwrap(struct pipe_buffer *_buffer)
-{
-   if(!_buffer)
-      return NULL;
-   return identity_buffer(_buffer)->buffer;
-}
-
-static INLINE struct pipe_texture *
-identity_texture_unwrap(struct pipe_texture *_texture)
+static INLINE struct pipe_resource *
+identity_resource_unwrap(struct pipe_resource *_resource)
 {
-   if(!_texture)
+   if(!_resource)
       return NULL;
-   return identity_texture(_texture)->texture;
+   return identity_resource(_resource)->resource;
 }
 
 static INLINE struct pipe_sampler_view *
@@ -183,22 +140,15 @@ identity_transfer_unwrap(struct pipe_transfer *_transfer)
 }
 
 
-struct pipe_buffer *
-identity_buffer_create(struct identity_screen *id_screen,
-                       struct pipe_buffer *buffer);
-
-void
-identity_buffer_destroy(struct identity_buffer *id_buffer);
-
-struct pipe_texture *
-identity_texture_create(struct identity_screen *id_screen,
-                        struct pipe_texture *texture);
+struct pipe_resource *
+identity_resource_create(struct identity_screen *id_screen,
+                        struct pipe_resource *resource);
 
 void
-identity_texture_destroy(struct identity_texture *id_texture);
+identity_resource_destroy(struct identity_resource *id_resource);
 
 struct pipe_surface *
-identity_surface_create(struct identity_texture *id_texture,
+identity_surface_create(struct identity_resource *id_resource,
                         struct pipe_surface *surface);
 
 void
@@ -206,19 +156,12 @@ identity_surface_destroy(struct identity_surface *id_surface);
 
 struct pipe_transfer *
 identity_transfer_create(struct identity_context *id_context,
-			 struct identity_texture *id_texture,
+			 struct identity_resource *id_resource,
                          struct pipe_transfer *transfer);
 
 void
 identity_transfer_destroy(struct identity_context *id_context,
                           struct identity_transfer *id_transfer);
 
-struct pipe_video_surface *
-identity_video_surface_create(struct identity_screen *id_screen,
-                              struct pipe_video_surface *video_surface);
-
-void
-identity_video_surface_destroy(struct identity_video_surface *id_video_surface);
-
 
 #endif /* ID_OBJECTS_H */
diff --git a/src/gallium/drivers/identity/id_screen.c b/src/gallium/drivers/identity/id_screen.c
index 419b1465787..52573b211fb 100644
--- a/src/gallium/drivers/identity/id_screen.c
+++ b/src/gallium/drivers/identity/id_screen.c
@@ -118,75 +118,76 @@ identity_screen_context_create(struct pipe_screen *_screen,
    return NULL;
 }
 
-static struct pipe_texture *
-identity_screen_texture_create(struct pipe_screen *_screen,
-                               const struct pipe_texture *templat)
+static struct pipe_resource *
+identity_screen_resource_create(struct pipe_screen *_screen,
+                               const struct pipe_resource *templat)
 {
    struct identity_screen *id_screen = identity_screen(_screen);
    struct pipe_screen *screen = id_screen->screen;
-   struct pipe_texture *result;
+   struct pipe_resource *result;
 
-   result = screen->texture_create(screen,
+   result = screen->resource_create(screen,
                                    templat);
 
    if (result)
-      return identity_texture_create(id_screen, result);
+      return identity_resource_create(id_screen, result);
    return NULL;
 }
 
-static struct pipe_texture *
-identity_screen_texture_from_handle(struct pipe_screen *_screen,
-                                    const struct pipe_texture *templ,
+static struct pipe_resource *
+identity_screen_resource_from_handle(struct pipe_screen *_screen,
+                                    const struct pipe_resource *templ,
                                     struct winsys_handle *handle)
 {
    struct identity_screen *id_screen = identity_screen(_screen);
    struct pipe_screen *screen = id_screen->screen;
-   struct pipe_texture *result;
+   struct pipe_resource *result;
 
    /* TODO trace call */
 
-   result = screen->texture_from_handle(screen, templ, handle);
+   result = screen->resource_from_handle(screen, templ, handle);
 
-   result = identity_texture_create(identity_screen(_screen), result);
+   result = identity_resource_create(identity_screen(_screen), result);
 
    return result;
 }
 
 static boolean
-identity_screen_texture_get_handle(struct pipe_screen *_screen,
-                                   struct pipe_texture *_texture,
+identity_screen_resource_get_handle(struct pipe_screen *_screen,
+                                   struct pipe_resource *_texture,
                                    struct winsys_handle *handle)
 {
    struct identity_screen *id_screen = identity_screen(_screen);
-   struct identity_texture *id_texture = identity_texture(_texture);
+   struct identity_resource *id_resource = identity_resource(_texture);
    struct pipe_screen *screen = id_screen->screen;
-   struct pipe_texture *texture = id_texture->texture;
+   struct pipe_resource *texture = id_resource->resource;
 
    /* TODO trace call */
 
-   return screen->texture_get_handle(screen, texture, handle);
+   return screen->resource_get_handle(screen, texture, handle);
 }
 
 
 
 static void
-identity_screen_texture_destroy(struct pipe_texture *_texture)
+identity_screen_resource_destroy(struct pipe_screen *screen,
+				 struct pipe_resource *_texture)
 {
-   identity_texture_destroy(identity_texture(_texture));
+   identity_resource_destroy(identity_resource(_texture));
 }
 
 static struct pipe_surface *
 identity_screen_get_tex_surface(struct pipe_screen *_screen,
-                                struct pipe_texture *_texture,
+                                struct pipe_resource *_texture,
                                 unsigned face,
                                 unsigned level,
                                 unsigned zslice,
                                 unsigned usage)
 {
    struct identity_screen *id_screen = identity_screen(_screen);
-   struct identity_texture *id_texture = identity_texture(_texture);
+   struct identity_resource *id_resource = identity_resource(_texture);
    struct pipe_screen *screen = id_screen->screen;
-   struct pipe_texture *texture = id_texture->texture;
+   struct pipe_resource *texture = id_resource->resource;
    struct pipe_surface *result;
 
    result = screen->get_tex_surface(screen,
@@ -197,7 +198,7 @@ identity_screen_get_tex_surface(struct pipe_screen *_screen,
                                     usage);
 
    if (result)
-      return identity_surface_create(id_texture, result);
+      return identity_surface_create(id_resource, result);
    return NULL;
 }
 
@@ -208,141 +209,28 @@ identity_screen_tex_surface_destroy(struct pipe_surface *_surface)
 }
 
 
-static struct pipe_buffer *
-identity_screen_buffer_create(struct pipe_screen *_screen,
-                              unsigned alignment,
-                              unsigned usage,
-                              unsigned size)
-{
-   struct identity_screen *id_screen = identity_screen(_screen);
-   struct pipe_screen *screen = id_screen->screen;
-   struct pipe_buffer *result;
-
-   result = screen->buffer_create(screen,
-                                  alignment,
-                                  usage,
-                                  size);
 
-   if (result)
-      return identity_buffer_create(id_screen, result);
-   return NULL;
-}
-
-static struct pipe_buffer *
+static struct pipe_resource *
 identity_screen_user_buffer_create(struct pipe_screen *_screen,
                                    void *ptr,
-                                   unsigned bytes)
+                                   unsigned bytes,
+				   unsigned usage)
 {
    struct identity_screen *id_screen = identity_screen(_screen);
    struct pipe_screen *screen = id_screen->screen;
-   struct pipe_buffer *result;
+   struct pipe_resource *result;
 
    result = screen->user_buffer_create(screen,
                                        ptr,
-                                       bytes);
+                                       bytes,
+				       usage);
 
    if (result)
-      return identity_buffer_create(id_screen, result);
+      return identity_resource_create(id_screen, result);
    return NULL;
 }
 
 
-static void *
-identity_screen_buffer_map(struct pipe_screen *_screen,
-                           struct pipe_buffer *_buffer,
-                           unsigned usage)
-{
-   struct identity_screen *id_screen = identity_screen(_screen);
-   struct identity_buffer *id_buffer = identity_buffer(_buffer);
-   struct pipe_screen *screen = id_screen->screen;
-   struct pipe_buffer *buffer = id_buffer->buffer;
-
-   return screen->buffer_map(screen,
-                             buffer,
-                             usage);
-}
-
-static void *
-identity_screen_buffer_map_range(struct pipe_screen *_screen,
-                                 struct pipe_buffer *_buffer,
-                                 unsigned offset,
-                                 unsigned length,
-                                 unsigned usage)
-{
-   struct identity_screen *id_screen = identity_screen(_screen);
-   struct identity_buffer *id_buffer = identity_buffer(_buffer);
-   struct pipe_screen *screen = id_screen->screen;
-   struct pipe_buffer *buffer = id_buffer->buffer;
-
-   return screen->buffer_map_range(screen,
-                                   buffer,
-                                   offset,
-                                   length,
-                                   usage);
-}
-
-static void
-identity_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
-                                          struct pipe_buffer *_buffer,
-                                          unsigned offset,
-                                          unsigned length)
-{
-   struct identity_screen *id_screen = identity_screen(_screen);
-   struct identity_buffer *id_buffer = identity_buffer(_buffer);
-   struct pipe_screen *screen = id_screen->screen;
-   struct pipe_buffer *buffer = id_buffer->buffer;
-
-   screen->buffer_flush_mapped_range(screen,
-                                     buffer,
-                                     offset,
-                                     length);
-}
-
-static void
-identity_screen_buffer_unmap(struct pipe_screen *_screen,
-                             struct pipe_buffer *_buffer)
-{
-   struct identity_screen *id_screen = identity_screen(_screen);
-   struct identity_buffer *id_buffer = identity_buffer(_buffer);
-   struct pipe_screen *screen = id_screen->screen;
-   struct pipe_buffer *buffer = id_buffer->buffer;
-
-   screen->buffer_unmap(screen,
-                        buffer);
-}
-
-static void
-identity_screen_buffer_destroy(struct pipe_buffer *_buffer)
-{
-   identity_buffer_destroy(identity_buffer(_buffer));
-}
-
-static struct pipe_video_surface *
-identity_screen_video_surface_create(struct pipe_screen *_screen,
-                                     enum pipe_video_chroma_format chroma_format,
-                                     unsigned width,
-                                     unsigned height)
-{
-   struct identity_screen *id_screen = identity_screen(_screen);
-   struct pipe_screen *screen = id_screen->screen;
-   struct pipe_video_surface *result;
-
-   result = screen->video_surface_create(screen,
-                                         chroma_format,
-                                         width,
-                                         height);
-
-   if (result) {
-      return identity_video_surface_create(id_screen, result);
-   }
-   return NULL;
-}
-
-static void
-identity_screen_video_surface_destroy(struct pipe_video_surface *_vsfc)
-{
-   identity_video_surface_destroy(identity_video_surface(_vsfc));
-}
 
 static void
 identity_screen_flush_frontbuffer(struct pipe_screen *_screen,
@@ -417,29 +305,13 @@ identity_screen_create(struct pipe_screen *screen)
    id_screen->base.get_paramf = identity_screen_get_paramf;
    id_screen->base.is_format_supported = identity_screen_is_format_supported;
    id_screen->base.context_create = identity_screen_context_create;
-   id_screen->base.texture_create = identity_screen_texture_create;
-   id_screen->base.texture_from_handle = identity_screen_texture_from_handle;
-   id_screen->base.texture_get_handle = identity_screen_texture_get_handle;
-   id_screen->base.texture_destroy = identity_screen_texture_destroy;
+   id_screen->base.resource_create = identity_screen_resource_create;
+   id_screen->base.resource_from_handle = identity_screen_resource_from_handle;
+   id_screen->base.resource_get_handle = identity_screen_resource_get_handle;
+   id_screen->base.resource_destroy = identity_screen_resource_destroy;
    id_screen->base.get_tex_surface = identity_screen_get_tex_surface;
    id_screen->base.tex_surface_destroy = identity_screen_tex_surface_destroy;
-   id_screen->base.buffer_create = identity_screen_buffer_create;
    id_screen->base.user_buffer_create = identity_screen_user_buffer_create;
-   if (screen->buffer_map)
-      id_screen->base.buffer_map = identity_screen_buffer_map;
-   if (screen->buffer_map_range)
-      id_screen->base.buffer_map_range = identity_screen_buffer_map_range;
-   if (screen->buffer_flush_mapped_range)
-      id_screen->base.buffer_flush_mapped_range = identity_screen_buffer_flush_mapped_range;
-   if (screen->buffer_unmap)
-      id_screen->base.buffer_unmap = identity_screen_buffer_unmap;
-   id_screen->base.buffer_destroy = identity_screen_buffer_destroy;
-   if (screen->video_surface_create) {
-      id_screen->base.video_surface_create = identity_screen_video_surface_create;
-   }
-   if (screen->video_surface_destroy) {
-      id_screen->base.video_surface_destroy = identity_screen_video_surface_destroy;
-   }
    id_screen->base.flush_frontbuffer = identity_screen_flush_frontbuffer;
    id_screen->base.fence_reference = identity_screen_fence_reference;
    id_screen->base.fence_signalled = identity_screen_fence_signalled;
diff --git a/src/gallium/drivers/llvmpipe/Makefile b/src/gallium/drivers/llvmpipe/Makefile
index 7bfce15c2ed..a35a24f5b06 100644
--- a/src/gallium/drivers/llvmpipe/Makefile
+++ b/src/gallium/drivers/llvmpipe/Makefile
@@ -6,7 +6,6 @@ LIBNAME = llvmpipe
 DEFINES += -D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS
 
 C_SOURCES = \
-	lp_buffer.c \
 	lp_clear.c \
 	lp_context.c \
 	lp_draw_arrays.c \
diff --git a/src/gallium/drivers/llvmpipe/SConscript b/src/gallium/drivers/llvmpipe/SConscript
index 07e6ccfce45..8e3267c8438 100644
--- a/src/gallium/drivers/llvmpipe/SConscript
+++ b/src/gallium/drivers/llvmpipe/SConscript
@@ -1,12 +1,11 @@
 Import('*')
 
-env = env.Clone()
-
-env.Tool('llvm')
-if not env.has_key('LLVM_VERSION'):
-    print 'warning: LLVM not found: not building llvmpipe'
+if not env['llvm']:
+    print 'warning: LLVM disabled: not building llvmpipe'
     Return()
 
+env = env.Clone()
+
 env.Tool('udis86')
 
 env.Append(CPPPATH = ['.'])
@@ -27,7 +26,6 @@ env.Depends('lp_tile_soa.c', [
 llvmpipe = env.ConvenienceLibrary(
 	target = 'llvmpipe',
 	source = [
-		'lp_buffer.c',
 		'lp_clear.c',
 		'lp_context.c',
 		'lp_draw_arrays.c',
diff --git a/src/gallium/drivers/llvmpipe/lp_buffer.c b/src/gallium/drivers/llvmpipe/lp_buffer.c
deleted file mode 100644
index 6e0f37393e9..00000000000
--- a/src/gallium/drivers/llvmpipe/lp_buffer.c
+++ /dev/null
@@ -1,118 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.
- * 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 VMWARE 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.
- *
- **************************************************************************/
-
-
-#include "util/u_inlines.h"
-#include "util/u_memory.h"
-#include "util/u_math.h"
-
-#include "lp_screen.h"
-#include "lp_buffer.h"
-
-
-static void *
-llvmpipe_buffer_map(struct pipe_screen *screen,
-                    struct pipe_buffer *buf,
-                    unsigned flags)
-{
-   struct llvmpipe_buffer *llvmpipe_buf = llvmpipe_buffer(buf);
-   return llvmpipe_buf->data;
-}
-
-
-static void
-llvmpipe_buffer_unmap(struct pipe_screen *screen,
-                      struct pipe_buffer *buf)
-{
-}
-
-
-static void
-llvmpipe_buffer_destroy(struct pipe_buffer *buf)
-{
-   struct llvmpipe_buffer *sbuf = llvmpipe_buffer(buf);
-
-   if (!sbuf->userBuffer)
-      align_free(sbuf->data);
-      
-   FREE(sbuf);
-}
-
-
-static struct pipe_buffer *
-llvmpipe_buffer_create(struct pipe_screen *screen,
-                       unsigned alignment,
-                       unsigned usage,
-                       unsigned size)
-{
-   struct llvmpipe_buffer *buffer = CALLOC_STRUCT(llvmpipe_buffer);
-
-   pipe_reference_init(&buffer->base.reference, 1);
-   buffer->base.screen = screen;
-   buffer->base.alignment = MAX2(alignment, 16);
-   buffer->base.usage = usage;
-   buffer->base.size = size;
-
-   buffer->data = align_malloc(size, alignment);
-
-   return &buffer->base;
-}
-
-
-/**
- * Create buffer which wraps user-space data.
- */
-static struct pipe_buffer *
-llvmpipe_user_buffer_create(struct pipe_screen *screen,
-                            void *ptr,
-                            unsigned bytes)
-{
-   struct llvmpipe_buffer *buffer;
-
-   buffer = CALLOC_STRUCT(llvmpipe_buffer);
-   if(!buffer)
-      return NULL;
-
-   pipe_reference_init(&buffer->base.reference, 1);
-   buffer->base.screen = screen;
-   buffer->base.size = bytes;
-   buffer->userBuffer = TRUE;
-   buffer->data = ptr;
-
-   return &buffer->base;
-}
-
-
-void
-llvmpipe_init_screen_buffer_funcs(struct pipe_screen *screen)
-{
-   screen->buffer_create = llvmpipe_buffer_create;
-   screen->user_buffer_create = llvmpipe_user_buffer_create;
-   screen->buffer_map = llvmpipe_buffer_map;
-   screen->buffer_unmap = llvmpipe_buffer_unmap;
-   screen->buffer_destroy = llvmpipe_buffer_destroy;
-}
diff --git a/src/gallium/drivers/llvmpipe/lp_context.c b/src/gallium/drivers/llvmpipe/lp_context.c
index 0786e409ae6..e63720c99ab 100644
--- a/src/gallium/drivers/llvmpipe/lp_context.c
+++ b/src/gallium/drivers/llvmpipe/lp_context.c
@@ -46,7 +46,7 @@
 #include "lp_setup.h"
 
 
-
+#define USE_DRAW_LLVM 0
 
 
 static void llvmpipe_destroy( struct pipe_context *pipe )
@@ -77,29 +77,13 @@ static void llvmpipe_destroy( struct pipe_context *pipe )
 
    for (i = 0; i < Elements(llvmpipe->constants); i++) {
       if (llvmpipe->constants[i]) {
-         pipe_buffer_reference(&llvmpipe->constants[i], NULL);
+         pipe_resource_reference(&llvmpipe->constants[i], NULL);
       }
    }
 
    align_free( llvmpipe );
 }
 
-static unsigned int
-llvmpipe_is_texture_referenced( struct pipe_context *pipe,
-				struct pipe_texture *texture,
-				unsigned face, unsigned level)
-{
-   struct llvmpipe_context *llvmpipe = llvmpipe_context( pipe );
-
-   return lp_setup_is_texture_referenced(llvmpipe->setup, texture);
-}
-
-static unsigned int
-llvmpipe_is_buffer_referenced( struct pipe_context *pipe,
-			       struct pipe_buffer *buf)
-{
-   return PIPE_UNREFERENCED;
-}
 
 struct pipe_context *
 llvmpipe_create_context( struct pipe_screen *screen, void *priv )
@@ -171,17 +155,19 @@ llvmpipe_create_context( struct pipe_screen *screen, void *priv )
    llvmpipe->pipe.clear = llvmpipe_clear;
    llvmpipe->pipe.flush = llvmpipe_flush;
 
-   llvmpipe->pipe.is_texture_referenced = llvmpipe_is_texture_referenced;
-   llvmpipe->pipe.is_buffer_referenced = llvmpipe_is_buffer_referenced;
 
    llvmpipe_init_query_funcs( llvmpipe );
-   llvmpipe_init_context_texture_funcs( &llvmpipe->pipe );
+   llvmpipe_init_context_resource_funcs( &llvmpipe->pipe );
 
    /*
     * Create drawing context and plug our rendering stage into it.
     */
+#if USE_DRAW_LLVM
+   llvmpipe->draw = draw_create_with_llvm();
+#else
    llvmpipe->draw = draw_create();
-   if (!llvmpipe->draw) 
+#endif
+   if (!llvmpipe->draw)
       goto fail;
 
    /* FIXME: devise alternative to draw_texture_samplers */
diff --git a/src/gallium/drivers/llvmpipe/lp_context.h b/src/gallium/drivers/llvmpipe/lp_context.h
index 71f991049e5..4848101ffb8 100644
--- a/src/gallium/drivers/llvmpipe/lp_context.h
+++ b/src/gallium/drivers/llvmpipe/lp_context.h
@@ -65,7 +65,7 @@ struct llvmpipe_context {
    struct pipe_blend_color blend_color;
    struct pipe_stencil_ref stencil_ref;
    struct pipe_clip_state clip;
-   struct pipe_buffer *constants[PIPE_SHADER_TYPES];
+   struct pipe_resource *constants[PIPE_SHADER_TYPES];
    struct pipe_framebuffer_state framebuffer;
    struct pipe_poly_stipple poly_stipple;
    struct pipe_scissor_state scissor;
diff --git a/src/gallium/drivers/llvmpipe/lp_draw_arrays.c b/src/gallium/drivers/llvmpipe/lp_draw_arrays.c
index 3dd68d5794e..86525eea9e9 100644
--- a/src/gallium/drivers/llvmpipe/lp_draw_arrays.c
+++ b/src/gallium/drivers/llvmpipe/lp_draw_arrays.c
@@ -35,7 +35,6 @@
 #include "pipe/p_context.h"
 #include "util/u_prim.h"
 
-#include "lp_buffer.h"
 #include "lp_context.h"
 #include "lp_state.h"
 
@@ -58,7 +57,7 @@ llvmpipe_draw_arrays(struct pipe_context *pipe, unsigned mode,
  */
 void
 llvmpipe_draw_range_elements(struct pipe_context *pipe,
-                             struct pipe_buffer *indexBuffer,
+                             struct pipe_resource *indexBuffer,
                              unsigned indexSize,
                              unsigned min_index,
                              unsigned max_index,
@@ -75,13 +74,13 @@ llvmpipe_draw_range_elements(struct pipe_context *pipe,
     * Map vertex buffers
     */
    for (i = 0; i < lp->num_vertex_buffers; i++) {
-      void *buf = llvmpipe_buffer(lp->vertex_buffer[i].buffer)->data;
+      void *buf = llvmpipe_resource_data(lp->vertex_buffer[i].buffer);
       draw_set_mapped_vertex_buffer(draw, i, buf);
    }
 
    /* Map index buffer, if present */
    if (indexBuffer) {
-      void *mapped_indexes = llvmpipe_buffer(indexBuffer)->data;
+      void *mapped_indexes = llvmpipe_resource_data(indexBuffer);
       draw_set_mapped_element_buffer_range(draw, indexSize,
                                            min_index,
                                            max_index,
@@ -117,7 +116,7 @@ llvmpipe_draw_range_elements(struct pipe_context *pipe,
 
 void
 llvmpipe_draw_elements(struct pipe_context *pipe,
-                       struct pipe_buffer *indexBuffer,
+                       struct pipe_resource *indexBuffer,
                        unsigned indexSize,
                        unsigned mode, unsigned start, unsigned count)
 {
diff --git a/src/gallium/drivers/llvmpipe/lp_fence.c b/src/gallium/drivers/llvmpipe/lp_fence.c
index 00dc3eab6b1..75d8d2b8251 100644
--- a/src/gallium/drivers/llvmpipe/lp_fence.c
+++ b/src/gallium/drivers/llvmpipe/lp_fence.c
@@ -33,6 +33,15 @@
 #include "lp_fence.h"
 
 
+/**
+ * Create a new fence object.
+ *
+ * The rank will be the number of bins in the scene.  Whenever a rendering
+ * thread hits a fence command, it'll increment the fence counter.  When
+ * the counter == the rank, the fence is finished.
+ *
+ * \param rank  the expected finished value of the fence counter.
+ */
 struct lp_fence *
 lp_fence_create(unsigned rank)
 {
@@ -49,6 +58,7 @@ lp_fence_create(unsigned rank)
 }
 
 
+/** Destroy a fence.  Called when refcount hits zero. */
 static void
 lp_fence_destroy(struct lp_fence *fence)
 {
@@ -58,6 +68,10 @@ lp_fence_destroy(struct lp_fence *fence)
 }
 
 
+/**
+ * For reference counting.
+ * This is a Gallium API function.
+ */
 static void
 llvmpipe_fence_reference(struct pipe_screen *screen,
                          struct pipe_fence_handle **ptr,
@@ -72,6 +86,10 @@ llvmpipe_fence_reference(struct pipe_screen *screen,
 }
 
 
+/**
+ * Has the fence been executed/finished?
+ * This is a Gallium API function.
+ */
 static int
 llvmpipe_fence_signalled(struct pipe_screen *screen,
                          struct pipe_fence_handle *fence,
@@ -83,6 +101,10 @@ llvmpipe_fence_signalled(struct pipe_screen *screen,
 }
 
 
+/**
+ * Wait for the fence to finish.
+ * This is a Gallium API function.
+ */
 static int
 llvmpipe_fence_finish(struct pipe_screen *screen,
                       struct pipe_fence_handle *fence_handle,
@@ -100,6 +122,10 @@ llvmpipe_fence_finish(struct pipe_screen *screen,
 }
 
 
+/**
+ * Called by the rendering threads to increment the fence counter.
+ * When the counter == the rank, the fence is finished.
+ */
 void
 lp_fence_signal(struct lp_fence *fence)
 {
diff --git a/src/gallium/drivers/llvmpipe/lp_flush.c b/src/gallium/drivers/llvmpipe/lp_flush.c
index 6aeb1a79774..a248142b1de 100644
--- a/src/gallium/drivers/llvmpipe/lp_flush.c
+++ b/src/gallium/drivers/llvmpipe/lp_flush.c
@@ -102,7 +102,7 @@ llvmpipe_flush( struct pipe_context *pipe,
  */
 boolean
 llvmpipe_flush_texture(struct pipe_context *pipe,
-                       struct pipe_texture *texture,
+                       struct pipe_resource *texture,
                        unsigned face,
                        unsigned level,
                        unsigned flush_flags,
@@ -112,7 +112,7 @@ llvmpipe_flush_texture(struct pipe_context *pipe,
 {
    unsigned referenced;
 
-   referenced = pipe->is_texture_referenced(pipe, texture, face, level);
+   referenced = pipe->is_resource_referenced(pipe, texture, face, level);
 
    if ((referenced & PIPE_REFERENCED_FOR_WRITE) ||
        ((referenced & PIPE_REFERENCED_FOR_READ) && !read_only)) {
diff --git a/src/gallium/drivers/llvmpipe/lp_flush.h b/src/gallium/drivers/llvmpipe/lp_flush.h
index e13f57ccec5..2375d22b854 100644
--- a/src/gallium/drivers/llvmpipe/lp_flush.h
+++ b/src/gallium/drivers/llvmpipe/lp_flush.h
@@ -38,7 +38,7 @@ void llvmpipe_flush(struct pipe_context *pipe, unsigned flags,
 
 boolean
 llvmpipe_flush_texture(struct pipe_context *pipe,
-                       struct pipe_texture *texture,
+                       struct pipe_resource *texture,
                        unsigned face,
                        unsigned level,
                        unsigned flush_flags,
diff --git a/src/gallium/drivers/llvmpipe/lp_jit.c b/src/gallium/drivers/llvmpipe/lp_jit.c
index d15a34c633e..7e8a117cc82 100644
--- a/src/gallium/drivers/llvmpipe/lp_jit.c
+++ b/src/gallium/drivers/llvmpipe/lp_jit.c
@@ -166,8 +166,6 @@ lp_jit_screen_cleanup(struct llvmpipe_screen *screen)
 void
 lp_jit_screen_init(struct llvmpipe_screen *screen)
 {
-   char *error = NULL;
-
    util_cpu_detect();
 
 #if 0
@@ -179,17 +177,10 @@ lp_jit_screen_init(struct llvmpipe_screen *screen)
 
    lp_build_init();
 
-   screen->module = LLVMModuleCreateWithName("llvmpipe");
-
-   screen->provider = LLVMCreateModuleProviderForExistingModule(screen->module);
-
-   if (LLVMCreateJITCompiler(&screen->engine, screen->provider, 1, &error)) {
-      _debug_printf("%s\n", error);
-      LLVMDisposeMessage(error);
-      assert(0);
-   }
-
-   screen->target = LLVMGetExecutionEngineTargetData(screen->engine);
+   screen->module = lp_build_module;
+   screen->provider = lp_build_provider;
+   screen->engine = lp_build_engine;
+   screen->target = lp_build_target;
 
    screen->pass = LLVMCreateFunctionPassManager(screen->provider);
    LLVMAddTargetData(screen->target, screen->pass);
diff --git a/src/gallium/drivers/llvmpipe/lp_rast.c b/src/gallium/drivers/llvmpipe/lp_rast.c
index f3ac77a7092..4574f411456 100644
--- a/src/gallium/drivers/llvmpipe/lp_rast.c
+++ b/src/gallium/drivers/llvmpipe/lp_rast.c
@@ -65,8 +65,7 @@ lp_rast_begin( struct lp_rasterizer *rast,
       rast->cbuf[i].tiles_per_row = align(cbuf->width, TILE_SIZE) / TILE_SIZE;
       rast->cbuf[i].blocksize = 
          util_format_get_blocksize(cbuf->texture->format);
-
-      rast->cbuf[i].map = llvmpipe_texture_map(cbuf->texture,
+      rast->cbuf[i].map = llvmpipe_resource_map(cbuf->texture,
                                                cbuf->face,
                                                cbuf->level,
                                                cbuf->zslice,
@@ -76,12 +75,11 @@ lp_rast_begin( struct lp_rasterizer *rast,
 
    if (fb->zsbuf) {
       struct pipe_surface *zsbuf = scene->fb.zsbuf;
-      rast->zsbuf.stride = llvmpipe_texture_stride(zsbuf->texture,
-                                                   zsbuf->level);
+      rast->zsbuf.stride = llvmpipe_resource_stride(zsbuf->texture, zsbuf->level);
       rast->zsbuf.blocksize = 
          util_format_get_blocksize(zsbuf->texture->format);
 
-      rast->zsbuf.map = llvmpipe_texture_map(zsbuf->texture,
+      rast->zsbuf.map = llvmpipe_resource_map(zsbuf->texture,
                                              zsbuf->face,
                                              zsbuf->level,
                                              zsbuf->zslice,
@@ -103,7 +101,7 @@ lp_rast_end( struct lp_rasterizer *rast )
    /* Unmap color buffers */
    for (i = 0; i < rast->state.nr_cbufs; i++) {
       struct pipe_surface *cbuf = scene->fb.cbufs[i];
-      llvmpipe_texture_unmap(cbuf->texture,
+      llvmpipe_resource_unmap(cbuf->texture,
                              cbuf->face,
                              cbuf->level,
                              cbuf->zslice);
@@ -113,7 +111,7 @@ lp_rast_end( struct lp_rasterizer *rast )
    /* Unmap z/stencil buffer */
    if (rast->zsbuf.map) {
       struct pipe_surface *zsbuf = scene->fb.zsbuf;
-      llvmpipe_texture_unmap(zsbuf->texture,
+      llvmpipe_resource_unmap(zsbuf->texture,
                              zsbuf->face,
                              zsbuf->level,
                              zsbuf->zslice);
@@ -160,9 +158,9 @@ lp_rast_tile_begin(struct lp_rasterizer_task *task,
    /* get pointers to color tile(s) */
    for (buf = 0; buf < rast->state.nr_cbufs; buf++) {
       struct pipe_surface *cbuf = rast->curr_scene->fb.cbufs[buf];
-      struct llvmpipe_texture *lpt;
+      struct llvmpipe_resource *lpt;
       assert(cbuf);
-      lpt = llvmpipe_texture(cbuf->texture);
+      lpt = llvmpipe_resource(cbuf->texture);
       task->color_tiles[buf] = llvmpipe_get_texture_tile(lpt,
                                                          cbuf->face,
                                                          cbuf->level,
@@ -175,7 +173,7 @@ lp_rast_tile_begin(struct lp_rasterizer_task *task,
    {
       struct pipe_surface *zsbuf = rast->curr_scene->fb.zsbuf;
       if (zsbuf) {
-         struct llvmpipe_texture *lpt = llvmpipe_texture(zsbuf->texture);
+         struct llvmpipe_resource *lpt = llvmpipe_resource(zsbuf->texture);
 
          if (scene->has_depth_clear)
             usage = LP_TEX_USAGE_WRITE_ALL;
@@ -376,7 +374,7 @@ lp_rast_store_color( struct lp_rasterizer_task *task,
    for (buf = 0; buf < rast->state.nr_cbufs; buf++) {
       struct pipe_surface *cbuf = scene->fb.cbufs[buf];
       const unsigned face = cbuf->face, level = cbuf->level;
-      struct llvmpipe_texture *lpt = llvmpipe_texture(cbuf->texture);
+      struct llvmpipe_resource *lpt = llvmpipe_resource(cbuf->texture);
       /* this will convert the tiled data to linear if needed */
       (void) llvmpipe_get_texture_tile_linear(lpt, face,level,
                                               LP_TEX_USAGE_READ,
diff --git a/src/gallium/drivers/llvmpipe/lp_scene.c b/src/gallium/drivers/llvmpipe/lp_scene.c
index 6d9ff4dac76..182e7cb2303 100644
--- a/src/gallium/drivers/llvmpipe/lp_scene.c
+++ b/src/gallium/drivers/llvmpipe/lp_scene.c
@@ -181,7 +181,7 @@ lp_scene_reset(struct lp_scene *scene )
       struct texture_ref *ref, *next, *ref_list = &scene->textures;
       for (ref = ref_list->next; ref != ref_list; ref = next) {
          next = next_elem(ref);
-         pipe_texture_reference(&ref->texture, NULL);
+         pipe_resource_reference(&ref->texture, NULL);
          FREE(ref);
       }
       make_empty_list(ref_list);
@@ -251,12 +251,12 @@ lp_scene_bin_size( const struct lp_scene *scene, unsigned x, unsigned y )
  */
 void
 lp_scene_texture_reference( struct lp_scene *scene,
-                            struct pipe_texture *texture )
+                            struct pipe_resource *texture )
 {
    struct texture_ref *ref = CALLOC_STRUCT(texture_ref);
    if (ref) {
       struct texture_ref *ref_list = &scene->textures;
-      pipe_texture_reference(&ref->texture, texture);
+      pipe_resource_reference(&ref->texture, texture);
       insert_at_tail(ref_list, ref);
    }
 }
@@ -266,8 +266,8 @@ lp_scene_texture_reference( struct lp_scene *scene,
  * Does this scene have a reference to the given texture?
  */
 boolean
-lp_scene_is_texture_referenced( const struct lp_scene *scene,
-                                const struct pipe_texture *texture )
+lp_scene_is_resource_referenced( const struct lp_scene *scene,
+                                const struct pipe_resource *texture )
 {
    const struct texture_ref *ref_list = &scene->textures;
    const struct texture_ref *ref;
@@ -426,7 +426,7 @@ lp_scene_unmap_buffers( struct lp_scene *scene )
    for (i = 0; i < scene->fb.nr_cbufs; i++) {
       if (scene->cbuf_map[i]) {
          struct pipe_surface *cbuf = scene->fb.cbufs[i];
-         llvmpipe_texture_unmap(cbuf->texture,
+         llvmpipe_resource_unmap(cbuf->texture,
                                 cbuf->face,
                                 cbuf->level,
                                 cbuf->zslice);
@@ -436,7 +436,7 @@ lp_scene_unmap_buffers( struct lp_scene *scene )
 
    if (scene->zsbuf_map) {
       struct pipe_surface *zsbuf = scene->fb.zsbuf;
-      llvmpipe_texture_unmap(zsbuf->texture,
+      llvmpipe_resource_unmap(zsbuf->texture,
                              zsbuf->face,
                              zsbuf->level,
                              zsbuf->zslice);
diff --git a/src/gallium/drivers/llvmpipe/lp_scene.h b/src/gallium/drivers/llvmpipe/lp_scene.h
index 421d685796f..ac0717db6a1 100644
--- a/src/gallium/drivers/llvmpipe/lp_scene.h
+++ b/src/gallium/drivers/llvmpipe/lp_scene.h
@@ -99,7 +99,7 @@ struct data_block_list {
 
 /** List of texture references */
 struct texture_ref {
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct texture_ref *prev, *next;  /**< linked list w/ u_simple_list.h */
 };
 
@@ -165,10 +165,10 @@ unsigned lp_scene_data_size( const struct lp_scene *scene );
 unsigned lp_scene_bin_size( const struct lp_scene *scene, unsigned x, unsigned y );
 
 void lp_scene_texture_reference( struct lp_scene *scene,
-                                 struct pipe_texture *texture );
+                                 struct pipe_resource *texture );
 
-boolean lp_scene_is_texture_referenced( const struct lp_scene *scene,
-                                        const struct pipe_texture *texture );
+boolean lp_scene_is_resource_referenced( const struct lp_scene *scene,
+                                        const struct pipe_resource *texture );
 
 
 /**
diff --git a/src/gallium/drivers/llvmpipe/lp_screen.c b/src/gallium/drivers/llvmpipe/lp_screen.c
index 625d4092db6..a30f3c4e9f4 100644
--- a/src/gallium/drivers/llvmpipe/lp_screen.c
+++ b/src/gallium/drivers/llvmpipe/lp_screen.c
@@ -28,11 +28,11 @@
 
 #include "util/u_memory.h"
 #include "util/u_format.h"
+#include "util/u_format_s3tc.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_screen.h"
 
 #include "lp_texture.h"
-#include "lp_buffer.h"
 #include "lp_fence.h"
 #include "lp_jit.h"
 #include "lp_screen.h"
@@ -186,32 +186,37 @@ llvmpipe_is_format_supported( struct pipe_screen *_screen,
    case PIPE_FORMAT_DXT1_RGBA:
    case PIPE_FORMAT_DXT3_RGBA:
    case PIPE_FORMAT_DXT5_RGBA:
+      return util_format_s3tc_enabled;
+   case PIPE_FORMAT_R16_FLOAT:
+   case PIPE_FORMAT_R16G16_FLOAT:
+   case PIPE_FORMAT_R16G16B16_FLOAT:
+   case PIPE_FORMAT_R16G16B16A16_FLOAT:
       return FALSE;
    default:
       break;
    }
 
-   if(format_desc->block.width != 1 ||
-      format_desc->block.height != 1)
-      return FALSE;
+   if(tex_usage & PIPE_BIND_RENDER_TARGET) {
+      if(format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN)
+         return FALSE;
 
-   if(format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN)
-      return FALSE;
+      if(format_desc->block.width != 1 ||
+         format_desc->block.height != 1)
+         return FALSE;
 
-   if(tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET) {
       if(format_desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB &&
          format_desc->colorspace != UTIL_FORMAT_COLORSPACE_SRGB)
          return FALSE;
    }
 
-   if(tex_usage & (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                   PIPE_TEXTURE_USAGE_SCANOUT |
-                   PIPE_TEXTURE_USAGE_SHARED)) {
+   if(tex_usage & (PIPE_BIND_DISPLAY_TARGET |
+                   PIPE_BIND_SCANOUT |
+                   PIPE_BIND_SHARED)) {
       if(!winsys->is_displaytarget_format_supported(winsys, tex_usage, format))
          return FALSE;
    }
 
-   if(tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL) {
+   if(tex_usage & PIPE_BIND_DEPTH_STENCIL) {
       if(format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS)
          return FALSE;
 
@@ -220,17 +225,6 @@ llvmpipe_is_format_supported( struct pipe_screen *_screen,
          return FALSE;
    }
 
-   /* FIXME: Temporary restrictions. See lp_bld_sample_soa.c */
-   if(tex_usage & PIPE_TEXTURE_USAGE_SAMPLER) {
-      if(!format_desc->is_bitmask &&
-         format != PIPE_FORMAT_R32_FLOAT)
-         return FALSE;
-
-      if(format_desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB &&
-         format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS)
-         return FALSE;
-   }
-
    return TRUE;
 }
 
@@ -244,7 +238,7 @@ llvmpipe_flush_frontbuffer(struct pipe_screen *_screen,
 {
    struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
    struct sw_winsys *winsys = screen->winsys;
-   struct llvmpipe_texture *texture = llvmpipe_texture(surface->texture);
+   struct llvmpipe_resource *texture = llvmpipe_resource(surface->texture);
 
    assert(texture->dt);
    if (texture->dt)
@@ -297,8 +291,9 @@ llvmpipe_create_screen(struct sw_winsys *winsys)
    screen->base.context_create = llvmpipe_create_context;
    screen->base.flush_frontbuffer = llvmpipe_flush_frontbuffer;
 
-   llvmpipe_init_screen_texture_funcs(&screen->base);
-   llvmpipe_init_screen_buffer_funcs(&screen->base);
+   util_format_s3tc_init();
+
+   llvmpipe_init_screen_resource_funcs(&screen->base);
    llvmpipe_init_screen_fence_funcs(&screen->base);
 
    lp_jit_screen_init(screen);
diff --git a/src/gallium/drivers/llvmpipe/lp_setup.c b/src/gallium/drivers/llvmpipe/lp_setup.c
index 85152426068..97a6b5422bd 100644
--- a/src/gallium/drivers/llvmpipe/lp_setup.c
+++ b/src/gallium/drivers/llvmpipe/lp_setup.c
@@ -39,7 +39,6 @@
 #include "util/u_surface.h"
 #include "lp_scene.h"
 #include "lp_scene_queue.h"
-#include "lp_buffer.h"
 #include "lp_texture.h"
 #include "lp_debug.h"
 #include "lp_fence.h"
@@ -405,11 +404,11 @@ lp_setup_set_fs_functions( struct lp_setup_context *setup,
 
 void
 lp_setup_set_fs_constants(struct lp_setup_context *setup,
-                          struct pipe_buffer *buffer)
+                          struct pipe_resource *buffer)
 {
    LP_DBG(DEBUG_SETUP, "%s %p\n", __FUNCTION__, (void *) buffer);
 
-   pipe_buffer_reference(&setup->constants.current, buffer);
+   pipe_resource_reference(&setup->constants.current, buffer);
 
    setup->dirty |= LP_SETUP_NEW_CONSTANTS;
 }
@@ -507,8 +506,8 @@ lp_setup_set_fragment_sampler_views(struct lp_setup_context *setup,
       struct pipe_sampler_view *view = i < num ? views[i] : NULL;
 
       if(view) {
-         struct pipe_texture *tex = view->texture;
-         struct llvmpipe_texture *lp_tex = llvmpipe_texture(tex);
+         struct pipe_resource *tex = view->texture;
+         struct llvmpipe_resource *lp_tex = llvmpipe_resource(tex);
          struct lp_jit_texture *jit_tex;
          jit_tex = &setup->fs.current.jit_context.textures[i];
          jit_tex->width = tex->width0;
@@ -519,7 +518,7 @@ lp_setup_set_fragment_sampler_views(struct lp_setup_context *setup,
          /* We're referencing the texture's internal data, so save a
           * reference to it.
           */
-         pipe_texture_reference(&setup->fs.current_tex[i], tex);
+         pipe_resource_reference(&setup->fs.current_tex[i], tex);
 
          if (!lp_tex->dt) {
             /* regular texture - setup array of mipmap level pointers */
@@ -545,7 +544,7 @@ lp_setup_set_fragment_sampler_views(struct lp_setup_context *setup,
             struct llvmpipe_screen *screen = llvmpipe_screen(tex->screen);
             struct sw_winsys *winsys = screen->winsys;
             jit_tex->data[0] = winsys->displaytarget_map(winsys, lp_tex->dt,
-                                                      PIPE_BUFFER_USAGE_CPU_READ);
+							 PIPE_TRANSFER_READ);
             jit_tex->row_stride[0] = lp_tex->stride[0];
             assert(jit_tex->data[0]);
          }
@@ -562,8 +561,8 @@ lp_setup_set_fragment_sampler_views(struct lp_setup_context *setup,
  * being rendered and the current scene being built.
  */
 unsigned
-lp_setup_is_texture_referenced( const struct lp_setup_context *setup,
-                                const struct pipe_texture *texture )
+lp_setup_is_resource_referenced( const struct lp_setup_context *setup,
+                                const struct pipe_resource *texture )
 {
    unsigned i;
 
@@ -578,7 +577,7 @@ lp_setup_is_texture_referenced( const struct lp_setup_context *setup,
 
    /* check textures referenced by the scene */
    for (i = 0; i < Elements(setup->scenes); i++) {
-      if (lp_scene_is_texture_referenced(setup->scenes[i], texture)) {
+      if (lp_scene_is_resource_referenced(setup->scenes[i], texture)) {
          return PIPE_REFERENCED_FOR_READ;
       }
    }
@@ -639,11 +638,11 @@ lp_setup_update_state( struct lp_setup_context *setup )
    }
 
    if(setup->dirty & LP_SETUP_NEW_CONSTANTS) {
-      struct pipe_buffer *buffer = setup->constants.current;
+      struct pipe_resource *buffer = setup->constants.current;
 
       if(buffer) {
-         unsigned current_size = buffer->size;
-         const void *current_data = llvmpipe_buffer(buffer)->data;
+         unsigned current_size = buffer->width0;
+         const void *current_data = llvmpipe_resource_data(buffer);
 
          /* TODO: copy only the actually used constants? */
 
@@ -725,10 +724,10 @@ lp_setup_destroy( struct lp_setup_context *setup )
    reset_context( setup );
 
    for (i = 0; i < Elements(setup->fs.current_tex); i++) {
-      pipe_texture_reference(&setup->fs.current_tex[i], NULL);
+      pipe_resource_reference(&setup->fs.current_tex[i], NULL);
    }
 
-   pipe_buffer_reference(&setup->constants.current, NULL);
+   pipe_resource_reference(&setup->constants.current, NULL);
 
    /* free the scenes in the 'empty' queue */
    while (1) {
diff --git a/src/gallium/drivers/llvmpipe/lp_setup.h b/src/gallium/drivers/llvmpipe/lp_setup.h
index dbfc1bf8d4c..e10d37d8d04 100644
--- a/src/gallium/drivers/llvmpipe/lp_setup.h
+++ b/src/gallium/drivers/llvmpipe/lp_setup.h
@@ -52,9 +52,8 @@ struct lp_shader_input {
    unsigned src_index;          /* where to find values in incoming vertices */
 };
 
-struct pipe_texture;
+struct pipe_resource;
 struct pipe_surface;
-struct pipe_buffer;
 struct pipe_blend_color;
 struct pipe_screen;
 struct pipe_framebuffer_state;
@@ -105,7 +104,7 @@ lp_setup_set_fs_functions( struct lp_setup_context *setup,
 
 void
 lp_setup_set_fs_constants(struct lp_setup_context *setup,
-                          struct pipe_buffer *buffer);
+                          struct pipe_resource *buffer);
 
 
 void
@@ -130,8 +129,8 @@ lp_setup_set_fragment_sampler_views(struct lp_setup_context *setup,
                                     struct pipe_sampler_view **views);
 
 unsigned
-lp_setup_is_texture_referenced( const struct lp_setup_context *setup,
-                                const struct pipe_texture *texture );
+lp_setup_is_resource_referenced( const struct lp_setup_context *setup,
+                                const struct pipe_resource *texture );
 
 void
 lp_setup_set_flatshade_first( struct lp_setup_context *setup, 
diff --git a/src/gallium/drivers/llvmpipe/lp_setup_context.h b/src/gallium/drivers/llvmpipe/lp_setup_context.h
index 3804adb6b8b..4594f7597d5 100644
--- a/src/gallium/drivers/llvmpipe/lp_setup_context.h
+++ b/src/gallium/drivers/llvmpipe/lp_setup_context.h
@@ -111,12 +111,12 @@ struct lp_setup_context
 
       const struct lp_rast_state *stored; /**< what's in the scene */
       struct lp_rast_state current;  /**< currently set state */
-      struct pipe_texture *current_tex[PIPE_MAX_SAMPLERS];
+      struct pipe_resource *current_tex[PIPE_MAX_SAMPLERS];
    } fs;
 
    /** fragment shader constants */
    struct {
-      struct pipe_buffer *current;
+      struct pipe_resource *current;
       unsigned stored_size;
       const void *stored_data;
    } constants;
diff --git a/src/gallium/drivers/llvmpipe/lp_state.h b/src/gallium/drivers/llvmpipe/lp_state.h
index 74ebf90d580..d89c28a2af2 100644
--- a/src/gallium/drivers/llvmpipe/lp_state.h
+++ b/src/gallium/drivers/llvmpipe/lp_state.h
@@ -170,7 +170,7 @@ void llvmpipe_set_clip_state( struct pipe_context *,
 
 void llvmpipe_set_constant_buffer(struct pipe_context *,
                                   uint shader, uint index,
-                                  struct pipe_buffer *buf);
+                                  struct pipe_resource *buf);
 
 void *llvmpipe_create_fs_state(struct pipe_context *,
                                const struct pipe_shader_state *);
@@ -204,7 +204,7 @@ llvmpipe_set_vertex_sampler_views(struct pipe_context *,
 
 struct pipe_sampler_view *
 llvmpipe_create_sampler_view(struct pipe_context *pipe,
-                            struct pipe_texture *texture,
+                            struct pipe_resource *texture,
                             const struct pipe_sampler_view *templ);
 
 void
@@ -227,12 +227,12 @@ void llvmpipe_draw_arrays(struct pipe_context *pipe, unsigned mode,
 			     unsigned start, unsigned count);
 
 void llvmpipe_draw_elements(struct pipe_context *pipe,
-			       struct pipe_buffer *indexBuffer,
+			       struct pipe_resource *indexBuffer,
 			       unsigned indexSize,
 			       unsigned mode, unsigned start, unsigned count);
 void
 llvmpipe_draw_range_elements(struct pipe_context *pipe,
-                             struct pipe_buffer *indexBuffer,
+                             struct pipe_resource *indexBuffer,
                              unsigned indexSize,
                              unsigned min_index,
                              unsigned max_index,
diff --git a/src/gallium/drivers/llvmpipe/lp_state_fs.c b/src/gallium/drivers/llvmpipe/lp_state_fs.c
index 7bbf348e0b8..59ba0be2b9d 100644
--- a/src/gallium/drivers/llvmpipe/lp_state_fs.c
+++ b/src/gallium/drivers/llvmpipe/lp_state_fs.c
@@ -85,7 +85,6 @@
 #include "gallivm/lp_bld_swizzle.h"
 #include "gallivm/lp_bld_flow.h"
 #include "gallivm/lp_bld_debug.h"
-#include "lp_buffer.h"
 #include "lp_context.h"
 #include "lp_debug.h"
 #include "lp_perf.h"
@@ -1044,11 +1043,11 @@ llvmpipe_delete_fs_state(struct pipe_context *pipe, void *fs)
 void
 llvmpipe_set_constant_buffer(struct pipe_context *pipe,
                              uint shader, uint index,
-                             struct pipe_buffer *constants)
+                             struct pipe_resource *constants)
 {
    struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
-   unsigned size = constants ? constants->size : 0;
-   const void *data = constants ? llvmpipe_buffer(constants)->data : NULL;
+   unsigned size = constants ? constants->width0 : 0;
+   const void *data = constants ? llvmpipe_resource_data(constants) : NULL;
 
    assert(shader < PIPE_SHADER_TYPES);
    assert(index == 0);
@@ -1059,7 +1058,7 @@ llvmpipe_set_constant_buffer(struct pipe_context *pipe,
    draw_flush(llvmpipe->draw);
 
    /* note: reference counting */
-   pipe_buffer_reference(&llvmpipe->constants[shader], constants);
+   pipe_resource_reference(&llvmpipe->constants[shader], constants);
 
    if(shader == PIPE_SHADER_VERTEX) {
       draw_set_mapped_constant_buffer(llvmpipe->draw, PIPE_SHADER_VERTEX, 0,
@@ -1131,7 +1130,7 @@ make_variant_key(struct llvmpipe_context *lp,
 
    for(i = 0; i < PIPE_MAX_SAMPLERS; ++i)
       if(shader->info.file_mask[TGSI_FILE_SAMPLER] & (1 << i))
-         lp_sampler_static_state(&key->sampler[i], lp->fragment_sampler_views[i]->texture, lp->sampler[i]);
+         lp_sampler_static_state(&key->sampler[i], lp->fragment_sampler_views[i], lp->sampler[i]);
 }
 
 
diff --git a/src/gallium/drivers/llvmpipe/lp_state_sampler.c b/src/gallium/drivers/llvmpipe/lp_state_sampler.c
index 2645441b58c..3552ff50ce1 100644
--- a/src/gallium/drivers/llvmpipe/lp_state_sampler.c
+++ b/src/gallium/drivers/llvmpipe/lp_state_sampler.c
@@ -165,7 +165,7 @@ llvmpipe_set_vertex_sampler_views(struct pipe_context *pipe,
 
 struct pipe_sampler_view *
 llvmpipe_create_sampler_view(struct pipe_context *pipe,
-                            struct pipe_texture *texture,
+                            struct pipe_resource *texture,
                             const struct pipe_sampler_view *templ)
 {
    struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
@@ -174,7 +174,7 @@ llvmpipe_create_sampler_view(struct pipe_context *pipe,
       *view = *templ;
       view->reference.count = 1;
       view->texture = NULL;
-      pipe_texture_reference(&view->texture, texture);
+      pipe_resource_reference(&view->texture, texture);
       view->context = pipe;
    }
 
@@ -186,7 +186,7 @@ void
 llvmpipe_sampler_view_destroy(struct pipe_context *pipe,
                               struct pipe_sampler_view *view)
 {
-   pipe_texture_reference(&view->texture, NULL);
+   pipe_resource_reference(&view->texture, NULL);
    FREE(view);
 }
 
diff --git a/src/gallium/drivers/llvmpipe/lp_surface.c b/src/gallium/drivers/llvmpipe/lp_surface.c
index 0c4c64937c1..381c58ecee5 100644
--- a/src/gallium/drivers/llvmpipe/lp_surface.c
+++ b/src/gallium/drivers/llvmpipe/lp_surface.c
@@ -74,8 +74,8 @@ lp_surface_copy(struct pipe_context *pipe,
     * to a linear image.
     */
    {
-      struct llvmpipe_texture *src_tex = llvmpipe_texture(src->texture);
-      struct llvmpipe_texture *dst_tex = llvmpipe_texture(dst->texture);
+      struct llvmpipe_resource *src_tex = llvmpipe_resource(src->texture);
+      struct llvmpipe_resource *dst_tex = llvmpipe_resource(dst->texture);
       enum pipe_format format = src_tex->base.format;
 
       /*
diff --git a/src/gallium/drivers/llvmpipe/lp_texture.c b/src/gallium/drivers/llvmpipe/lp_texture.c
index 8e8b81bcd84..7e4e4d5f0be 100644
--- a/src/gallium/drivers/llvmpipe/lp_texture.c
+++ b/src/gallium/drivers/llvmpipe/lp_texture.c
@@ -39,17 +39,34 @@
 #include "util/u_format.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
+#include "util/u_transfer.h"
 
 #include "lp_context.h"
 #include "lp_flush.h"
 #include "lp_screen.h"
 #include "lp_tile_image.h"
 #include "lp_texture.h"
+#include "lp_setup.h"
 #include "lp_tile_size.h"
 
 #include "state_tracker/sw_winsys.h"
 
 
+static INLINE boolean
+resource_is_texture(const struct pipe_resource *resource)
+{
+   const unsigned tex_binds = (PIPE_BIND_DISPLAY_TARGET |
+                               PIPE_BIND_SCANOUT |
+                               PIPE_BIND_SHARED |
+                               PIPE_BIND_DEPTH_STENCIL |
+                               PIPE_BIND_SAMPLER_VIEW);
+   const struct llvmpipe_resource *lpt = llvmpipe_resource_const(resource);
+
+   return (lpt->base.bind & tex_binds) ? TRUE : FALSE;
+}
+
+
+
 /**
  * Allocate storage for llvmpipe_texture::layout array.
  * The number of elements is width_in_tiles * height_in_tiles.
@@ -75,9 +92,9 @@ alloc_layout_array(unsigned width, unsigned height)
  */
 static boolean
 llvmpipe_texture_layout(struct llvmpipe_screen *screen,
-                        struct llvmpipe_texture *lpt)
+                        struct llvmpipe_resource *lpt)
 {
-   struct pipe_texture *pt = &lpt->base;
+   struct pipe_resource *pt = &lpt->base;
    unsigned level;
    unsigned width = pt->width0;
    unsigned height = pt->height0;
@@ -114,7 +131,7 @@ llvmpipe_texture_layout(struct llvmpipe_screen *screen,
 
 static boolean
 llvmpipe_displaytarget_layout(struct llvmpipe_screen *screen,
-                              struct llvmpipe_texture *lpt)
+                              struct llvmpipe_resource *lpt)
 {
    struct sw_winsys *winsys = screen->winsys;
 
@@ -129,7 +146,7 @@ llvmpipe_displaytarget_layout(struct llvmpipe_screen *screen,
    lpt->layout[0][0] = alloc_layout_array(width, height);
 
    lpt->dt = winsys->displaytarget_create(winsys,
-                                          lpt->base.tex_usage,
+                                          lpt->base.bind,
                                           lpt->base.format,
                                           width, height,
                                           16,
@@ -139,13 +156,13 @@ llvmpipe_displaytarget_layout(struct llvmpipe_screen *screen,
 }
 
 
-static struct pipe_texture *
-llvmpipe_texture_create(struct pipe_screen *_screen,
-                        const struct pipe_texture *templat)
+static struct pipe_resource *
+llvmpipe_resource_create(struct pipe_screen *_screen,
+                         const struct pipe_resource *templat)
 {
    static unsigned id_counter = 0;
    struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
-   struct llvmpipe_texture *lpt = CALLOC_STRUCT(llvmpipe_texture);
+   struct llvmpipe_resource *lpt = CALLOC_STRUCT(llvmpipe_resource);
    if (!lpt)
       return NULL;
 
@@ -153,18 +170,35 @@ llvmpipe_texture_create(struct pipe_screen *_screen,
    pipe_reference_init(&lpt->base.reference, 1);
    lpt->base.screen = &screen->base;
 
-   if (lpt->base.tex_usage & (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                              PIPE_TEXTURE_USAGE_SCANOUT |
-                              PIPE_TEXTURE_USAGE_SHARED)) {
+   assert(lpt->base.bind);
+
+   if (lpt->base.bind & (PIPE_BIND_DISPLAY_TARGET |
+                         PIPE_BIND_SCANOUT |
+                         PIPE_BIND_SHARED)) {
+      /* displayable surface */
       if (!llvmpipe_displaytarget_layout(screen, lpt))
          goto fail;
+      assert(lpt->layout[0][0][0] == LP_TEX_LAYOUT_NONE);
    }
-   else {
+   else if (lpt->base.bind & (PIPE_BIND_SAMPLER_VIEW |
+                              PIPE_BIND_DEPTH_STENCIL)) {
+      /* texture map */
       if (!llvmpipe_texture_layout(screen, lpt))
          goto fail;
+      assert(lpt->layout[0][0][0] == LP_TEX_LAYOUT_NONE);
+   }
+   else {
+      /* other data (vertex buffer, const buffer, etc) */
+      const enum pipe_format format = templat->format;
+      const uint w = templat->width0 / util_format_get_blockheight(format);
+      const uint h = templat->height0 / util_format_get_blockwidth(format);
+      const uint d = templat->depth0;
+      const uint bpp = util_format_get_blocksize(format);
+      const uint bytes = w * h * d * bpp;
+      lpt->data = align_malloc(bytes, 16);
+      if (!lpt->data)
+         goto fail;
    }
-
-   assert(lpt->layout[0][0][0] == LP_TEX_LAYOUT_NONE);
 
    lpt->id = id_counter++;
 
@@ -177,19 +211,21 @@ llvmpipe_texture_create(struct pipe_screen *_screen,
 
 
 static void
-llvmpipe_texture_destroy(struct pipe_texture *pt)
+llvmpipe_resource_destroy(struct pipe_screen *pscreen,
+			  struct pipe_resource *pt)
 {
-   struct llvmpipe_screen *screen = llvmpipe_screen(pt->screen);
-   struct llvmpipe_texture *lpt = llvmpipe_texture(pt);
+   struct llvmpipe_screen *screen = llvmpipe_screen(pscreen);
+   struct llvmpipe_resource *lpt = llvmpipe_resource(pt);
 
    if (lpt->dt) {
       /* display target */
       struct sw_winsys *winsys = screen->winsys;
       winsys->displaytarget_destroy(winsys, lpt->dt);
    }
-   else {
+   else if (resource_is_texture(pt)) {
       /* regular texture */
-      uint level;
+      const uint num_faces = pt->target == PIPE_TEXTURE_CUBE ? 6 : 1;
+      uint level, face;
 
       /* free linear image data */
       for (level = 0; level < Elements(lpt->linear); level++) {
@@ -206,6 +242,18 @@ llvmpipe_texture_destroy(struct pipe_texture *pt)
             lpt->tiled[level].data = NULL;
          }
       }
+
+      /* free layout flag arrays */
+      for (level = 0; level < Elements(lpt->tiled); level++) {
+         for (face = 0; face < num_faces; face++) {
+            free(lpt->layout[face][level]);
+            lpt->layout[face][level] = NULL;
+         }
+      }
+   }
+   else if (!lpt->userBuffer) {
+      assert(lpt->data);
+      align_free(lpt->data);
    }
 
    FREE(lpt);
@@ -216,16 +264,15 @@ llvmpipe_texture_destroy(struct pipe_texture *pt)
  * Map a texture for read/write (rendering).  Without any synchronization.
  */
 void *
-llvmpipe_texture_map(struct pipe_texture *texture,
-                     unsigned face,
-                     unsigned level,
-                     unsigned zslice,
-                     enum lp_texture_usage tex_usage,
-                     enum lp_texture_layout layout)
+llvmpipe_resource_map(struct pipe_resource *texture,
+		      unsigned face,
+		      unsigned level,
+		      unsigned zslice,
+                      enum lp_texture_usage tex_usage,
+                      enum lp_texture_layout layout)
 {
-   struct llvmpipe_texture *lpt = llvmpipe_texture(texture);
+   struct llvmpipe_resource *lpt = llvmpipe_resource(texture);
    uint8_t *map;
-   unsigned offset = 0;
 
    assert(face < 6);
    assert(level < LP_MAX_TEXTURE_LEVELS);
@@ -245,10 +292,10 @@ llvmpipe_texture_map(struct pipe_texture *texture,
       unsigned dt_usage;
 
       if (tex_usage == LP_TEX_USAGE_READ) {
-         dt_usage = PIPE_BUFFER_USAGE_CPU_READ;
+         dt_usage = PIPE_TRANSFER_READ;
       }
       else {
-         dt_usage = PIPE_BUFFER_USAGE_CPU_READ_WRITE;
+         dt_usage = PIPE_TRANSFER_READ_WRITE;
       }
 
       assert(face == 0);
@@ -260,13 +307,19 @@ llvmpipe_texture_map(struct pipe_texture *texture,
 
       /* install this linear image in texture data structure */
       lpt->linear[level].data = map;
+
+      map = llvmpipe_get_texture_image(lpt, face, level, tex_usage, layout);
+      assert(map);
+
+      return map;
    }
-   else {
+   else if (resource_is_texture(texture)) {
       /* regular texture */
-      unsigned tex_height = u_minify(texture->height0, level);
+      const unsigned tex_height = u_minify(texture->height0, level);
       const unsigned nblocksy =
          util_format_get_nblocksy(texture->format, tex_height);
       const unsigned stride = lpt->stride[level];
+      unsigned offset = 0;
 
       if (texture->target == PIPE_TEXTURE_CUBE) {
          /* XXX incorrect
@@ -281,13 +334,15 @@ llvmpipe_texture_map(struct pipe_texture *texture,
          assert(zslice == 0);
          offset = 0;
       }
-   }
 
-   map = llvmpipe_get_texture_image(lpt, face, level, tex_usage, layout);
-   assert(map);
-   map += offset;
-
-   return map;
+      map = llvmpipe_get_texture_image(lpt, face, level, tex_usage, layout);
+      assert(map);
+      map += offset;
+      return map;
+   }
+   else {
+      return lpt->data;
+   }
 }
 
 
@@ -295,12 +350,12 @@ llvmpipe_texture_map(struct pipe_texture *texture,
  * Unmap a texture. Without any synchronization.
  */
 void
-llvmpipe_texture_unmap(struct pipe_texture *texture,
+llvmpipe_resource_unmap(struct pipe_resource *texture,
                        unsigned face,
                        unsigned level,
                        unsigned zslice)
 {
-   struct llvmpipe_texture *lpt = llvmpipe_texture(texture);
+   struct llvmpipe_resource *lpt = llvmpipe_resource(texture);
 
    if (lpt->dt) {
       /* display target */
@@ -321,13 +376,27 @@ llvmpipe_texture_unmap(struct pipe_texture *texture,
 }
 
 
-static struct pipe_texture *
-llvmpipe_texture_from_handle(struct pipe_screen *screen,
-                             const struct pipe_texture *template,
-                             struct winsys_handle *whandle)
+void *
+llvmpipe_resource_data(struct pipe_resource *resource)
+{
+   struct llvmpipe_resource *lpt = llvmpipe_resource(resource);
+
+   assert((lpt->base.bind & (PIPE_BIND_DISPLAY_TARGET |
+                             PIPE_BIND_SCANOUT |
+                             PIPE_BIND_SHARED |
+                             PIPE_BIND_SAMPLER_VIEW)) == 0);
+
+   return lpt->data;
+}
+
+
+static struct pipe_resource *
+llvmpipe_resource_from_handle(struct pipe_screen *screen,
+			      const struct pipe_resource *template,
+			      struct winsys_handle *whandle)
 {
    struct sw_winsys *winsys = llvmpipe_screen(screen)->winsys;
-   struct llvmpipe_texture *lpt = CALLOC_STRUCT(llvmpipe_texture);
+   struct llvmpipe_resource *lpt = CALLOC_STRUCT(llvmpipe_resource);
    if (!lpt)
       return NULL;
 
@@ -351,12 +420,12 @@ llvmpipe_texture_from_handle(struct pipe_screen *screen,
 
 
 static boolean
-llvmpipe_texture_get_handle(struct pipe_screen *screen,
-                            struct pipe_texture *pt,
+llvmpipe_resource_get_handle(struct pipe_screen *screen,
+                            struct pipe_resource *pt,
                             struct winsys_handle *whandle)
 {
    struct sw_winsys *winsys = llvmpipe_screen(screen)->winsys;
-   struct llvmpipe_texture *lpt = llvmpipe_texture(pt);
+   struct llvmpipe_resource *lpt = llvmpipe_resource(pt);
 
    assert(lpt->dt);
    if (!lpt->dt)
@@ -368,11 +437,10 @@ llvmpipe_texture_get_handle(struct pipe_screen *screen,
 
 static struct pipe_surface *
 llvmpipe_get_tex_surface(struct pipe_screen *screen,
-                         struct pipe_texture *pt,
+                         struct pipe_resource *pt,
                          unsigned face, unsigned level, unsigned zslice,
                          enum lp_texture_usage usage)
 {
-   struct llvmpipe_texture *lpt = llvmpipe_texture(pt);
    struct pipe_surface *ps;
 
    assert(level <= pt->last_level);
@@ -380,32 +448,12 @@ llvmpipe_get_tex_surface(struct pipe_screen *screen,
    ps = CALLOC_STRUCT(pipe_surface);
    if (ps) {
       pipe_reference_init(&ps->reference, 1);
-      pipe_texture_reference(&ps->texture, pt);
+      pipe_resource_reference(&ps->texture, pt);
       ps->format = pt->format;
       ps->width = u_minify(pt->width0, level);
       ps->height = u_minify(pt->height0, level);
       ps->usage = usage;
 
-      /* Because we are llvmpipe, anything that the state tracker
-       * thought was going to be done with the GPU will actually get
-       * done with the CPU.  Let's adjust the flags to take that into
-       * account.
-       */
-      if (ps->usage & PIPE_BUFFER_USAGE_GPU_WRITE) {
-         /* GPU_WRITE means "render" and that can involve reads (blending) */
-         ps->usage |= PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_CPU_READ;
-      }
-
-      if (ps->usage & PIPE_BUFFER_USAGE_GPU_READ)
-         ps->usage |= PIPE_BUFFER_USAGE_CPU_READ;
-
-      if (ps->usage & (PIPE_BUFFER_USAGE_CPU_WRITE |
-                       PIPE_BUFFER_USAGE_GPU_WRITE)) {
-         /* Mark the surface as dirty. */
-         lpt->timestamp++;
-         llvmpipe_screen(screen)->timestamp++;
-      }
-
       ps->face = face;
       ps->level = level;
       ps->zslice = zslice;
@@ -422,37 +470,32 @@ llvmpipe_tex_surface_destroy(struct pipe_surface *surf)
     * where it would happen.  For llvmpipe, nothing to do.
     */
    assert(surf->texture);
-   pipe_texture_reference(&surf->texture, NULL);
+   pipe_resource_reference(&surf->texture, NULL);
    FREE(surf);
 }
 
 
 static struct pipe_transfer *
-llvmpipe_get_tex_transfer(struct pipe_context *pipe,
-                          struct pipe_texture *texture,
-                          unsigned face, unsigned level, unsigned zslice,
-                          enum pipe_transfer_usage usage,
-                          unsigned x, unsigned y, unsigned w, unsigned h)
+llvmpipe_get_transfer(struct pipe_context *pipe,
+		      struct pipe_resource *resource,
+		      struct pipe_subresource sr,
+		      unsigned usage,
+		      const struct pipe_box *box)
 {
-   struct llvmpipe_texture *lptex = llvmpipe_texture(texture);
+   struct llvmpipe_resource *lptex = llvmpipe_resource(resource);
    struct llvmpipe_transfer *lpt;
 
-   assert(texture);
-   assert(level <= texture->last_level);
+   assert(resource);
+   assert(sr.level <= resource->last_level);
 
    lpt = CALLOC_STRUCT(llvmpipe_transfer);
    if (lpt) {
       struct pipe_transfer *pt = &lpt->base;
-      pipe_texture_reference(&pt->texture, texture);
-      pt->x = x;
-      pt->y = y;
-      pt->width = align(w, TILE_SIZE);
-      pt->height = align(h, TILE_SIZE);
-      pt->stride = lptex->stride[level];
+      pipe_resource_reference(&pt->resource, resource);
+      pt->box = *box;
+      pt->sr = sr;
+      pt->stride = lptex->stride[sr.level];
       pt->usage = usage;
-      pt->face = face;
-      pt->level = level;
-      pt->zslice = zslice;
 
       return pt;
    }
@@ -461,15 +504,15 @@ llvmpipe_get_tex_transfer(struct pipe_context *pipe,
 
 
 static void 
-llvmpipe_tex_transfer_destroy(struct pipe_context *pipe,
+llvmpipe_transfer_destroy(struct pipe_context *pipe,
                               struct pipe_transfer *transfer)
 {
    /* Effectively do the texture_update work here - if texture images
     * needed post-processing to put them into hardware layout, this is
     * where it would happen.  For llvmpipe, nothing to do.
     */
-   assert (transfer->texture);
-   pipe_texture_reference(&transfer->texture, NULL);
+   assert (transfer->resource);
+   pipe_resource_reference(&transfer->resource, NULL);
    FREE(transfer);
 }
 
@@ -480,12 +523,13 @@ llvmpipe_transfer_map( struct pipe_context *pipe,
 {
    struct llvmpipe_screen *screen = llvmpipe_screen(pipe->screen);
    ubyte *map;
+   struct llvmpipe_resource *lpt;
    enum pipe_format format;
    enum lp_texture_usage tex_usage;
    const char *mode;
 
-   assert(transfer->face < 6);
-   assert(transfer->level < LP_MAX_TEXTURE_LEVELS);
+   assert(transfer->sr.face < 6);
+   assert(transfer->sr.level < LP_MAX_TEXTURE_LEVELS);
 
    /*
    printf("tex_transfer_map(%d, %d  %d x %d of %d x %d,  usage %d )\n",
@@ -504,30 +548,35 @@ llvmpipe_transfer_map( struct pipe_context *pipe,
       mode = "read/write";
    }
 
-   if(0){
-      struct llvmpipe_texture *lpt = llvmpipe_texture(transfer->texture);
+   if (0) {
+      struct llvmpipe_resource *lpt = llvmpipe_resource(transfer->resource);
       printf("transfer map tex %u  mode %s\n", lpt->id, mode);
    }
 
 
-   assert(transfer->texture);
-   format = transfer->texture->format;
+   assert(transfer->resource);
+   lpt = llvmpipe_resource(transfer->resource);
+   format = lpt->base.format;
 
    /*
     * Transfers, like other pipe operations, must happen in order, so flush the
     * context if necessary.
     */
    llvmpipe_flush_texture(pipe,
-                          transfer->texture, transfer->face, transfer->level,
+                          transfer->resource,
+			  transfer->sr.face,
+			  transfer->sr.level,
                           0, /* flush_flags */
                           !(transfer->usage & PIPE_TRANSFER_WRITE), /* read_only */
                           TRUE, /* cpu_access */
                           FALSE); /* do_not_flush */
 
-   /* get pointer to linear texture image */
-   map = llvmpipe_texture_map(transfer->texture, transfer->face,
-                              transfer->level, transfer->zslice,
-                              tex_usage, LP_TEX_LAYOUT_LINEAR);
+   map = llvmpipe_resource_map(transfer->resource,
+			       transfer->sr.face,
+			       transfer->sr.level,
+			       transfer->box.z,
+                               tex_usage, LP_TEX_LAYOUT_LINEAR);
+
 
    /* May want to do different things here depending on read/write nature
     * of the map:
@@ -539,8 +588,8 @@ llvmpipe_transfer_map( struct pipe_context *pipe,
    }
    
    map +=
-      transfer->y / util_format_get_blockheight(format) * transfer->stride +
-      transfer->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
+      transfer->box.y / util_format_get_blockheight(format) * transfer->stride +
+      transfer->box.x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
 
    return map;
 }
@@ -550,13 +599,57 @@ static void
 llvmpipe_transfer_unmap(struct pipe_context *pipe,
                         struct pipe_transfer *transfer)
 {
-   assert(transfer->texture);
+   assert(transfer->resource);
 
-   assert(transfer->face < 6);
-   assert(transfer->level < LP_MAX_TEXTURE_LEVELS);
+   llvmpipe_resource_unmap(transfer->resource,
+			   transfer->sr.face,
+			   transfer->sr.level,
+			   transfer->box.z);
+}
+
+static unsigned int
+llvmpipe_is_resource_referenced( struct pipe_context *pipe,
+				struct pipe_resource *presource,
+				unsigned face, unsigned level)
+{
+   struct llvmpipe_context *llvmpipe = llvmpipe_context( pipe );
+
+   if (presource->target == PIPE_BUFFER)
+      return PIPE_UNREFERENCED;
+   
+   return lp_setup_is_resource_referenced(llvmpipe->setup, presource);
+}
+
+
+
+/**
+ * Create buffer which wraps user-space data.
+ */
+static struct pipe_resource *
+llvmpipe_user_buffer_create(struct pipe_screen *screen,
+                            void *ptr,
+                            unsigned bytes,
+			    unsigned bind_flags)
+{
+   struct llvmpipe_resource *buffer;
+
+   buffer = CALLOC_STRUCT(llvmpipe_resource);
+   if(!buffer)
+      return NULL;
 
-   llvmpipe_texture_unmap(transfer->texture,
-                          transfer->face, transfer->level, transfer->zslice);
+   pipe_reference_init(&buffer->base.reference, 1);
+   buffer->base.screen = screen;
+   buffer->base.format = PIPE_FORMAT_R8_UNORM; /* ?? */
+   buffer->base.bind = bind_flags;
+   buffer->base._usage = PIPE_USAGE_IMMUTABLE;
+   buffer->base.flags = 0;
+   buffer->base.width0 = bytes;
+   buffer->base.height0 = 1;
+   buffer->base.depth0 = 1;
+   buffer->userBuffer = TRUE;
+   buffer->data = ptr;
+
+   return &buffer->base;
 }
 
 
@@ -565,7 +658,7 @@ llvmpipe_transfer_unmap(struct pipe_context *pipe,
  * for just one cube face.
  */
 static unsigned
-tex_image_face_size(const struct llvmpipe_texture *lpt, unsigned level,
+tex_image_face_size(const struct llvmpipe_resource *lpt, unsigned level,
                     enum lp_texture_layout layout)
 {
    /* for tiled layout, force a 32bpp format */
@@ -587,7 +680,7 @@ tex_image_face_size(const struct llvmpipe_texture *lpt, unsigned level,
  * including all cube faces.
  */
 static unsigned
-tex_image_size(const struct llvmpipe_texture *lpt, unsigned level,
+tex_image_size(const struct llvmpipe_resource *lpt, unsigned level,
                enum lp_texture_layout layout)
 {
    const unsigned buf_size = tex_image_face_size(lpt, level, layout);
@@ -659,7 +752,7 @@ layout_logic(enum lp_texture_layout cur_layout,
  * Return pointer to a texture image.  No tiled/linear conversion is done.
  */
 void *
-llvmpipe_get_texture_image_address(struct llvmpipe_texture *lpt,
+llvmpipe_get_texture_image_address(struct llvmpipe_resource *lpt,
                                    unsigned face, unsigned level,
                                    enum lp_texture_layout layout)
 {
@@ -690,7 +783,7 @@ llvmpipe_get_texture_image_address(struct llvmpipe_texture *lpt,
  * \param layout  either LP_TEX_LAYOUT_LINEAR or LP_TEX_LAYOUT_TILED
  */
 void *
-llvmpipe_get_texture_image(struct llvmpipe_texture *lpt,
+llvmpipe_get_texture_image(struct llvmpipe_resource *lpt,
                            unsigned face, unsigned level,
                            enum lp_texture_usage usage,
                            enum lp_texture_layout layout)
@@ -810,11 +903,12 @@ llvmpipe_get_texture_image(struct llvmpipe_texture *lpt,
 
 
 static INLINE enum lp_texture_layout
-llvmpipe_get_texture_tile_layout(const struct llvmpipe_texture *lpt,
+llvmpipe_get_texture_tile_layout(const struct llvmpipe_resource *lpt,
                                  unsigned face, unsigned level,
                                  unsigned x, unsigned y)
 {
    uint i;
+   assert(resource_is_texture(&lpt->base));
    assert(x < lpt->tiles_per_row[level]);
    i = y * lpt->tiles_per_row[level] + x;
    return lpt->layout[face][level][i];
@@ -822,12 +916,13 @@ llvmpipe_get_texture_tile_layout(const struct llvmpipe_texture *lpt,
 
 
 static INLINE void
-llvmpipe_set_texture_tile_layout(struct llvmpipe_texture *lpt,
+llvmpipe_set_texture_tile_layout(struct llvmpipe_resource *lpt,
                                  unsigned face, unsigned level,
                                  unsigned x, unsigned y,
                                  enum lp_texture_layout layout)
 {
    uint i;
+   assert(resource_is_texture(&lpt->base));
    assert(x < lpt->tiles_per_row[level]);
    i = y * lpt->tiles_per_row[level] + x;
    lpt->layout[face][level][i] = layout;
@@ -841,7 +936,7 @@ llvmpipe_set_texture_tile_layout(struct llvmpipe_texture *lpt,
  * \return pointer to start of image/face (not the tile)
  */
 ubyte *
-llvmpipe_get_texture_tile_linear(struct llvmpipe_texture *lpt,
+llvmpipe_get_texture_tile_linear(struct llvmpipe_resource *lpt,
                                  unsigned face, unsigned level,
                                  enum lp_texture_usage usage,
                                  unsigned x, unsigned y)
@@ -852,6 +947,7 @@ llvmpipe_get_texture_tile_linear(struct llvmpipe_texture *lpt,
    const unsigned tx = x / TILE_SIZE, ty = y / TILE_SIZE;
    boolean convert;
 
+   assert(resource_is_texture(&lpt->base));
    assert(x % TILE_SIZE == 0);
    assert(y % TILE_SIZE == 0);
 
@@ -891,7 +987,7 @@ llvmpipe_get_texture_tile_linear(struct llvmpipe_texture *lpt,
  * \return pointer to the tiled data at the given tile position
  */
 ubyte *
-llvmpipe_get_texture_tile(struct llvmpipe_texture *lpt,
+llvmpipe_get_texture_tile(struct llvmpipe_resource *lpt,
                           unsigned face, unsigned level,
                           enum lp_texture_usage usage,
                           unsigned x, unsigned y)
@@ -947,12 +1043,13 @@ llvmpipe_get_texture_tile(struct llvmpipe_texture *lpt,
 
 
 void
-llvmpipe_init_screen_texture_funcs(struct pipe_screen *screen)
+llvmpipe_init_screen_resource_funcs(struct pipe_screen *screen)
 {
-   screen->texture_create = llvmpipe_texture_create;
-   screen->texture_destroy = llvmpipe_texture_destroy;
-   screen->texture_from_handle = llvmpipe_texture_from_handle;
-   screen->texture_get_handle = llvmpipe_texture_get_handle;
+   screen->resource_create = llvmpipe_resource_create;
+   screen->resource_destroy = llvmpipe_resource_destroy;
+   screen->resource_from_handle = llvmpipe_resource_from_handle;
+   screen->resource_get_handle = llvmpipe_resource_get_handle;
+   screen->user_buffer_create = llvmpipe_user_buffer_create;
 
    screen->get_tex_surface = llvmpipe_get_tex_surface;
    screen->tex_surface_destroy = llvmpipe_tex_surface_destroy;
@@ -960,10 +1057,14 @@ llvmpipe_init_screen_texture_funcs(struct pipe_screen *screen)
 
 
 void
-llvmpipe_init_context_texture_funcs(struct pipe_context *pipe)
+llvmpipe_init_context_resource_funcs(struct pipe_context *pipe)
 {
-   pipe->get_tex_transfer = llvmpipe_get_tex_transfer;
-   pipe->tex_transfer_destroy = llvmpipe_tex_transfer_destroy;
+   pipe->get_transfer = llvmpipe_get_transfer;
+   pipe->transfer_destroy = llvmpipe_transfer_destroy;
    pipe->transfer_map = llvmpipe_transfer_map;
    pipe->transfer_unmap = llvmpipe_transfer_unmap;
+   pipe->is_resource_referenced = llvmpipe_is_resource_referenced;
+ 
+   pipe->transfer_flush_region = u_default_transfer_flush_region;
+   pipe->transfer_inline_write = u_default_transfer_inline_write;
 }
diff --git a/src/gallium/drivers/llvmpipe/lp_texture.h b/src/gallium/drivers/llvmpipe/lp_texture.h
index bac4ff665df..89202092453 100644
--- a/src/gallium/drivers/llvmpipe/lp_texture.h
+++ b/src/gallium/drivers/llvmpipe/lp_texture.h
@@ -30,6 +30,7 @@
 
 
 #include "pipe/p_state.h"
+#include "util/u_debug.h"
 
 
 #define LP_MAX_TEXTURE_2D_LEVELS 12  /* 2K x 2K for now */
@@ -78,16 +79,24 @@ struct llvmpipe_texture_image
 };
 
 
-struct llvmpipe_texture
+/**
+ * llvmpipe subclass of pipe_resource.  A texture, drawing surface,
+ * vertex buffer, const buffer, etc.
+ * Textures are stored differently than othere types of objects such as
+ * vertex buffers and const buffers.
+ * The former are tiled and have per-tile layout flags.
+ * The later are simple malloc'd blocks of memory.
+ */
+struct llvmpipe_resource
 {
-   struct pipe_texture base;
+   struct pipe_resource base;
 
    /** Row stride in bytes */
    unsigned stride[LP_MAX_TEXTURE_LEVELS];
    unsigned tiles_per_row[LP_MAX_TEXTURE_LEVELS];
 
    /**
-    * Display target, for textures with the PIPE_TEXTURE_USAGE_DISPLAY_TARGET
+    * Display target, for textures with the PIPE_BIND_DISPLAY_TARGET
     * usage.
     */
    struct sw_displaytarget *dt;
@@ -98,9 +107,15 @@ struct llvmpipe_texture
    struct llvmpipe_texture_image tiled[LP_MAX_TEXTURE_LEVELS];
    struct llvmpipe_texture_image linear[LP_MAX_TEXTURE_LEVELS];
 
+   /**
+    * Data for non-texture resources.
+    */
+   void *data;
+
    /** per-tile layout info */
    enum lp_texture_layout *layout[PIPE_TEX_FACE_MAX][LP_MAX_TEXTURE_LEVELS];
 
+   boolean userBuffer;  /** Is this a user-space buffer? */
    unsigned timestamp;
 
    unsigned id;  /**< temporary, for debugging */
@@ -116,17 +131,17 @@ struct llvmpipe_transfer
 
 
 /** cast wrappers */
-static INLINE struct llvmpipe_texture *
-llvmpipe_texture(struct pipe_texture *pt)
+static INLINE struct llvmpipe_resource *
+llvmpipe_resource(struct pipe_resource *pt)
 {
-   return (struct llvmpipe_texture *) pt;
+   return (struct llvmpipe_resource *) pt;
 }
 
 
-static INLINE const struct llvmpipe_texture *
-llvmpipe_texture_const(const struct pipe_texture *pt)
+static INLINE const struct llvmpipe_resource *
+llvmpipe_resource_const(const struct pipe_resource *pt)
 {
-   return (const struct llvmpipe_texture *) pt;
+   return (const struct llvmpipe_resource *) pt;
 }
 
 
@@ -137,53 +152,61 @@ llvmpipe_transfer(struct pipe_transfer *pt)
 }
 
 
+void llvmpipe_init_screen_resource_funcs(struct pipe_screen *screen);
+void llvmpipe_init_context_resource_funcs(struct pipe_context *pipe);
+
 static INLINE unsigned
-llvmpipe_texture_stride(struct pipe_texture *texture,
+llvmpipe_resource_stride(struct pipe_resource *texture,
                         unsigned level)
 {
-   struct llvmpipe_texture *lpt = llvmpipe_texture(texture);
+   struct llvmpipe_resource *lpt = llvmpipe_resource(texture);
    assert(level < LP_MAX_TEXTURE_2D_LEVELS);
    return lpt->stride[level];
 }
 
 
 void *
-llvmpipe_texture_map(struct pipe_texture *texture,
-                     unsigned face,
-                     unsigned level,
-                     unsigned zslice,
-                     enum lp_texture_usage usage,
-                     enum lp_texture_layout layout);
+llvmpipe_resource_map(struct pipe_resource *texture,
+		      unsigned face,
+		      unsigned level,
+		      unsigned zslice,
+                      enum lp_texture_usage tex_usage,
+                      enum lp_texture_layout layout);
 
 void
-llvmpipe_texture_unmap(struct pipe_texture *texture,
+llvmpipe_resource_unmap(struct pipe_resource *texture,
                        unsigned face,
                        unsigned level,
                        unsigned zslice);
 
+
 void *
-llvmpipe_get_texture_image_address(struct llvmpipe_texture *lpt,
-                                   unsigned face, unsigned level,
-                                   enum lp_texture_layout layout);
+llvmpipe_resource_data(struct pipe_resource *resource);
+
 
 void *
-llvmpipe_get_texture_image(struct llvmpipe_texture *texture,
-                           unsigned face, unsigned level,
-                           enum lp_texture_usage usage,
-                           enum lp_texture_layout layout);
+llvmpipe_get_texture_image_address(struct llvmpipe_resource *lpt,
+                                    unsigned face, unsigned level,
+                                    enum lp_texture_layout layout);
+
+void *
+llvmpipe_get_texture_image(struct llvmpipe_resource *resource,
+                            unsigned face, unsigned level,
+                            enum lp_texture_usage usage,
+                            enum lp_texture_layout layout);
 
 
 ubyte *
-llvmpipe_get_texture_tile_linear(struct llvmpipe_texture *lpt,
-                                 unsigned face, unsigned level,
-                                 enum lp_texture_usage usage,
-                                 unsigned x, unsigned y);
+llvmpipe_get_texture_tile_linear(struct llvmpipe_resource *lpt,
+                                  unsigned face, unsigned level,
+                                  enum lp_texture_usage usage,
+                                  unsigned x, unsigned y);
 
 ubyte *
-llvmpipe_get_texture_tile(struct llvmpipe_texture *lpt,
-                          unsigned face, unsigned level,
-                          enum lp_texture_usage usage,
-                          unsigned x, unsigned y);
+llvmpipe_get_texture_tile(struct llvmpipe_resource *lpt,
+                           unsigned face, unsigned level,
+                           enum lp_texture_usage usage,
+                           unsigned x, unsigned y);
 
 
 
diff --git a/src/gallium/drivers/nouveau/Makefile b/src/gallium/drivers/nouveau/Makefile
index 0cb66041d50..db591b756c4 100644
--- a/src/gallium/drivers/nouveau/Makefile
+++ b/src/gallium/drivers/nouveau/Makefile
@@ -3,7 +3,9 @@ include $(TOP)/configs/current
 
 LIBNAME = nouveau
 
-C_SOURCES = nouveau_screen.c \
-	    nouveau_context.c
+LIBRARY_INCLUDES = \
+	-I$(TOP)/src/gallium/drivers/nouveau/include
+
+C_SOURCES = nouveau_screen.c 
 
 include ../../Makefile.template
diff --git a/src/gallium/drivers/nouveau/nouveau_class.h b/src/gallium/drivers/nouveau/nouveau_class.h
new file mode 100644
index 00000000000..adfdd37b1b6
--- /dev/null
+++ b/src/gallium/drivers/nouveau/nouveau_class.h
@@ -0,0 +1,9025 @@
+/*************************************************************************
+
+   Autogenerated file, do not edit !
+
+   This file was generated by renouveau-gen from renouveau.xml, the
+   XML database of nvidia objects and methods. renouveau-gen and
+   renouveau.xml can be found in CVS module renouveau of sourceforge.net
+   project nouveau:
+
+cvs -z3 -d:pserver:anonymous@nouveau.cvs.sourceforge.net:/cvsroot/nouveau co -P renouveau
+
+**************************************************************************
+
+   Copyright (C) 2006-2008 :
+   Dmitry Baryshkov,
+   Laurent Carlier,
+   Matthieu Castet,
+   Dawid Gajownik,
+   Jeremy Kolb,
+   Stephane Loeuillet,
+   Patrice Mandin,
+   Stephane Marchesin,
+   Serge Martin,
+   Sylvain Munaut,
+   Simon Raffeiner,
+   Ben Skeggs,
+   Erik Waling,
+   koala_br,
+
+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, sublicense, 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 NONINFRINGEMENT.
+IN NO EVENT SHALL THE COPYRIGHT OWNER(S) 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 NOUVEAU_REG_H
+#define NOUVEAU_REG_H 1
+
+
+#define NV01_ROOT									0x00000001
+
+
+
+#define NV01_CONTEXT_DMA								0x00000002
+
+
+
+#define NV01_DEVICE									0x00000003
+
+
+
+#define NV01_TIMER									0x00000004
+
+#define  NV01_TIMER_SYNCHRONIZE								0x00000100
+#define  NV01_TIMER_STOP_ALARM								0x00000104
+#define  NV01_TIMER_DMA_NOTIFY								0x00000180
+#define  NV01_TIMER_TIME(x)								(0x00000300+((x)*4))
+#define  NV01_TIMER_TIME__SIZE								0x00000002
+#define  NV01_TIMER_ALARM_NOTIFY							0x00000308
+
+
+#define NV01_CONTEXT_BETA1								0x00000012
+
+#define  NV01_CONTEXT_BETA1_NOP								0x00000100
+#define  NV01_CONTEXT_BETA1_NOTIFY							0x00000104
+#define  NV01_CONTEXT_BETA1_DMA_NOTIFY							0x00000180
+#define  NV01_CONTEXT_BETA1_BETA_1D31							0x00000300
+
+
+#define NV01_CONTEXT_COLOR_KEY								0x00000017
+
+#define  NV01_CONTEXT_COLOR_KEY_NOP							0x00000100
+#define  NV01_CONTEXT_COLOR_KEY_NOTIFY							0x00000104
+#define  NV01_CONTEXT_COLOR_KEY_DMA_NOTIFY						0x00000180
+#define  NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT						0x00000300
+#define   NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X16A8Y8					0x00000001
+#define   NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X24Y8					0x00000002
+#define   NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X16A1R5G5B5				0x00000003
+#define   NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X17R5G5B5					0x00000004
+#define   NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_A8R8G8B8					0x00000005
+#define   NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X8R8G8B8					0x00000006
+#define   NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_A16Y16					0x00000007
+#define   NV01_CONTEXT_COLOR_KEY_COLOR_FORMAT_X16Y16					0x00000008
+#define  NV01_CONTEXT_COLOR_KEY_COLOR							0x00000304
+
+
+#define NV04_CONTEXT_COLOR_KEY								0x00000057
+
+
+
+#define NV01_CONTEXT_PATTERN								0x00000018
+
+#define  NV01_CONTEXT_PATTERN_NOP							0x00000100
+#define  NV01_CONTEXT_PATTERN_NOTIFY							0x00000104
+#define  NV01_CONTEXT_PATTERN_DMA_NOTIFY						0x00000180
+#define  NV01_CONTEXT_PATTERN_COLOR_FORMAT						0x00000300
+#define  NV01_CONTEXT_PATTERN_MONOCHROME_FORMAT						0x00000304
+#define  NV01_CONTEXT_PATTERN_SHAPE							0x00000308
+#define  NV01_CONTEXT_PATTERN_COLOR(x)							(0x00000310+((x)*4))
+#define  NV01_CONTEXT_PATTERN_COLOR__SIZE						0x00000002
+#define  NV01_CONTEXT_PATTERN_PATTERN(x)						(0x00000318+((x)*4))
+#define  NV01_CONTEXT_PATTERN_PATTERN__SIZE						0x00000002
+
+
+#define NV01_CONTEXT_CLIP_RECTANGLE							0x00000019
+
+#define  NV01_CONTEXT_CLIP_RECTANGLE_NOP						0x00000100
+#define  NV01_CONTEXT_CLIP_RECTANGLE_NOTIFY						0x00000104
+#define  NV01_CONTEXT_CLIP_RECTANGLE_DMA_NOTIFY						0x00000180
+#define  NV01_CONTEXT_CLIP_RECTANGLE_POINT						0x00000300
+#define   NV01_CONTEXT_CLIP_RECTANGLE_POINT_X_SHIFT					0
+#define   NV01_CONTEXT_CLIP_RECTANGLE_POINT_X_MASK					0x0000ffff
+#define   NV01_CONTEXT_CLIP_RECTANGLE_POINT_Y_SHIFT					16
+#define   NV01_CONTEXT_CLIP_RECTANGLE_POINT_Y_MASK					0xffff0000
+#define  NV01_CONTEXT_CLIP_RECTANGLE_SIZE						0x00000304
+#define   NV01_CONTEXT_CLIP_RECTANGLE_SIZE_W_SHIFT					0
+#define   NV01_CONTEXT_CLIP_RECTANGLE_SIZE_W_MASK					0x0000ffff
+#define   NV01_CONTEXT_CLIP_RECTANGLE_SIZE_H_SHIFT					16
+#define   NV01_CONTEXT_CLIP_RECTANGLE_SIZE_H_MASK					0xffff0000
+
+
+#define NV01_RENDER_SOLID_LINE								0x0000001c
+
+#define  NV01_RENDER_SOLID_LINE_NOP							0x00000100
+#define  NV01_RENDER_SOLID_LINE_NOTIFY							0x00000104
+#define  NV01_RENDER_SOLID_LINE_PATCH							0x0000010c
+#define  NV01_RENDER_SOLID_LINE_DMA_NOTIFY						0x00000180
+#define  NV01_RENDER_SOLID_LINE_CLIP_RECTANGLE						0x00000184
+#define  NV01_RENDER_SOLID_LINE_PATTERN							0x00000188
+#define  NV01_RENDER_SOLID_LINE_ROP							0x0000018c
+#define  NV01_RENDER_SOLID_LINE_BETA1							0x00000190
+#define  NV01_RENDER_SOLID_LINE_SURFACE							0x00000194
+#define  NV01_RENDER_SOLID_LINE_OPERATION						0x000002fc
+#define   NV01_RENDER_SOLID_LINE_OPERATION_SRCCOPY_AND					0x00000000
+#define   NV01_RENDER_SOLID_LINE_OPERATION_ROP_AND					0x00000001
+#define   NV01_RENDER_SOLID_LINE_OPERATION_BLEND_AND					0x00000002
+#define   NV01_RENDER_SOLID_LINE_OPERATION_SRCCOPY					0x00000003
+#define   NV01_RENDER_SOLID_LINE_OPERATION_SRCCOPY_PREMULT				0x00000004
+#define   NV01_RENDER_SOLID_LINE_OPERATION_BLEND_PREMULT				0x00000005
+#define  NV01_RENDER_SOLID_LINE_COLOR_FORMAT						0x00000300
+#define   NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X16A8Y8					0x00000001
+#define   NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X24Y8					0x00000002
+#define   NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X16A1R5G5B5				0x00000003
+#define   NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X17R5G5B5					0x00000004
+#define   NV01_RENDER_SOLID_LINE_COLOR_FORMAT_A8R8G8B8					0x00000005
+#define   NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X8R8G8B8					0x00000006
+#define   NV01_RENDER_SOLID_LINE_COLOR_FORMAT_A16Y16					0x00000007
+#define   NV01_RENDER_SOLID_LINE_COLOR_FORMAT_X16Y16					0x00000008
+#define  NV01_RENDER_SOLID_LINE_COLOR							0x00000304
+#define  NV01_RENDER_SOLID_LINE_LINE_POINT0(x)						(0x00000400+((x)*8))
+#define  NV01_RENDER_SOLID_LINE_LINE_POINT0__SIZE					0x00000010
+#define   NV01_RENDER_SOLID_LINE_LINE_POINT0_X_SHIFT					0
+#define   NV01_RENDER_SOLID_LINE_LINE_POINT0_X_MASK					0x0000ffff
+#define   NV01_RENDER_SOLID_LINE_LINE_POINT0_Y_SHIFT					16
+#define   NV01_RENDER_SOLID_LINE_LINE_POINT0_Y_MASK					0xffff0000
+#define  NV01_RENDER_SOLID_LINE_LINE_POINT1(x)						(0x00000404+((x)*8))
+#define  NV01_RENDER_SOLID_LINE_LINE_POINT1__SIZE					0x00000010
+#define   NV01_RENDER_SOLID_LINE_LINE_POINT1_X_SHIFT					0
+#define   NV01_RENDER_SOLID_LINE_LINE_POINT1_X_MASK					0x0000ffff
+#define   NV01_RENDER_SOLID_LINE_LINE_POINT1_Y_SHIFT					16
+#define   NV01_RENDER_SOLID_LINE_LINE_POINT1_Y_MASK					0xffff0000
+#define  NV01_RENDER_SOLID_LINE_LINE32_POINT0_X(x)					(0x00000480+((x)*16))
+#define  NV01_RENDER_SOLID_LINE_LINE32_POINT0_X__SIZE					0x00000010
+#define  NV01_RENDER_SOLID_LINE_LINE32_POINT0_Y(x)					(0x00000484+((x)*16))
+#define  NV01_RENDER_SOLID_LINE_LINE32_POINT0_Y__SIZE					0x00000010
+#define  NV01_RENDER_SOLID_LINE_LINE32_POINT1_X(x)					(0x00000488+((x)*16))
+#define  NV01_RENDER_SOLID_LINE_LINE32_POINT1_X__SIZE					0x00000010
+#define  NV01_RENDER_SOLID_LINE_LINE32_POINT1_Y(x)					(0x0000048c+((x)*16))
+#define  NV01_RENDER_SOLID_LINE_LINE32_POINT1_Y__SIZE					0x00000010
+#define  NV01_RENDER_SOLID_LINE_POLYLINE(x)						(0x00000500+((x)*4))
+#define  NV01_RENDER_SOLID_LINE_POLYLINE__SIZE						0x00000020
+#define   NV01_RENDER_SOLID_LINE_POLYLINE_X_SHIFT					0
+#define   NV01_RENDER_SOLID_LINE_POLYLINE_X_MASK					0x0000ffff
+#define   NV01_RENDER_SOLID_LINE_POLYLINE_Y_SHIFT					16
+#define   NV01_RENDER_SOLID_LINE_POLYLINE_Y_MASK					0xffff0000
+#define  NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_X(x)					(0x00000580+((x)*8))
+#define  NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_X__SIZE				0x00000010
+#define  NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_Y(x)					(0x00000584+((x)*8))
+#define  NV01_RENDER_SOLID_LINE_POLYLINE32_POINT_Y__SIZE				0x00000010
+#define  NV01_RENDER_SOLID_LINE_CPOLYLINE_COLOR(x)					(0x00000600+((x)*8))
+#define  NV01_RENDER_SOLID_LINE_CPOLYLINE_COLOR__SIZE					0x00000010
+#define  NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT(x)					(0x00000604+((x)*8))
+#define  NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT__SIZE					0x00000010
+#define   NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_X_SHIFT				0
+#define   NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_X_MASK					0x0000ffff
+#define   NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_Y_SHIFT				16
+#define   NV01_RENDER_SOLID_LINE_CPOLYLINE_POINT_Y_MASK					0xffff0000
+
+
+#define NV04_RENDER_SOLID_LINE								0x0000005c
+
+#define  NV04_RENDER_SOLID_LINE_BETA4							0x00000194
+#define  NV04_RENDER_SOLID_LINE_SURFACE							0x00000198
+
+
+#define NV01_RENDER_SOLID_TRIANGLE							0x0000001d
+
+#define  NV01_RENDER_SOLID_TRIANGLE_NOP							0x00000100
+#define  NV01_RENDER_SOLID_TRIANGLE_NOTIFY						0x00000104
+#define  NV01_RENDER_SOLID_TRIANGLE_PATCH						0x0000010c
+#define  NV01_RENDER_SOLID_TRIANGLE_DMA_NOTIFY						0x00000180
+#define  NV01_RENDER_SOLID_TRIANGLE_CLIP_RECTANGLE					0x00000184
+#define  NV01_RENDER_SOLID_TRIANGLE_PATTERN						0x00000188
+#define  NV01_RENDER_SOLID_TRIANGLE_ROP							0x0000018c
+#define  NV01_RENDER_SOLID_TRIANGLE_BETA1						0x00000190
+#define  NV01_RENDER_SOLID_TRIANGLE_SURFACE						0x00000194
+#define  NV01_RENDER_SOLID_TRIANGLE_OPERATION						0x000002fc
+#define   NV01_RENDER_SOLID_TRIANGLE_OPERATION_SRCCOPY_AND				0x00000000
+#define   NV01_RENDER_SOLID_TRIANGLE_OPERATION_ROP_AND					0x00000001
+#define   NV01_RENDER_SOLID_TRIANGLE_OPERATION_BLEND_AND				0x00000002
+#define   NV01_RENDER_SOLID_TRIANGLE_OPERATION_SRCCOPY					0x00000003
+#define   NV01_RENDER_SOLID_TRIANGLE_OPERATION_SRCCOPY_PREMULT				0x00000004
+#define   NV01_RENDER_SOLID_TRIANGLE_OPERATION_BLEND_PREMULT				0x00000005
+#define  NV01_RENDER_SOLID_TRIANGLE_COLOR_FORMAT					0x00000300
+#define  NV01_RENDER_SOLID_TRIANGLE_COLOR						0x00000304
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0					0x00000310
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_X_SHIFT				0
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_X_MASK				0x0000ffff
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_Y_SHIFT				16
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT0_Y_MASK				0xffff0000
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1					0x00000314
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_X_SHIFT				0
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_X_MASK				0x0000ffff
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_Y_SHIFT				16
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT1_Y_MASK				0xffff0000
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2					0x00000318
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_X_SHIFT				0
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_X_MASK				0x0000ffff
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_Y_SHIFT				16
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIANGLE_POINT2_Y_MASK				0xffff0000
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT0_X					0x00000320
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT0_Y					0x00000324
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT1_X					0x00000328
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT1_Y					0x0000032c
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT2_X					0x00000330
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIANGLE32_POINT2_Y					0x00000334
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIMESH(x)						(0x00000400+((x)*4))
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIMESH__SIZE					0x00000020
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIMESH_X_SHIFT					0
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIMESH_X_MASK					0x0000ffff
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIMESH_Y_SHIFT					16
+#define   NV01_RENDER_SOLID_TRIANGLE_TRIMESH_Y_MASK					0xffff0000
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_X(x)				(0x00000480+((x)*8))
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_X__SIZE				0x00000010
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_Y(x)				(0x00000484+((x)*8))
+#define  NV01_RENDER_SOLID_TRIANGLE_TRIMESH32_POINT_Y__SIZE				0x00000010
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_COLOR(x)					(0x00000500+((x)*16))
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_COLOR__SIZE				0x00000008
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0(x)					(0x00000504+((x)*16))
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0__SIZE				0x00000008
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_X_SHIFT				0
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_X_MASK				0x0000ffff
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_Y_SHIFT				16
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT0_Y_MASK				0xffff0000
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1(x)					(0x00000508+((x)*16))
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1__SIZE				0x00000008
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_X_SHIFT				0
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_X_MASK				0x0000ffff
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_Y_SHIFT				16
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT1_Y_MASK				0xffff0000
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2(x)					(0x0000050c+((x)*16))
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2__SIZE				0x00000008
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_X_SHIFT				0
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_X_MASK				0x0000ffff
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_Y_SHIFT				16
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIANGLE_POINT2_Y_MASK				0xffff0000
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_COLOR(x)					(0x00000580+((x)*8))
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_COLOR__SIZE				0x00000010
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT(x)					(0x00000584+((x)*8))
+#define  NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT__SIZE				0x00000010
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_X_SHIFT				0
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_X_MASK				0x0000ffff
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_Y_SHIFT				16
+#define   NV01_RENDER_SOLID_TRIANGLE_CTRIMESH_POINT_Y_MASK				0xffff0000
+
+
+#define NV04_RENDER_SOLID_TRIANGLE							0x0000005d
+
+#define  NV04_RENDER_SOLID_TRIANGLE_BETA4						0x00000194
+#define  NV04_RENDER_SOLID_TRIANGLE_SURFACE						0x00000198
+
+
+#define NV01_RENDER_SOLID_RECTANGLE							0x0000001e
+
+#define  NV01_RENDER_SOLID_RECTANGLE_NOP						0x00000100
+#define  NV01_RENDER_SOLID_RECTANGLE_NOTIFY						0x00000104
+#define  NV01_RENDER_SOLID_RECTANGLE_PATCH						0x0000010c
+#define  NV01_RENDER_SOLID_RECTANGLE_DMA_NOTIFY						0x00000180
+#define  NV01_RENDER_SOLID_RECTANGLE_CLIP_RECTANGLE					0x00000184
+#define  NV01_RENDER_SOLID_RECTANGLE_PATTERN						0x00000188
+#define  NV01_RENDER_SOLID_RECTANGLE_ROP						0x0000018c
+#define  NV01_RENDER_SOLID_RECTANGLE_BETA1						0x00000190
+#define  NV01_RENDER_SOLID_RECTANGLE_SURFACE						0x00000194
+#define  NV01_RENDER_SOLID_RECTANGLE_OPERATION						0x000002fc
+#define   NV01_RENDER_SOLID_RECTANGLE_OPERATION_SRCCOPY_AND				0x00000000
+#define   NV01_RENDER_SOLID_RECTANGLE_OPERATION_ROP_AND					0x00000001
+#define   NV01_RENDER_SOLID_RECTANGLE_OPERATION_BLEND_AND				0x00000002
+#define   NV01_RENDER_SOLID_RECTANGLE_OPERATION_SRCCOPY					0x00000003
+#define   NV01_RENDER_SOLID_RECTANGLE_OPERATION_SRCCOPY_PREMULT				0x00000004
+#define   NV01_RENDER_SOLID_RECTANGLE_OPERATION_BLEND_PREMULT				0x00000005
+#define  NV01_RENDER_SOLID_RECTANGLE_COLOR_FORMAT					0x00000300
+#define  NV01_RENDER_SOLID_RECTANGLE_COLOR						0x00000304
+#define  NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT(x)					(0x00000400+((x)*8))
+#define  NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT__SIZE				0x00000010
+#define   NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_X_SHIFT				0
+#define   NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_X_MASK				0x0000ffff
+#define   NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_Y_SHIFT				16
+#define   NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_POINT_Y_MASK				0xffff0000
+#define  NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE(x)					(0x00000404+((x)*8))
+#define  NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE__SIZE				0x00000010
+#define   NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_W_SHIFT				0
+#define   NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_W_MASK				0x0000ffff
+#define   NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_H_SHIFT				16
+#define   NV01_RENDER_SOLID_RECTANGLE_RECTANGLE_SIZE_H_MASK				0xffff0000
+
+
+#define NV04_RENDER_SOLID_RECTANGLE							0x0000005e
+
+#define  NV04_RENDER_SOLID_RECTANGLE_BETA4						0x00000194
+#define  NV04_RENDER_SOLID_RECTANGLE_SURFACE						0x00000198
+
+
+#define NV01_IMAGE_BLIT									0x0000001f
+
+#define  NV01_IMAGE_BLIT_NOP								0x00000100
+#define  NV01_IMAGE_BLIT_NOTIFY								0x00000104
+#define  NV01_IMAGE_BLIT_PATCH								0x0000010c
+#define  NV01_IMAGE_BLIT_DMA_NOTIFY							0x00000180
+#define  NV01_IMAGE_BLIT_COLOR_KEY							0x00000184
+#define  NV01_IMAGE_BLIT_CLIP_RECTANGLE							0x00000188
+#define  NV01_IMAGE_BLIT_PATTERN							0x0000018c
+#define  NV01_IMAGE_BLIT_ROP								0x00000190
+#define  NV01_IMAGE_BLIT_BETA1								0x00000194
+#define  NV01_IMAGE_BLIT_SURFACE							0x0000019c
+#define  NV01_IMAGE_BLIT_OPERATION							0x000002fc
+#define   NV01_IMAGE_BLIT_OPERATION_SRCCOPY_AND						0x00000000
+#define   NV01_IMAGE_BLIT_OPERATION_ROP_AND						0x00000001
+#define   NV01_IMAGE_BLIT_OPERATION_BLEND_AND						0x00000002
+#define   NV01_IMAGE_BLIT_OPERATION_SRCCOPY						0x00000003
+#define   NV01_IMAGE_BLIT_OPERATION_SRCCOPY_PREMULT					0x00000004
+#define   NV01_IMAGE_BLIT_OPERATION_BLEND_PREMULT					0x00000005
+#define  NV01_IMAGE_BLIT_IMAGE_INPUT							0x00000204
+#define  NV01_IMAGE_BLIT_POINT_IN							0x00000300
+#define   NV01_IMAGE_BLIT_POINT_IN_X_SHIFT						0
+#define   NV01_IMAGE_BLIT_POINT_IN_X_MASK						0x0000ffff
+#define   NV01_IMAGE_BLIT_POINT_IN_Y_SHIFT						16
+#define   NV01_IMAGE_BLIT_POINT_IN_Y_MASK						0xffff0000
+#define  NV01_IMAGE_BLIT_POINT_OUT							0x00000304
+#define   NV01_IMAGE_BLIT_POINT_OUT_X_SHIFT						0
+#define   NV01_IMAGE_BLIT_POINT_OUT_X_MASK						0x0000ffff
+#define   NV01_IMAGE_BLIT_POINT_OUT_Y_SHIFT						16
+#define   NV01_IMAGE_BLIT_POINT_OUT_Y_MASK						0xffff0000
+#define  NV01_IMAGE_BLIT_SIZE								0x00000308
+#define   NV01_IMAGE_BLIT_SIZE_W_SHIFT							0
+#define   NV01_IMAGE_BLIT_SIZE_W_MASK							0x0000ffff
+#define   NV01_IMAGE_BLIT_SIZE_H_SHIFT							16
+#define   NV01_IMAGE_BLIT_SIZE_H_MASK							0xffff0000
+
+
+#define NV04_IMAGE_BLIT									0x0000005f
+
+#define  NV04_IMAGE_BLIT_ROP								0x00000190
+#define  NV04_IMAGE_BLIT_BETA4								0x00000198
+#define  NV04_IMAGE_BLIT_SURFACE							0x0000019c
+
+
+#define NV12_IMAGE_BLIT									0x0000009f
+
+#define  NV12_IMAGE_BLIT_WAIT_FOR_IDLE							0x00000108
+
+
+#define NV01_IMAGE_FROM_CPU								0x00000021
+
+#define  NV01_IMAGE_FROM_CPU_NOP							0x00000100
+#define  NV01_IMAGE_FROM_CPU_NOTIFY							0x00000104
+#define  NV01_IMAGE_FROM_CPU_PATCH							0x0000010c
+#define  NV01_IMAGE_FROM_CPU_DMA_NOTIFY							0x00000180
+#define  NV01_IMAGE_FROM_CPU_COLOR_KEY							0x00000184
+#define  NV01_IMAGE_FROM_CPU_CLIP_RECTANGLE						0x00000188
+#define  NV01_IMAGE_FROM_CPU_PATTERN							0x0000018c
+#define  NV01_IMAGE_FROM_CPU_ROP							0x00000190
+#define  NV01_IMAGE_FROM_CPU_BETA1							0x00000194
+#define  NV01_IMAGE_FROM_CPU_SURFACE							0x00000198
+#define  NV01_IMAGE_FROM_CPU_OPERATION							0x000002fc
+#define   NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY_AND					0x00000000
+#define   NV01_IMAGE_FROM_CPU_OPERATION_ROP_AND						0x00000001
+#define   NV01_IMAGE_FROM_CPU_OPERATION_BLEND_AND					0x00000002
+#define   NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY						0x00000003
+#define   NV01_IMAGE_FROM_CPU_OPERATION_SRCCOPY_PREMULT					0x00000004
+#define   NV01_IMAGE_FROM_CPU_OPERATION_BLEND_PREMULT					0x00000005
+#define  NV01_IMAGE_FROM_CPU_COLOR_FORMAT						0x00000300
+#define   NV01_IMAGE_FROM_CPU_COLOR_FORMAT_Y8						0x00000001
+#define   NV01_IMAGE_FROM_CPU_COLOR_FORMAT_A1R5G5B5					0x00000002
+#define   NV01_IMAGE_FROM_CPU_COLOR_FORMAT_X1R5G5B5					0x00000003
+#define   NV01_IMAGE_FROM_CPU_COLOR_FORMAT_A8R8G8B8					0x00000004
+#define   NV01_IMAGE_FROM_CPU_COLOR_FORMAT_X8R8G8B8					0x00000005
+#define  NV01_IMAGE_FROM_CPU_POINT							0x00000304
+#define   NV01_IMAGE_FROM_CPU_POINT_X_SHIFT						0
+#define   NV01_IMAGE_FROM_CPU_POINT_X_MASK						0x0000ffff
+#define   NV01_IMAGE_FROM_CPU_POINT_Y_SHIFT						16
+#define   NV01_IMAGE_FROM_CPU_POINT_Y_MASK						0xffff0000
+#define  NV01_IMAGE_FROM_CPU_SIZE_OUT							0x00000308
+#define   NV01_IMAGE_FROM_CPU_SIZE_OUT_W_SHIFT						0
+#define   NV01_IMAGE_FROM_CPU_SIZE_OUT_W_MASK						0x0000ffff
+#define   NV01_IMAGE_FROM_CPU_SIZE_OUT_H_SHIFT						16
+#define   NV01_IMAGE_FROM_CPU_SIZE_OUT_H_MASK						0xffff0000
+#define  NV01_IMAGE_FROM_CPU_SIZE_IN							0x0000030c
+#define   NV01_IMAGE_FROM_CPU_SIZE_IN_W_SHIFT						0
+#define   NV01_IMAGE_FROM_CPU_SIZE_IN_W_MASK						0x0000ffff
+#define   NV01_IMAGE_FROM_CPU_SIZE_IN_H_SHIFT						16
+#define   NV01_IMAGE_FROM_CPU_SIZE_IN_H_MASK						0xffff0000
+#define  NV01_IMAGE_FROM_CPU_COLOR(x)							(0x00000400+((x)*4))
+#define  NV01_IMAGE_FROM_CPU_COLOR__SIZE						0x00000020
+
+
+#define NV04_IMAGE_FROM_CPU								0x00000061
+
+#define  NV04_IMAGE_FROM_CPU_BETA4							0x00000198
+#define  NV04_IMAGE_FROM_CPU_SURFACE							0x0000019c
+
+
+#define NV05_IMAGE_FROM_CPU								0x00000065
+
+#define  NV05_IMAGE_FROM_CPU_COLOR_CONVERSION						0x000002f8
+
+
+#define NV10_IMAGE_FROM_CPU								0x0000008a
+
+#define  NV10_IMAGE_FROM_CPU_WAIT_FOR_IDLE						0x00000108
+
+
+#define NV30_IMAGE_FROM_CPU								0x0000038a
+
+
+
+#define NV40_IMAGE_FROM_CPU								0x0000308a
+
+
+
+#define NV01_NULL									0x00000030
+
+
+
+#define NV03_STRETCHED_IMAGE_FROM_CPU							0x00000036
+
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_NOP						0x00000100
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_NOTIFY						0x00000104
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_PATCH						0x0000010c
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_DMA_NOTIFY					0x00000180
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_COLOR_KEY					0x00000184
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_PATTERN						0x00000188
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_ROP						0x0000018c
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_BETA1						0x00000190
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_SURFACE						0x00000194
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_OPERATION					0x000002fc
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_COLOR_FORMAT					0x00000300
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN						0x00000304
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_W_SHIFT					0
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_W_MASK					0x0000ffff
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_H_SHIFT					16
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_SIZE_IN_H_MASK					0xffff0000
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_DX_DU						0x00000308
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_DY_DV						0x0000030c
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT					0x00000310
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_X_SHIFT				0
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_X_MASK				0x0000ffff
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_Y_SHIFT				16
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_POINT_Y_MASK				0xffff0000
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE					0x00000314
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_W_SHIFT				0
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_W_MASK				0x0000ffff
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_H_SHIFT				16
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_CLIP_SIZE_H_MASK				0xffff0000
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4					0x00000318
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_X_SHIFT				0
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_X_MASK				0x0000ffff
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_Y_SHIFT				16
+#define   NV03_STRETCHED_IMAGE_FROM_CPU_POINT12D4_Y_MASK				0xffff0000
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_COLOR(x)						(0x00000400+((x)*4))
+#define  NV03_STRETCHED_IMAGE_FROM_CPU_COLOR__SIZE					0x00000020
+
+
+#define NV04_STRETCHED_IMAGE_FROM_CPU							0x00000076
+
+#define  NV04_STRETCHED_IMAGE_FROM_CPU_BETA4						0x00000194
+#define  NV04_STRETCHED_IMAGE_FROM_CPU_SURFACE						0x00000198
+
+
+#define NV05_STRETCHED_IMAGE_FROM_CPU							0x00000066
+
+#define  NV05_STRETCHED_IMAGE_FROM_CPU_COLOR_CONVERSION					0x000002f8
+
+
+#define NV30_STRETCHED_IMAGE_FROM_CPU							0x00000366
+
+
+
+#define NV40_STRETCHED_IMAGE_FROM_CPU							0x00003066
+
+
+
+#define NV03_SCALED_IMAGE_FROM_MEMORY							0x00000037
+
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_NOP						0x00000100
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_NOTIFY						0x00000104
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_DMA_NOTIFY					0x00000180
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_DMA_IMAGE					0x00000184
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_PATTERN						0x00000188
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_ROP						0x0000018c
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_BETA1						0x00000190
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_SURFACE						0x00000194
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT					0x00000300
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_A1R5G5B5				0x00000001
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_X1R5G5B5				0x00000002
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_A8R8G8B8				0x00000003
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_X8R8G8B8				0x00000004
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_V8YB8U8YA8				0x00000005
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_YB8V8YA8U8				0x00000006
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_R5G6B5				0x00000007
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_Y8					0x00000008
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT_AY8				0x00000009
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION					0x00000304
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY_AND				0x00000000
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_ROP_AND				0x00000001
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_BLEND_AND				0x00000002
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY				0x00000003
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY_PREMULT			0x00000004
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_BLEND_PREMULT				0x00000005
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT					0x00000308
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_X_SHIFT				0
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_X_MASK				0x0000ffff
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_Y_SHIFT				16
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_POINT_Y_MASK				0xffff0000
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE					0x0000030c
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_W_SHIFT				0
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_W_MASK				0x0000ffff
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_H_SHIFT				16
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_CLIP_SIZE_H_MASK				0xffff0000
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT					0x00000310
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_X_SHIFT				0
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_X_MASK				0x0000ffff
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_Y_SHIFT				16
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OUT_POINT_Y_MASK				0xffff0000
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE						0x00000314
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_W_SHIFT				0
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_W_MASK					0x0000ffff
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_H_SHIFT				16
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_OUT_SIZE_H_MASK					0xffff0000
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_DU_DX						0x00000318
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_DV_DY						0x0000031c
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_SIZE						0x00000400
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_W_SHIFT					0
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_W_MASK					0x0000ffff
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_H_SHIFT					16
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_SIZE_H_MASK					0xffff0000
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT						0x00000404
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_PITCH_SHIFT				0
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_PITCH_MASK				0x0000ffff
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_SHIFT				16
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_MASK				0x00ff0000
+#define    NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CENTER				0x00010000
+#define    NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CORNER				0x00020000
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_SHIFT				24
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_MASK				0xff000000
+#define    NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_POINT_SAMPLE			0x00000000
+#define    NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_BILINEAR				0x01000000
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_OFFSET						0x00000408
+#define  NV03_SCALED_IMAGE_FROM_MEMORY_POINT						0x0000040c
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_POINT_U_SHIFT					0
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_POINT_U_MASK					0x0000ffff
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_POINT_V_SHIFT					16
+#define   NV03_SCALED_IMAGE_FROM_MEMORY_POINT_V_MASK					0xffff0000
+
+
+#define NV04_SCALED_IMAGE_FROM_MEMORY							0x00000077
+
+#define  NV04_SCALED_IMAGE_FROM_MEMORY_BETA4						0x00000194
+#define  NV04_SCALED_IMAGE_FROM_MEMORY_SURFACE						0x00000198
+
+
+#define NV05_SCALED_IMAGE_FROM_MEMORY							0x00000063
+
+#define  NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION					0x000002fc
+#define   NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_DITHER				0x00000000
+#define   NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_TRUNCATE			0x00000001
+#define   NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_SUBTR_TRUNCATE			0x00000002
+
+
+#define NV10_SCALED_IMAGE_FROM_MEMORY							0x00000089
+
+#define  NV10_SCALED_IMAGE_FROM_MEMORY_WAIT_FOR_IDLE					0x00000108
+
+
+#define NV30_SCALED_IMAGE_FROM_MEMORY							0x00000389
+
+
+
+#define NV40_SCALED_IMAGE_FROM_MEMORY							0x00003089
+
+
+
+#define NV04_DVD_SUBPICTURE								0x00000038
+
+#define  NV04_DVD_SUBPICTURE_NOP							0x00000100
+#define  NV04_DVD_SUBPICTURE_NOTIFY							0x00000104
+#define  NV04_DVD_SUBPICTURE_DMA_NOTIFY							0x00000180
+#define  NV04_DVD_SUBPICTURE_DMA_OVERLAY						0x00000184
+#define  NV04_DVD_SUBPICTURE_DMA_IMAGEIN						0x00000188
+#define  NV04_DVD_SUBPICTURE_DMA_IMAGEOUT						0x0000018c
+#define  NV04_DVD_SUBPICTURE_IMAGEOUT_POINT						0x00000300
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_POINT_X_SHIFT					0
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_POINT_X_MASK					0x0000ffff
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_POINT_Y_SHIFT					16
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_POINT_Y_MASK					0xffff0000
+#define  NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE						0x00000304
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE_W_SHIFT					0
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE_W_MASK					0x0000ffff
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE_H_SHIFT					16
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_SIZE_H_MASK					0xffff0000
+#define  NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT						0x00000308
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT_PITCH_SHIFT				0
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT_PITCH_MASK				0x0000ffff
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT_COLOR_SHIFT				16
+#define   NV04_DVD_SUBPICTURE_IMAGEOUT_FORMAT_COLOR_MASK				0xffff0000
+#define  NV04_DVD_SUBPICTURE_IMAGEOUT_OFFSET						0x0000030c
+#define  NV04_DVD_SUBPICTURE_IMAGEIN_DELTA_DU_DX					0x00000310
+#define  NV04_DVD_SUBPICTURE_IMAGEIN_DELTA_DV_DY					0x00000314
+#define  NV04_DVD_SUBPICTURE_IMAGEIN_SIZE						0x00000318
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_SIZE_W_SHIFT					0
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_SIZE_W_MASK					0x0000ffff
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_SIZE_H_SHIFT					16
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_SIZE_H_MASK					0xffff0000
+#define  NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT						0x0000031c
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT_PITCH_SHIFT				0
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT_PITCH_MASK					0x0000ffff
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT_COLOR_SHIFT				16
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_FORMAT_COLOR_MASK					0xffff0000
+#define  NV04_DVD_SUBPICTURE_IMAGEIN_OFFSET						0x00000320
+#define  NV04_DVD_SUBPICTURE_IMAGEIN_POINT						0x00000324
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_POINT_U_SHIFT					0
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_POINT_U_MASK					0x0000ffff
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_POINT_V_SHIFT					16
+#define   NV04_DVD_SUBPICTURE_IMAGEIN_POINT_V_MASK					0xffff0000
+#define  NV04_DVD_SUBPICTURE_OVERLAY_DELTA_DU_DX					0x00000328
+#define  NV04_DVD_SUBPICTURE_OVERLAY_DELTA_DV_DY					0x0000032c
+#define  NV04_DVD_SUBPICTURE_OVERLAY_SIZE						0x00000330
+#define   NV04_DVD_SUBPICTURE_OVERLAY_SIZE_W_SHIFT					0
+#define   NV04_DVD_SUBPICTURE_OVERLAY_SIZE_W_MASK					0x0000ffff
+#define   NV04_DVD_SUBPICTURE_OVERLAY_SIZE_H_SHIFT					16
+#define   NV04_DVD_SUBPICTURE_OVERLAY_SIZE_H_MASK					0xffff0000
+#define  NV04_DVD_SUBPICTURE_OVERLAY_FORMAT						0x00000334
+#define   NV04_DVD_SUBPICTURE_OVERLAY_FORMAT_PITCH_SHIFT				0
+#define   NV04_DVD_SUBPICTURE_OVERLAY_FORMAT_PITCH_MASK					0x0000ffff
+#define   NV04_DVD_SUBPICTURE_OVERLAY_FORMAT_COLOR_SHIFT				16
+#define   NV04_DVD_SUBPICTURE_OVERLAY_FORMAT_COLOR_MASK					0xffff0000
+#define  NV04_DVD_SUBPICTURE_OVERLAY_OFFSET						0x00000338
+#define  NV04_DVD_SUBPICTURE_OVERLAY_POINT						0x0000033c
+#define   NV04_DVD_SUBPICTURE_OVERLAY_POINT_U_SHIFT					0
+#define   NV04_DVD_SUBPICTURE_OVERLAY_POINT_U_MASK					0x0000ffff
+#define   NV04_DVD_SUBPICTURE_OVERLAY_POINT_V_SHIFT					16
+#define   NV04_DVD_SUBPICTURE_OVERLAY_POINT_V_MASK					0xffff0000
+
+
+#define NV10_DVD_SUBPICTURE								0x00000088
+
+#define  NV10_DVD_SUBPICTURE_WAIT_FOR_IDLE						0x00000108
+
+
+#define NV04_MEMORY_TO_MEMORY_FORMAT							0x00000039
+
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_NOP						0x00000100
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_NOTIFY						0x00000104
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_DMA_NOTIFY					0x00000180
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_DMA_BUFFER_IN					0x00000184
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_DMA_BUFFER_OUT					0x00000188
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN						0x0000030c
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_OFFSET_OUT					0x00000310
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_PITCH_IN						0x00000314
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_PITCH_OUT						0x00000318
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_LINE_LENGTH_IN					0x0000031c
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_LINE_COUNT					0x00000320
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT						0x00000324
+#define   NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT_INPUT_INC_SHIFT				0
+#define   NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT_INPUT_INC_MASK				0x000000ff
+#define   NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT_OUTPUT_INC_SHIFT				8
+#define   NV04_MEMORY_TO_MEMORY_FORMAT_FORMAT_OUTPUT_INC_MASK				0x0000ff00
+#define  NV04_MEMORY_TO_MEMORY_FORMAT_BUF_NOTIFY					0x00000328
+
+
+#define NV50_MEMORY_TO_MEMORY_FORMAT							0x00005039
+
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_SERIALIZE						0x00000110
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_LINEAR_IN						0x00000200
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_MODE_IN					0x00000204
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_PITCH_IN					0x00000208
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_HEIGHT_IN					0x0000020c
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_DEPTH_IN					0x00000210
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_Z				0x00000214
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN				0x00000218
+#define   NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_X_SHIFT			0
+#define   NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_X_MASK			0x0000ffff
+#define   NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_Y_SHIFT			16
+#define   NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_IN_Y_MASK			0xffff0000
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_LINEAR_OUT					0x0000021c
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_MODE_OUT					0x00000220
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_PITCH_OUT					0x00000224
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_HEIGHT_OUT					0x00000228
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_DEPTH_OUT					0x0000022c
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_Z				0x00000230
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT				0x00000234
+#define   NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_X_SHIFT			0
+#define   NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_X_MASK			0x0000ffff
+#define   NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_Y_SHIFT			16
+#define   NV50_MEMORY_TO_MEMORY_FORMAT_TILING_POSITION_OUT_Y_MASK			0xffff0000
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN_HIGH					0x00000238
+#define  NV50_MEMORY_TO_MEMORY_FORMAT_OFFSET_OUT_HIGH					0x0000023c
+
+
+#define NV01_MEMORY_LOCAL_BANKED							0x0000003d
+
+
+
+#define NV01_MAPPING_SYSTEM								0x0000003e
+
+
+
+#define NV03_MEMORY_LOCAL_CURSOR							0x0000003f
+
+
+
+#define NV01_MEMORY_LOCAL_LINEAR							0x00000040
+
+
+
+#define NV01_MAPPING_LOCAL								0x00000041
+
+
+
+#define NV04_CONTEXT_SURFACES_2D							0x00000042
+
+#define  NV04_CONTEXT_SURFACES_2D_NOP							0x00000100
+#define  NV04_CONTEXT_SURFACES_2D_NOTIFY						0x00000104
+#define  NV04_CONTEXT_SURFACES_2D_PM_TRIGGER						0x00000140
+#define  NV04_CONTEXT_SURFACES_2D_DMA_NOTIFY						0x00000180
+#define  NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_SOURCE					0x00000184
+#define  NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_DESTIN					0x00000188
+#define  NV04_CONTEXT_SURFACES_2D_FORMAT						0x00000300
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_Y8						0x00000001
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_X1R5G5B5_Z1R5G5B5				0x00000002
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_X1R5G5B5_X1R5G5B5				0x00000003
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_R5G6B5					0x00000004
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_Y16						0x00000005
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_Z8R8G8B8				0x00000006
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_X8R8G8B8_X8R8G8B8				0x00000007
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_X1A7R8G8B8_Z1A7R8G8B8				0x00000008
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_X1A7R8G8B8_X1A7R8G8B8				0x00000009
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_A8R8G8B8					0x0000000a
+#define   NV04_CONTEXT_SURFACES_2D_FORMAT_Y32						0x0000000b
+#define  NV04_CONTEXT_SURFACES_2D_PITCH							0x00000304
+#define   NV04_CONTEXT_SURFACES_2D_PITCH_SOURCE_SHIFT					0
+#define   NV04_CONTEXT_SURFACES_2D_PITCH_SOURCE_MASK					0x0000ffff
+#define   NV04_CONTEXT_SURFACES_2D_PITCH_DESTIN_SHIFT					16
+#define   NV04_CONTEXT_SURFACES_2D_PITCH_DESTIN_MASK					0xffff0000
+#define  NV04_CONTEXT_SURFACES_2D_OFFSET_SOURCE						0x00000308
+#define  NV04_CONTEXT_SURFACES_2D_OFFSET_DESTIN						0x0000030c
+
+
+#define NV10_CONTEXT_SURFACES_2D							0x00000062
+
+
+
+#define NV30_CONTEXT_SURFACES_2D							0x00000362
+
+
+
+#define NV40_CONTEXT_SURFACES_2D							0x00003062
+
+
+
+#define NV03_CONTEXT_ROP								0x00000043
+
+#define  NV03_CONTEXT_ROP_NOP								0x00000100
+#define  NV03_CONTEXT_ROP_NOTIFY							0x00000104
+#define  NV03_CONTEXT_ROP_DMA_NOTIFY							0x00000180
+#define  NV03_CONTEXT_ROP_ROP								0x00000300
+#define   NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_SHIFT					0
+#define   NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_MASK					0x0000000f
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_CLEAR					0x00000000
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_NOR					0x00000001
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_AND_INVERTED				0x00000002
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_COPY_INVERTED				0x00000003
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_AND_REVERSE				0x00000004
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_INVERT					0x00000005
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_XOR					0x00000006
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_NAND					0x00000007
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_AND					0x00000008
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_EQUI					0x00000009
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_NOOP					0x0000000a
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_OR_INVERTED				0x0000000b
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_COPY					0x0000000c
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_OR_REVERSE					0x0000000d
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_OR						0x0000000e
+#define    NV03_CONTEXT_ROP_ROP_DST_LOGIC_OP_SET					0x0000000f
+#define   NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_SHIFT					4
+#define   NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_MASK					0x000000f0
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_CLEAR					0x00000000
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_NOR					0x00000010
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_AND_INVERTED				0x00000020
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_COPY_INVERTED				0x00000030
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_AND_REVERSE				0x00000040
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_INVERT					0x00000050
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_XOR					0x00000060
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_NAND					0x00000070
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_AND					0x00000080
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_EQUI					0x00000090
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_NOOP					0x000000a0
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_OR_INVERTED				0x000000b0
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_COPY					0x000000c0
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_OR_REVERSE					0x000000d0
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_OR						0x000000e0
+#define    NV03_CONTEXT_ROP_ROP_SRC_LOGIC_OP_SET					0x000000f0
+
+
+#define NV04_IMAGE_PATTERN								0x00000044
+
+#define  NV04_IMAGE_PATTERN_NOP								0x00000100
+#define  NV04_IMAGE_PATTERN_NOTIFY							0x00000104
+#define  NV04_IMAGE_PATTERN_DMA_NOTIFY							0x00000180
+#define  NV04_IMAGE_PATTERN_COLOR_FORMAT						0x00000300
+#define   NV04_IMAGE_PATTERN_COLOR_FORMAT_A16R5G6B5					0x00000001
+#define   NV04_IMAGE_PATTERN_COLOR_FORMAT_X16A1R5G5B5					0x00000002
+#define   NV04_IMAGE_PATTERN_COLOR_FORMAT_A8R8G8B8					0x00000003
+#define  NV04_IMAGE_PATTERN_MONOCHROME_FORMAT						0x00000304
+#define   NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_CGA6					0x00000001
+#define   NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_LE					0x00000002
+#define  NV04_IMAGE_PATTERN_MONOCHROME_SHAPE						0x00000308
+#define   NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8					0x00000000
+#define   NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_64X1					0x00000001
+#define   NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_1X64					0x00000002
+#define  NV04_IMAGE_PATTERN_PATTERN_SELECT						0x0000030c
+#define   NV04_IMAGE_PATTERN_PATTERN_SELECT_MONO					0x00000001
+#define   NV04_IMAGE_PATTERN_PATTERN_SELECT_COLOR					0x00000002
+#define  NV04_IMAGE_PATTERN_MONOCHROME_COLOR0						0x00000310
+#define  NV04_IMAGE_PATTERN_MONOCHROME_COLOR1						0x00000314
+#define  NV04_IMAGE_PATTERN_MONOCHROME_PATTERN0						0x00000318
+#define  NV04_IMAGE_PATTERN_MONOCHROME_PATTERN1						0x0000031c
+#define  NV04_IMAGE_PATTERN_PATTERN_Y8(x)						(0x00000400+((x)*4))
+#define  NV04_IMAGE_PATTERN_PATTERN_Y8__SIZE						0x00000010
+#define   NV04_IMAGE_PATTERN_PATTERN_Y8_Y0_SHIFT					0
+#define   NV04_IMAGE_PATTERN_PATTERN_Y8_Y0_MASK						0x000000ff
+#define   NV04_IMAGE_PATTERN_PATTERN_Y8_Y1_SHIFT					8
+#define   NV04_IMAGE_PATTERN_PATTERN_Y8_Y1_MASK						0x0000ff00
+#define   NV04_IMAGE_PATTERN_PATTERN_Y8_Y2_SHIFT					16
+#define   NV04_IMAGE_PATTERN_PATTERN_Y8_Y2_MASK						0x00ff0000
+#define   NV04_IMAGE_PATTERN_PATTERN_Y8_Y3_SHIFT					24
+#define   NV04_IMAGE_PATTERN_PATTERN_Y8_Y3_MASK						0xff000000
+#define  NV04_IMAGE_PATTERN_PATTERN_R5G6B5(x)						(0x00000500+((x)*4))
+#define  NV04_IMAGE_PATTERN_PATTERN_R5G6B5__SIZE					0x00000020
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B0_SHIFT					0
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B0_MASK					0x0000001f
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G0_SHIFT					5
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G0_MASK					0x000007e0
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R0_SHIFT					11
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R0_MASK					0x0000f800
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B1_SHIFT					16
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_B1_MASK					0x001f0000
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G1_SHIFT					21
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_G1_MASK					0x07e00000
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R1_SHIFT					27
+#define   NV04_IMAGE_PATTERN_PATTERN_R5G6B5_R1_MASK					0xf8000000
+#define  NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5(x)						(0x00000600+((x)*4))
+#define  NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5__SIZE					0x00000020
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B0_SHIFT					0
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B0_MASK					0x0000001f
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G0_SHIFT					5
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G0_MASK					0x000003e0
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R0_SHIFT					10
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R0_MASK					0x00007c00
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B1_SHIFT					16
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_B1_MASK					0x001f0000
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G1_SHIFT					21
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_G1_MASK					0x03e00000
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R1_SHIFT					26
+#define   NV04_IMAGE_PATTERN_PATTERN_X1R5G5B5_R1_MASK					0x7c000000
+#define  NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8(x)						(0x00000700+((x)*4))
+#define  NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8__SIZE					0x00000040
+#define   NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_B_SHIFT					0
+#define   NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_B_MASK					0x000000ff
+#define   NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_G_SHIFT					8
+#define   NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_G_MASK					0x0000ff00
+#define   NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_R_SHIFT					16
+#define   NV04_IMAGE_PATTERN_PATTERN_X8R8G8B8_R_MASK					0x00ff0000
+
+
+#define NV03_VIDEO_LUT_CURSOR_DAC							0x00000046
+
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SYNCHRONIZE						0x00000100
+#define  NV03_VIDEO_LUT_CURSOR_DAC_STOP_IMAGE						0x00000104
+#define  NV03_VIDEO_LUT_CURSOR_DAC_STOP_CURSOR						0x00000108
+#define  NV03_VIDEO_LUT_CURSOR_DAC_STOP_DAC						0x0000010c
+#define  NV03_VIDEO_LUT_CURSOR_DAC_DMA_NOTIFY						0x00000180
+#define  NV03_VIDEO_LUT_CURSOR_DAC_DMA_IMAGE(x)						(0x00000184+((x)*4))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_DMA_IMAGE__SIZE					0x00000002
+#define  NV03_VIDEO_LUT_CURSOR_DAC_DMA_LUT(x)						(0x0000018c+((x)*4))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_DMA_LUT__SIZE					0x00000002
+#define  NV03_VIDEO_LUT_CURSOR_DAC_DMA_CURSOR(x)					(0x00000194+((x)*4))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_DMA_CURSOR__SIZE					0x00000002
+#define  NV03_VIDEO_LUT_CURSOR_DAC_GET							0x000002fc
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_OFFSET(x)					(0x00000300+((x)*8))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_OFFSET__SIZE				0x00000002
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT(x)					(0x00000304+((x)*8))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT__SIZE				0x00000002
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_PITCH_SHIFT			0
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_PITCH_MASK				0x0000ffff
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_COLOR_SHIFT			16
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_COLOR_MASK				0x0fff0000
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_NOTIFY_SHIFT			28
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_IMAGE_FORMAT_NOTIFY_MASK			0xf0000000
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_OFFSET(x)					(0x00000340+((x)*12))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_OFFSET__SIZE				0x00000002
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT(x)				(0x00000344+((x)*12))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT__SIZE				0x00000002
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_X_SHIFT			0
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_X_MASK				0x0000ffff
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_Y_SHIFT			16
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_Y_MASK				0xffff0000
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_FORMAT(x)					(0x00000348+((x)*12))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_FORMAT__SIZE				0x00000002
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A				0x00000358
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A_X_SHIFT			0
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A_X_MASK			0x0000ffff
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A_Y_SHIFT			16
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_CURSOR_POINT_OUT_A_Y_MASK			0xffff0000
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE(x)				(0x00000380+((x)*16))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE__SIZE				0x00000002
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE_W_SHIFT				0
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE_W_MASK				0x0000ffff
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE_H_SHIFT				16
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_IMAGE_SIZE_H_MASK				0xffff0000
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC(x)					(0x00000384+((x)*16))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC__SIZE					0x00000002
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_START_SHIFT				0
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_START_MASK				0x0000ffff
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_WIDTH_SHIFT				16
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_WIDTH_MASK				0x0fff0000
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_POLARITY_SHIFT			28
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_HSYNC_POLARITY_MASK				0xf0000000
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC(x)					(0x00000388+((x)*16))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC__SIZE					0x00000002
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_START_SHIFT				0
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_START_MASK				0x0000ffff
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_WIDTH_SHIFT				16
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_WIDTH_MASK				0x0fff0000
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_POLARITY_SHIFT			28
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_VSYNC_POLARITY_MASK				0xf0000000
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE(x)				(0x0000038c+((x)*16))
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE__SIZE				0x00000002
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_WIDTH_SHIFT			0
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_WIDTH_MASK			0x0000ffff
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_HEIGHT_SHIFT			16
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_HEIGHT_MASK			0x0fff0000
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_NOTIFY_SHIFT			28
+#define   NV03_VIDEO_LUT_CURSOR_DAC_SET_DAC_TOTAL_SIZE_NOTIFY_MASK			0xf0000000
+#define  NV03_VIDEO_LUT_CURSOR_DAC_SET_PIXEL_CLOCK					0x000003a0
+
+
+#define NV03_TEXTURED_TRIANGLE								0x00000048
+
+#define  NV03_TEXTURED_TRIANGLE_NOP							0x00000100
+#define  NV03_TEXTURED_TRIANGLE_NOTIFY							0x00000104
+#define  NV03_TEXTURED_TRIANGLE_PATCH							0x0000010c
+#define  NV03_TEXTURED_TRIANGLE_DMA_NOTIFY						0x00000180
+#define  NV03_TEXTURED_TRIANGLE_DMA_TEXTURE						0x00000184
+#define  NV03_TEXTURED_TRIANGLE_CLIP_RECTANGLE						0x00000188
+#define  NV03_TEXTURED_TRIANGLE_SURFACE							0x0000018c
+#define  NV03_TEXTURED_TRIANGLE_TEXTURE_OFFSET						0x00000304
+#define  NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT						0x00000308
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_KEY_MASK_SHIFT			0
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_KEY_MASK_MASK			0x0000ffff
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_KEY_ENABLE_SHIFT			16
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_KEY_ENABLE_MASK			0x000f0000
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_SHIFT				20
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_COLOR_MASK				0x00f00000
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_SIZE_MIN_SHIFT				24
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_SIZE_MIN_MASK				0x0f000000
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_SIZE_MAX_SHIFT				28
+#define   NV03_TEXTURED_TRIANGLE_TEXTURE_FORMAT_SIZE_MAX_MASK				0xf0000000
+#define  NV03_TEXTURED_TRIANGLE_FILTER							0x0000030c
+#define   NV03_TEXTURED_TRIANGLE_FILTER_SPREAD_X_SHIFT					0
+#define   NV03_TEXTURED_TRIANGLE_FILTER_SPREAD_X_MASK					0x0000001f
+#define   NV03_TEXTURED_TRIANGLE_FILTER_SPREAD_Y_SHIFT					8
+#define   NV03_TEXTURED_TRIANGLE_FILTER_SPREAD_Y_MASK					0x00001f00
+#define   NV03_TEXTURED_TRIANGLE_FILTER_SIZE_ADJUST_SHIFT				16
+#define   NV03_TEXTURED_TRIANGLE_FILTER_SIZE_ADJUST_MASK				0x00ff0000
+#define  NV03_TEXTURED_TRIANGLE_FOG_COLOR						0x00000310
+#define   NV03_TEXTURED_TRIANGLE_FOG_COLOR_B_SHIFT					0
+#define   NV03_TEXTURED_TRIANGLE_FOG_COLOR_B_MASK					0x000000ff
+#define   NV03_TEXTURED_TRIANGLE_FOG_COLOR_G_SHIFT					8
+#define   NV03_TEXTURED_TRIANGLE_FOG_COLOR_G_MASK					0x0000ff00
+#define   NV03_TEXTURED_TRIANGLE_FOG_COLOR_R_SHIFT					16
+#define   NV03_TEXTURED_TRIANGLE_FOG_COLOR_R_MASK					0x00ff0000
+#define  NV03_TEXTURED_TRIANGLE_CONTROL_OUT						0x00000314
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_INTERPOLATOR_SHIFT				0
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_INTERPOLATOR_MASK				0x0000000f
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_WRAP_U_SHIFT				4
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_WRAP_U_MASK				0x00000030
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_WRAP_V_SHIFT				6
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_WRAP_V_MASK				0x000000c0
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_SOURCE_COLOR_SHIFT				8
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_SOURCE_COLOR_MASK				0x00000f00
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_CULLING_SHIFT				12
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_CULLING_MASK				0x00007000
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_PERSPECTIVE_ENABLE			(1 << 15)
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_FUNC_SHIFT				16
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_FUNC_MASK				0x000f0000
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_WRITE_ENABLE_SHIFT			20
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_Z_WRITE_ENABLE_MASK			0x00f00000
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_COLOR_WRITE_ENABLE_SHIFT			24
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_COLOR_WRITE_ENABLE_MASK			0x07000000
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_ROP_SHIFT					27
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_ROP_MASK					0x18000000
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_BETA					(1 << 29)
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_DST_BLEND					(1 << 30)
+#define   NV03_TEXTURED_TRIANGLE_CONTROL_OUT_SRC_BLEND					(1 << 31)
+#define  NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL						0x00000318
+#define   NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL_ALPHA_REF_SHIFT				0
+#define   NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL_ALPHA_REF_MASK				0x000000ff
+#define   NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL_ALPHA_FUNC_SHIFT				8
+#define   NV03_TEXTURED_TRIANGLE_ALPHA_CONTROL_ALPHA_FUNC_MASK				0xffffff00
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR(x)					(0x00001000+((x)*32))
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR__SIZE					0x00000080
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I0_SHIFT				0
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I0_MASK				0x0000000f
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I1_SHIFT				4
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I1_MASK				0x000000f0
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I2_SHIFT				8
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I2_MASK				0x00000f00
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I3_SHIFT				12
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I3_MASK				0x0000f000
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I4_SHIFT				16
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I4_MASK				0x000f0000
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I5_SHIFT				20
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_I5_MASK				0x00f00000
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG_SHIFT				24
+#define   NV03_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG_MASK				0xff000000
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_COLOR(x)					(0x00001004+((x)*32))
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_COLOR__SIZE					0x00000080
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_SX(x)						(0x00001008+((x)*32))
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_SX__SIZE					0x00000080
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_SY(x)						(0x0000100c+((x)*32))
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_SY__SIZE					0x00000080
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_SZ(x)						(0x00001010+((x)*32))
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_SZ__SIZE					0x00000080
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_RHW(x)						(0x00001014+((x)*32))
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_RHW__SIZE					0x00000080
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_TU(x)						(0x00001018+((x)*32))
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_TU__SIZE					0x00000080
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_TV(x)						(0x0000101c+((x)*32))
+#define  NV03_TEXTURED_TRIANGLE_TLVERTEX_TV__SIZE					0x00000080
+
+
+#define NV04_GDI_RECTANGLE_TEXT								0x0000004a
+
+#define  NV04_GDI_RECTANGLE_TEXT_NOP							0x00000100
+#define  NV04_GDI_RECTANGLE_TEXT_NOTIFY							0x00000104
+#define  NV04_GDI_RECTANGLE_TEXT_PATCH							0x0000010c
+#define  NV04_GDI_RECTANGLE_TEXT_PM_TRIGGER						0x00000140
+#define  NV04_GDI_RECTANGLE_TEXT_DMA_NOTIFY						0x00000180
+#define  NV04_GDI_RECTANGLE_TEXT_DMA_FONTS						0x00000184
+#define  NV04_GDI_RECTANGLE_TEXT_PATTERN						0x00000188
+#define  NV04_GDI_RECTANGLE_TEXT_ROP							0x0000018c
+#define  NV04_GDI_RECTANGLE_TEXT_BETA1							0x00000190
+#define  NV04_GDI_RECTANGLE_TEXT_BETA4							0x00000194
+#define  NV04_GDI_RECTANGLE_TEXT_SURFACE						0x00000198
+#define  NV04_GDI_RECTANGLE_TEXT_OPERATION						0x000002fc
+#define   NV04_GDI_RECTANGLE_TEXT_OPERATION_SRCCOPY_AND					0x00000000
+#define   NV04_GDI_RECTANGLE_TEXT_OPERATION_ROP_AND					0x00000001
+#define   NV04_GDI_RECTANGLE_TEXT_OPERATION_BLEND_AND					0x00000002
+#define   NV04_GDI_RECTANGLE_TEXT_OPERATION_SRCCOPY					0x00000003
+#define   NV04_GDI_RECTANGLE_TEXT_OPERATION_SRCCOPY_PREMULT				0x00000004
+#define   NV04_GDI_RECTANGLE_TEXT_OPERATION_BLEND_PREMULT				0x00000005
+#define  NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT						0x00000300
+#define   NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A16R5G6B5				0x00000001
+#define   NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_X16A1R5G5B5				0x00000002
+#define   NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT_A8R8G8B8					0x00000003
+#define  NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT					0x00000304
+#define   NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_CGA6				0x00000001
+#define   NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_LE					0x00000002
+#define  NV04_GDI_RECTANGLE_TEXT_COLOR1_A						0x000003fc
+#define  NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT(x)				(0x00000400+((x)*8))
+#define  NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT__SIZE			0x00000020
+#define   NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y_SHIFT			0
+#define   NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y_MASK			0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X_SHIFT			16
+#define   NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X_MASK			0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE(x)				(0x00000404+((x)*8))
+#define  NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE__SIZE				0x00000020
+#define   NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H_SHIFT			0
+#define   NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H_MASK			0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W_SHIFT			16
+#define   NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W_MASK			0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0						0x000005f4
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_L_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_L_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_T_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT0_T_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1						0x000005f8
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_R_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_R_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_B_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_B_POINT1_B_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_COLOR1_B						0x000005fc
+#define  NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0(x)				(0x00000600+((x)*8))
+#define  NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0__SIZE			0x00000020
+#define   NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L_SHIFT			0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L_MASK			0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T_SHIFT			16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T_MASK			0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1(x)				(0x00000604+((x)*8))
+#define  NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1__SIZE			0x00000020
+#define   NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R_SHIFT			0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R_MASK			0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B_SHIFT			16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B_MASK			0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0						0x000007ec
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1						0x000007f0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_COLOR1_C						0x000007f4
+#define  NV04_GDI_RECTANGLE_TEXT_SIZE_C							0x000007f8
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_C_W_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_C_W_MASK						0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_C_H_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_C_H_MASK						0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_POINT_C						0x000007fc
+#define   NV04_GDI_RECTANGLE_TEXT_POINT_C_X_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_POINT_C_X_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_POINT_C_Y_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_POINT_C_Y_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C(x)					(0x00000800+((x)*4))
+#define  NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C__SIZE				0x00000080
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0						0x00000be4
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1						0x00000be8
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_COLOR0_E						0x00000bec
+#define  NV04_GDI_RECTANGLE_TEXT_COLOR1_E						0x00000bf0
+#define  NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E						0x00000bf4
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_W_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_W_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_H_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_IN_E_H_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E						0x00000bf8
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_POINT_E						0x00000bfc
+#define   NV04_GDI_RECTANGLE_TEXT_POINT_E_X_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_POINT_E_X_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_POINT_E_Y_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_POINT_E_Y_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E(x)				(0x00000c00+((x)*4))
+#define  NV04_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E__SIZE				0x00000080
+#define  NV04_GDI_RECTANGLE_TEXT_FONT_F							0x00000ff0
+#define   NV04_GDI_RECTANGLE_TEXT_FONT_F_OFFSET_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_FONT_F_OFFSET_MASK					0x0fffffff
+#define   NV04_GDI_RECTANGLE_TEXT_FONT_F_PITCH_SHIFT					28
+#define   NV04_GDI_RECTANGLE_TEXT_FONT_F_PITCH_MASK					0xf0000000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0						0x00000ff4
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_L_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_L_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_T_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT0_T_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1						0x00000ff8
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_R_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_R_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_B_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_F_POINT1_B_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_COLOR1_F						0x00000ffc
+#define  NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F(x)					(0x00001000+((x)*4))
+#define  NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F__SIZE				0x00000100
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_INDEX_SHIFT			0
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_INDEX_MASK				0x000000ff
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_X_SHIFT				8
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_X_MASK				0x000fff00
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_Y_SHIFT				20
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_F_Y_MASK				0xfff00000
+#define  NV04_GDI_RECTANGLE_TEXT_FONT_G							0x000017f0
+#define   NV04_GDI_RECTANGLE_TEXT_FONT_G_OFFSET_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_FONT_G_OFFSET_MASK					0x0fffffff
+#define   NV04_GDI_RECTANGLE_TEXT_FONT_G_PITCH_SHIFT					28
+#define   NV04_GDI_RECTANGLE_TEXT_FONT_G_PITCH_MASK					0xf0000000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0						0x000017f4
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_L_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_L_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_T_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT0_T_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1						0x000017f8
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_R_SHIFT					0
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_R_MASK					0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_B_SHIFT					16
+#define   NV04_GDI_RECTANGLE_TEXT_CLIP_G_POINT1_B_MASK					0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_COLOR1_G						0x000017fc
+#define  NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT(x)				(0x00001800+((x)*8))
+#define  NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT__SIZE				0x00000100
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_X_SHIFT			0
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_X_MASK			0x0000ffff
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_Y_SHIFT			16
+#define   NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_POINT_Y_MASK			0xffff0000
+#define  NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_INDEX(x)				(0x00001804+((x)*8))
+#define  NV04_GDI_RECTANGLE_TEXT_CHARACTER_COLOR1_G_INDEX__SIZE				0x00000100
+
+
+#define NV03_GDI_RECTANGLE_TEXT								0x0000004b
+
+#define  NV03_GDI_RECTANGLE_TEXT_NOP							0x00000100
+#define  NV03_GDI_RECTANGLE_TEXT_NOTIFY							0x00000104
+#define  NV03_GDI_RECTANGLE_TEXT_DMA_NOTIFY						0x00000180
+#define  NV03_GDI_RECTANGLE_TEXT_PATTERN						0x00000184
+#define  NV03_GDI_RECTANGLE_TEXT_ROP							0x00000188
+#define  NV03_GDI_RECTANGLE_TEXT_BETA1							0x0000018c
+#define  NV03_GDI_RECTANGLE_TEXT_SURFACE						0x00000190
+#define  NV03_GDI_RECTANGLE_TEXT_OPERATION						0x000002fc
+#define  NV03_GDI_RECTANGLE_TEXT_COLOR_FORMAT						0x00000300
+#define  NV03_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT					0x00000304
+#define  NV03_GDI_RECTANGLE_TEXT_COLOR1_A						0x000003fc
+#define  NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT				0x00000400
+#define   NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y_SHIFT			0
+#define   NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_Y_MASK			0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X_SHIFT			16
+#define   NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT_X_MASK			0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE				0x00000404
+#define   NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H_SHIFT			0
+#define   NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_H_MASK			0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W_SHIFT			16
+#define   NV03_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_SIZE_W_MASK			0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B						0x000007f4
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_L_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_L_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_T_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_POINT0_B_T_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B						0x000007f8
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_R_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_R_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_B_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_POINT1_B_B_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_COLOR1_B						0x000007fc
+#define  NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0				0x00000800
+#define   NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L_SHIFT			0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_L_MASK			0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T_SHIFT			16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_0_T_MASK			0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1				0x00000804
+#define   NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R_SHIFT			0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_R_MASK			0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B_SHIFT			16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIPPED_RECTANGLE_POINT_1_B_MASK			0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0						0x00000bec
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_L_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT0_T_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1						0x00000bf0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_R_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_C_POINT1_B_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_COLOR1_C						0x00000bf4
+#define  NV03_GDI_RECTANGLE_TEXT_SIZE_C							0x00000bf8
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_C_W_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_C_W_MASK						0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_C_H_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_C_H_MASK						0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_POINT_C						0x00000bfc
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_C_X_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_C_X_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_C_Y_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_C_Y_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C(x)					(0x00000c00+((x)*4))
+#define  NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_C__SIZE				0x00000020
+#define  NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0						0x00000fe8
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_L_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_L_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_T_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT0_T_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1						0x00000fec
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_R_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_R_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_B_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_D_POINT1_B_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_COLOR1_D						0x00000ff0
+#define  NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D						0x00000ff4
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_W_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_W_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_H_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_IN_D_H_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D						0x00000ff8
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_W_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_W_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_H_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_D_H_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_POINT_D						0x00000ffc
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_D_X_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_D_X_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_D_Y_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_D_Y_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_D(x)					(0x00001000+((x)*4))
+#define  NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR1_D__SIZE				0x00000020
+#define  NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0						0x000013e4
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_L_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT0_T_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1						0x000013e8
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_R_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_CLIP_E_POINT1_B_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_COLOR0_E						0x000013ec
+#define  NV03_GDI_RECTANGLE_TEXT_COLOR1_E						0x000013f0
+#define  NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E						0x000013f4
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_W_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_W_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_H_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_IN_E_H_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E						0x000013f8
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_W_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_SIZE_OUT_E_H_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_POINT_E						0x000013fc
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_E_X_SHIFT					0
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_E_X_MASK					0x0000ffff
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_E_Y_SHIFT					16
+#define   NV03_GDI_RECTANGLE_TEXT_POINT_E_Y_MASK					0xffff0000
+#define  NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E(x)				(0x00001400+((x)*4))
+#define  NV03_GDI_RECTANGLE_TEXT_MONOCHROME_COLOR01_E__SIZE				0x00000020
+
+
+#define NV04_SWIZZLED_SURFACE								0x00000052
+
+#define  NV04_SWIZZLED_SURFACE_NOP							0x00000100
+#define  NV04_SWIZZLED_SURFACE_NOTIFY							0x00000104
+#define  NV04_SWIZZLED_SURFACE_DMA_NOTIFY						0x00000180
+#define  NV04_SWIZZLED_SURFACE_DMA_IMAGE						0x00000184
+#define  NV04_SWIZZLED_SURFACE_FORMAT							0x00000300
+#define   NV04_SWIZZLED_SURFACE_FORMAT_COLOR_SHIFT					0
+#define   NV04_SWIZZLED_SURFACE_FORMAT_COLOR_MASK					0x000000ff
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y8					0x00000001
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1R5G5B5_Z1R5G5B5				0x00000002
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1R5G5B5_X1R5G5B5				0x00000003
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_R5G6B5					0x00000004
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y16					0x00000005
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X8R8G8B8_Z8R8G8B8				0x00000006
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X8R8G8B8_X8R8G8B8				0x00000007
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1A7R8G8B8_Z1A7R8G8B8			0x00000008
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_X1A7R8G8B8_X1A7R8G8B8			0x00000009
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_A8R8G8B8					0x0000000a
+#define    NV04_SWIZZLED_SURFACE_FORMAT_COLOR_Y32					0x0000000b
+#define   NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_U_SHIFT				16
+#define   NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_U_MASK					0x00ff0000
+#define   NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_V_SHIFT				24
+#define   NV04_SWIZZLED_SURFACE_FORMAT_BASE_SIZE_V_MASK					0xff000000
+#define  NV04_SWIZZLED_SURFACE_OFFSET							0x00000304
+
+
+#define NV20_SWIZZLED_SURFACE								0x0000009e
+
+
+
+#define NV30_SWIZZLED_SURFACE								0x0000039e
+
+
+
+#define NV40_SWIZZLED_SURFACE								0x0000309e
+
+
+
+#define NV04_CONTEXT_SURFACES_3D							0x00000053
+
+#define  NV04_CONTEXT_SURFACES_3D_NOP							0x00000100
+#define  NV04_CONTEXT_SURFACES_3D_NOTIFY						0x00000104
+#define  NV04_CONTEXT_SURFACES_3D_DMA_NOTIFY						0x00000180
+#define  NV04_CONTEXT_SURFACES_3D_DMA_COLOR						0x00000184
+#define  NV04_CONTEXT_SURFACES_3D_DMA_ZETA						0x00000188
+#define  NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL					0x000002f8
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_X_SHIFT				0
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_X_MASK				0x0000ffff
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_W_SHIFT				16
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL_W_MASK				0xffff0000
+#define  NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL						0x000002fc
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_Y_SHIFT				0
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_Y_MASK					0x0000ffff
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_H_SHIFT				16
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_VERTICAL_H_MASK					0xffff0000
+#define  NV04_CONTEXT_SURFACES_3D_FORMAT						0x00000300
+#define   NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_SHIFT					0
+#define   NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_MASK					0x000000ff
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1R5G5B5_Z1R5G5B5			0x00000001
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1R5G5B5_X1R5G5B5			0x00000002
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_R5G6B5					0x00000003
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X8R8G8B8_Z8R8G8B8			0x00000004
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X8R8G8B8_X8R8G8B8			0x00000005
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1A7R8G8B8_Z1A7R8G8B8			0x00000006
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_X1A7R8G8B8_X1A7R8G8B8			0x00000007
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_COLOR_A8R8G8B8				0x00000008
+#define   NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_SHIFT					8
+#define   NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_MASK					0x0000ff00
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_PITCH					0x00000100
+#define    NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_SWIZZLE					0x00000200
+#define   NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_U_SHIFT				16
+#define   NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_U_MASK				0x00ff0000
+#define   NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_V_SHIFT				24
+#define   NV04_CONTEXT_SURFACES_3D_FORMAT_BASE_SIZE_V_MASK				0xff000000
+#define  NV04_CONTEXT_SURFACES_3D_CLIP_SIZE						0x00000304
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_W_SHIFT					0
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_W_MASK					0x0000ffff
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_H_SHIFT					16
+#define   NV04_CONTEXT_SURFACES_3D_CLIP_SIZE_H_MASK					0xffff0000
+#define  NV04_CONTEXT_SURFACES_3D_PITCH							0x00000308
+#define   NV04_CONTEXT_SURFACES_3D_PITCH_COLOR_SHIFT					0
+#define   NV04_CONTEXT_SURFACES_3D_PITCH_COLOR_MASK					0x0000ffff
+#define   NV04_CONTEXT_SURFACES_3D_PITCH_ZETA_SHIFT					16
+#define   NV04_CONTEXT_SURFACES_3D_PITCH_ZETA_MASK					0xffff0000
+#define  NV04_CONTEXT_SURFACES_3D_OFFSET_COLOR						0x0000030c
+#define  NV04_CONTEXT_SURFACES_3D_OFFSET_ZETA						0x00000310
+
+
+#define NV10_CONTEXT_SURFACES_3D							0x00000093
+
+
+
+#define NV04_TEXTURED_TRIANGLE								0x00000054
+
+#define  NV04_TEXTURED_TRIANGLE_NOP							0x00000100
+#define  NV04_TEXTURED_TRIANGLE_NOTIFY							0x00000104
+#define  NV04_TEXTURED_TRIANGLE_DMA_NOTIFY						0x00000180
+#define  NV04_TEXTURED_TRIANGLE_DMA_A							0x00000184
+#define  NV04_TEXTURED_TRIANGLE_DMA_B							0x00000188
+#define  NV04_TEXTURED_TRIANGLE_SURFACE							0x0000018c
+#define  NV04_TEXTURED_TRIANGLE_COLORKEY						0x00000300
+#define  NV04_TEXTURED_TRIANGLE_OFFSET							0x00000304
+#define  NV04_TEXTURED_TRIANGLE_FORMAT							0x00000308
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_DMA_A						(1 <<  0)
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_DMA_B						(1 <<  1)
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_KEY_MATCH_SHIFT				2
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_KEY_MATCH_MASK				0x0000000c
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_SHIFT				4
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_MASK					0x00000030
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_CENTER				0x00000010
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_ZOH_CORNER				0x00000020
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_SHIFT				6
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_MASK					0x000000c0
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_CENTER				0x00000040
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ORIGIN_FOH_CORNER				0x00000080
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_SHIFT					8
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_MASK					0x00000f00
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_Y8					0x00000100
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_A1R5G5B5					0x00000200
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_X1R5G5B5					0x00000300
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_A4R4G4B4					0x00000400
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_R5G6B5					0x00000500
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_A8R8G8B8					0x00000600
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_COLOR_X8R8G8B8					0x00000700
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_MIPMAP_LEVELS_SHIFT				12
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_MIPMAP_LEVELS_MASK				0x0000f000
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_U_SHIFT				16
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_U_MASK				0x000f0000
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_V_SHIFT				20
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_BASE_SIZE_V_MASK				0x00f00000
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_SHIFT					24
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_MASK					0x07000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_REPEAT				0x01000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_MIRRORED_REPEAT			0x02000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_CLAMP_TO_EDGE				0x03000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_CLAMP_TO_BORDER			0x04000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSU_CLAMP					0x05000000
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_WRAPU						(1 << 27)
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_SHIFT					28
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_MASK					0x70000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_REPEAT				0x10000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_MIRRORED_REPEAT			0x20000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_CLAMP_TO_EDGE				0x30000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_CLAMP_TO_BORDER			0x40000000
+#define    NV04_TEXTURED_TRIANGLE_FORMAT_ADDRESSV_CLAMP					0x50000000
+#define   NV04_TEXTURED_TRIANGLE_FORMAT_WRAPV						(1 << 31)
+#define  NV04_TEXTURED_TRIANGLE_FILTER							0x0000030c
+#define   NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_X_SHIFT				0
+#define   NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_X_MASK				0x000000ff
+#define   NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_Y_SHIFT				8
+#define   NV04_TEXTURED_TRIANGLE_FILTER_KERNEL_SIZE_Y_MASK				0x00007f00
+#define   NV04_TEXTURED_TRIANGLE_FILTER_MIPMAP_DITHER_ENABLE				(1 << 15)
+#define   NV04_TEXTURED_TRIANGLE_FILTER_MIPMAP_LODBIAS_SHIFT				16
+#define   NV04_TEXTURED_TRIANGLE_FILTER_MIPMAP_LODBIAS_MASK				0x00ff0000
+#define   NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_SHIFT					24
+#define   NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_MASK					0x07000000
+#define    NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_NEAREST					0x01000000
+#define    NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_LINEAR					0x02000000
+#define    NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST			0x03000000
+#define    NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST			0x04000000
+#define    NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR			0x05000000
+#define    NV04_TEXTURED_TRIANGLE_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR			0x06000000
+#define   NV04_TEXTURED_TRIANGLE_FILTER_ANISOTROPIC_MINIFY_ENABLE			(1 << 27)
+#define   NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_SHIFT					28
+#define   NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_MASK					0x70000000
+#define    NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_NEAREST				0x10000000
+#define    NV04_TEXTURED_TRIANGLE_FILTER_MAGNIFY_LINEAR					0x20000000
+#define   NV04_TEXTURED_TRIANGLE_FILTER_ANISOTROPIC_MAGNIFY_ENABLE			(1 << 31)
+#define  NV04_TEXTURED_TRIANGLE_BLEND							0x00000310
+#define   NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_SHIFT				0
+#define   NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_MAP_MASK					0x0000000f
+#define   NV04_TEXTURED_TRIANGLE_BLEND_MASK_BIT_SHIFT					4
+#define   NV04_TEXTURED_TRIANGLE_BLEND_MASK_BIT_MASK					0x00000030
+#define   NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_SHIFT					6
+#define   NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_MASK					0x000000c0
+#define    NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_FLAT					0x00000040
+#define    NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_GOURAUD				0x00000080
+#define    NV04_TEXTURED_TRIANGLE_BLEND_SHADE_MODE_PHONG				0x000000c0
+#define   NV04_TEXTURED_TRIANGLE_BLEND_TEXTURE_PERSPECTIVE_ENABLE			(1 <<  8)
+#define   NV04_TEXTURED_TRIANGLE_BLEND_SPECULAR_ENABLE					(1 << 12)
+#define   NV04_TEXTURED_TRIANGLE_BLEND_FOG_ENABLE					(1 << 16)
+#define   NV04_TEXTURED_TRIANGLE_BLEND_BLEND_ENABLE					(1 << 20)
+#define   NV04_TEXTURED_TRIANGLE_BLEND_SRC_SHIFT					24
+#define   NV04_TEXTURED_TRIANGLE_BLEND_SRC_MASK						0x0f000000
+#define   NV04_TEXTURED_TRIANGLE_BLEND_DST_SHIFT					28
+#define   NV04_TEXTURED_TRIANGLE_BLEND_DST_MASK						0xf0000000
+#define  NV04_TEXTURED_TRIANGLE_CONTROL							0x00000314
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_REF_SHIFT				0
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_REF_MASK					0x000000ff
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_SHIFT				8
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_FUNC_MASK				0x00000f00
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_ALPHA_ENABLE					(1 << 12)
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_ORIGIN						(1 << 13)
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_Z_ENABLE					(1 << 14)
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_SHIFT					16
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_Z_FUNC_MASK					0x000f0000
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_SHIFT				20
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_MASK					0x00300000
+#define    NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_BOTH				0x00000000
+#define    NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_NONE				0x00100000
+#define    NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_CW					0x00200000
+#define    NV04_TEXTURED_TRIANGLE_CONTROL_CULL_MODE_CCW					0x00300000
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_DITHER_ENABLE					(1 << 22)
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_Z_PERSPECTIVE_ENABLE				(1 << 23)
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_Z_WRITE					(1 << 24)
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_Z_FORMAT_SHIFT					30
+#define   NV04_TEXTURED_TRIANGLE_CONTROL_Z_FORMAT_MASK					0xc0000000
+#define  NV04_TEXTURED_TRIANGLE_FOGCOLOR						0x00000318
+#define   NV04_TEXTURED_TRIANGLE_FOGCOLOR_B_SHIFT					0
+#define   NV04_TEXTURED_TRIANGLE_FOGCOLOR_B_MASK					0x000000ff
+#define   NV04_TEXTURED_TRIANGLE_FOGCOLOR_G_SHIFT					8
+#define   NV04_TEXTURED_TRIANGLE_FOGCOLOR_G_MASK					0x0000ff00
+#define   NV04_TEXTURED_TRIANGLE_FOGCOLOR_R_SHIFT					16
+#define   NV04_TEXTURED_TRIANGLE_FOGCOLOR_R_MASK					0x00ff0000
+#define   NV04_TEXTURED_TRIANGLE_FOGCOLOR_A_SHIFT					24
+#define   NV04_TEXTURED_TRIANGLE_FOGCOLOR_A_MASK					0xff000000
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_SX(x)						(0x00000400+((x)*32))
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_SX__SIZE					0x00000010
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_SY(x)						(0x00000404+((x)*32))
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_SY__SIZE					0x00000010
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_SZ(x)						(0x00000408+((x)*32))
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_SZ__SIZE					0x00000010
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_RHW(x)						(0x0000040c+((x)*32))
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_RHW__SIZE					0x00000010
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR(x)					(0x00000410+((x)*32))
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR__SIZE					0x00000010
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_B_SHIFT					0
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_B_MASK					0x000000ff
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_G_SHIFT					8
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_G_MASK					0x0000ff00
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_R_SHIFT					16
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_R_MASK					0x00ff0000
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_A_SHIFT					24
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_COLOR_A_MASK					0xff000000
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR(x)					(0x00000414+((x)*32))
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR__SIZE					0x00000010
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_B_SHIFT				0
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_B_MASK				0x000000ff
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_G_SHIFT				8
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_G_MASK				0x0000ff00
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_R_SHIFT				16
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_R_MASK				0x00ff0000
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG_SHIFT				24
+#define   NV04_TEXTURED_TRIANGLE_TLVERTEX_SPECULAR_FOG_MASK				0xff000000
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_TU(x)						(0x00000418+((x)*32))
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_TU__SIZE					0x00000010
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_TV(x)						(0x0000041c+((x)*32))
+#define  NV04_TEXTURED_TRIANGLE_TLVERTEX_TV__SIZE					0x00000010
+#define  NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE(x)					(0x00000600+((x)*4))
+#define  NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE__SIZE					0x00000040
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I0_SHIFT					0
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I0_MASK					0x0000000f
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I1_SHIFT					4
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I1_MASK					0x000000f0
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I2_SHIFT					8
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I2_MASK					0x00000f00
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I3_SHIFT					12
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I3_MASK					0x0000f000
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I4_SHIFT					16
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I4_MASK					0x000f0000
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I5_SHIFT					20
+#define   NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE_I5_MASK					0x00f00000
+
+
+#define NV10_TEXTURED_TRIANGLE								0x00000094
+
+
+
+#define NV04_MULTITEX_TRIANGLE								0x00000055
+
+#define  NV04_MULTITEX_TRIANGLE_NOP							0x00000100
+#define  NV04_MULTITEX_TRIANGLE_NOTIFY							0x00000104
+#define  NV04_MULTITEX_TRIANGLE_DMA_NOTIFY						0x00000180
+#define  NV04_MULTITEX_TRIANGLE_DMA_A							0x00000184
+#define  NV04_MULTITEX_TRIANGLE_DMA_B							0x00000188
+#define  NV04_MULTITEX_TRIANGLE_SURFACE							0x0000018c
+#define  NV04_MULTITEX_TRIANGLE_OFFSET(x)						(0x00000308+((x)*4))
+#define  NV04_MULTITEX_TRIANGLE_OFFSET__SIZE						0x00000002
+#define  NV04_MULTITEX_TRIANGLE_FORMAT(x)						(0x00000310+((x)*4))
+#define  NV04_MULTITEX_TRIANGLE_FORMAT__SIZE						0x00000002
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_DMA_A						(1 <<  0)
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_DMA_B						(1 <<  1)
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_ZOH_SHIFT				4
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_ZOH_MASK					0x00000030
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_FOH_SHIFT				6
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_ORIGIN_FOH_MASK					0x000000c0
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_SHIFT					8
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_COLOR_MASK					0x00000f00
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_MIPMAP_LEVELS_SHIFT				12
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_MIPMAP_LEVELS_MASK				0x0000f000
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_U_SHIFT				16
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_U_MASK				0x000f0000
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_V_SHIFT				20
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_BASE_SIZE_V_MASK				0x00f00000
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU_SHIFT					24
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSU_MASK					0x07000000
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_WRAPU						(1 << 27)
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV_SHIFT					28
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_ADDRESSV_MASK					0x70000000
+#define   NV04_MULTITEX_TRIANGLE_FORMAT_WRAPV						(1 << 31)
+#define  NV04_MULTITEX_TRIANGLE_FILTER(x)						(0x00000318+((x)*4))
+#define  NV04_MULTITEX_TRIANGLE_FILTER__SIZE						0x00000002
+#define   NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_X_SHIFT				0
+#define   NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_X_MASK				0x000000ff
+#define   NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_Y_SHIFT				8
+#define   NV04_MULTITEX_TRIANGLE_FILTER_KERNEL_SIZE_Y_MASK				0x00007f00
+#define   NV04_MULTITEX_TRIANGLE_FILTER_MIPMAP_DITHER_ENABLE				(1 << 15)
+#define   NV04_MULTITEX_TRIANGLE_FILTER_MIPMAP_LODBIAS_SHIFT				16
+#define   NV04_MULTITEX_TRIANGLE_FILTER_MIPMAP_LODBIAS_MASK				0x00ff0000
+#define   NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_SHIFT					24
+#define   NV04_MULTITEX_TRIANGLE_FILTER_MINIFY_MASK					0x07000000
+#define   NV04_MULTITEX_TRIANGLE_FILTER_ANISOTROPIC_MINIFY_ENABLE			(1 << 27)
+#define   NV04_MULTITEX_TRIANGLE_FILTER_MAGNIFY_SHIFT					28
+#define   NV04_MULTITEX_TRIANGLE_FILTER_MAGNIFY_MASK					0x70000000
+#define   NV04_MULTITEX_TRIANGLE_FILTER_ANISOTROPIC_MAGNIFY_ENABLE			(1 << 31)
+#define  NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA(x)					(0x00000320+((x)*12))
+#define  NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA__SIZE					0x00000002
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE0					(1 <<  0)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_SHIFT				2
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_MASK				0x000000fc
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_ZERO				0x00000004
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_CONSTANT			0x00000008
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_PRIMARY_COLOR			0x0000000c
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_PREVIOUS			0x00000010
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_TEXTURE0			0x00000014
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT0_TEXTURE1			0x00000018
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE1					(1 <<  8)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_SHIFT				10
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_MASK				0x0000fc00
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_ZERO				0x00000400
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_CONSTANT			0x00000800
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_PRIMARY_COLOR			0x00000c00
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_PREVIOUS			0x00001000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_TEXTURE0			0x00001400
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT1_TEXTURE1			0x00001800
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE2					(1 << 16)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_SHIFT				18
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_MASK				0x00fc0000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_ZERO				0x00040000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_CONSTANT			0x00080000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_PRIMARY_COLOR			0x000c0000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_PREVIOUS			0x00100000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_TEXTURE0			0x00140000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT2_TEXTURE1			0x00180000
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_INVERSE3					(1 << 24)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_SHIFT				26
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_MASK				0x1c000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_ZERO				0x04000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_CONSTANT			0x08000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_PRIMARY_COLOR			0x0c000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_PREVIOUS			0x10000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_TEXTURE0			0x14000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_ARGUMENT3_TEXTURE1			0x18000000
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_SHIFT				29
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_MASK					0xe0000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_IDENTITY				0x20000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_SCALE2				0x40000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_SCALE4				0x60000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_BIAS				0x80000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA_MAP_BIAS_SCALE2				0xe0000000
+#define  NV04_MULTITEX_TRIANGLE_COMBINE_COLOR(x)					(0x00000324+((x)*12))
+#define  NV04_MULTITEX_TRIANGLE_COMBINE_COLOR__SIZE					0x00000002
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE0					(1 <<  0)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA0					(1 <<  1)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_SHIFT				2
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_MASK				0x000000fc
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_ZERO				0x00000004
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_CONSTANT			0x00000008
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_PRIMARY_COLOR			0x0000000c
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_PREVIOUS			0x00000010
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_TEXTURE0			0x00000014
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT0_TEXTURE1			0x00000018
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE1					(1 <<  8)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA1					(1 <<  9)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_SHIFT				10
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_MASK				0x0000fc00
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_ZERO				0x00000400
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_CONSTANT			0x00000800
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_PRIMARY_COLOR			0x00000c00
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_PREVIOUS			0x00001000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_TEXTURE0			0x00001400
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT1_TEXTURE1			0x00001800
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE2					(1 << 16)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA2					(1 << 17)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_SHIFT				18
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_MASK				0x00fc0000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_ZERO				0x00040000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_CONSTANT			0x00080000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_PRIMARY_COLOR			0x000c0000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_PREVIOUS			0x00100000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_TEXTURE0			0x00140000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT2_TEXTURE1			0x00180000
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_INVERSE3					(1 << 24)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ALPHA3					(1 << 25)
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_SHIFT				26
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_MASK				0x1c000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_ZERO				0x04000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_CONSTANT			0x08000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_PRIMARY_COLOR			0x0c000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_PREVIOUS			0x10000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_TEXTURE0			0x14000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_ARGUMENT3_TEXTURE1			0x18000000
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_SHIFT				29
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_MASK					0xe0000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_IDENTITY				0x20000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_SCALE2				0x40000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_SCALE4				0x60000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_BIAS				0x80000000
+#define    NV04_MULTITEX_TRIANGLE_COMBINE_COLOR_MAP_BIAS_SCALE2				0xe0000000
+#define  NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR						0x00000334
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_B_SHIFT					0
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_B_MASK					0x000000ff
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_G_SHIFT					8
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_G_MASK					0x0000ff00
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_R_SHIFT					16
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_R_MASK					0x00ff0000
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_A_SHIFT					24
+#define   NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR_A_MASK					0xff000000
+#define  NV04_MULTITEX_TRIANGLE_BLEND							0x00000338
+#define   NV04_MULTITEX_TRIANGLE_BLEND_MASK_BIT_SHIFT					4
+#define   NV04_MULTITEX_TRIANGLE_BLEND_MASK_BIT_MASK					0x00000030
+#define   NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_SHIFT					6
+#define   NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_MASK					0x000000c0
+#define    NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_FLAT					0x00000040
+#define    NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_GOURAUD				0x00000080
+#define    NV04_MULTITEX_TRIANGLE_BLEND_SHADE_MODE_PHONG				0x000000c0
+#define   NV04_MULTITEX_TRIANGLE_BLEND_TEXTURE_PERSPECTIVE_ENABLE			(1 <<  8)
+#define   NV04_MULTITEX_TRIANGLE_BLEND_SPECULAR_ENABLE					(1 << 12)
+#define   NV04_MULTITEX_TRIANGLE_BLEND_FOG_ENABLE					(1 << 16)
+#define   NV04_MULTITEX_TRIANGLE_BLEND_BLEND_ENABLE					(1 << 20)
+#define   NV04_MULTITEX_TRIANGLE_BLEND_SRC_SHIFT					24
+#define   NV04_MULTITEX_TRIANGLE_BLEND_SRC_MASK						0x0f000000
+#define   NV04_MULTITEX_TRIANGLE_BLEND_DST_SHIFT					28
+#define   NV04_MULTITEX_TRIANGLE_BLEND_DST_MASK						0xf0000000
+#define  NV04_MULTITEX_TRIANGLE_CONTROL0						0x0000033c
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_REF_SHIFT				0
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_REF_MASK				0x000000ff
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_SHIFT				8
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_FUNC_MASK				0x00000f00
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_ENABLE					(1 << 12)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_ORIGIN					(1 << 13)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_Z_ENABLE					(1 << 14)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_SHIFT					16
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FUNC_MASK					0x000f0000
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_SHIFT				20
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_MASK				0x00300000
+#define    NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_BOTH				0x00000000
+#define    NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_NONE				0x00100000
+#define    NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_CW					0x00200000
+#define    NV04_MULTITEX_TRIANGLE_CONTROL0_CULL_MODE_CCW				0x00300000
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_DITHER_ENABLE					(1 << 22)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_Z_PERSPECTIVE_ENABLE				(1 << 23)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_Z_WRITE					(1 << 24)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_STENCIL_WRITE					(1 << 25)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_ALPHA_WRITE					(1 << 26)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_RED_WRITE					(1 << 27)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_GREEN_WRITE					(1 << 28)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_BLUE_WRITE					(1 << 29)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FORMAT_SHIFT				30
+#define   NV04_MULTITEX_TRIANGLE_CONTROL0_Z_FORMAT_MASK					0xc0000000
+#define  NV04_MULTITEX_TRIANGLE_CONTROL1						0x00000340
+#define   NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_ENABLE				(1 <<  0)
+#define   NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_FUNC_SHIFT				4
+#define   NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_FUNC_MASK				0x000000f0
+#define   NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_REF_SHIFT				8
+#define   NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_REF_MASK				0x0000ff00
+#define   NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_READ_SHIFT			16
+#define   NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_READ_MASK			0x00ff0000
+#define   NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_WRITE_SHIFT			24
+#define   NV04_MULTITEX_TRIANGLE_CONTROL1_STENCIL_MASK_WRITE_MASK			0xff000000
+#define  NV04_MULTITEX_TRIANGLE_CONTROL2						0x00000344
+#define   NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_FAIL_SHIFT				0
+#define   NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_FAIL_MASK				0x0000000f
+#define   NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZFAIL_SHIFT			4
+#define   NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZFAIL_MASK				0x000000f0
+#define   NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZPASS_SHIFT			8
+#define   NV04_MULTITEX_TRIANGLE_CONTROL2_STENCIL_OP_ZPASS_MASK				0x00000f00
+#define  NV04_MULTITEX_TRIANGLE_FOGCOLOR						0x00000348
+#define   NV04_MULTITEX_TRIANGLE_FOGCOLOR_B_SHIFT					0
+#define   NV04_MULTITEX_TRIANGLE_FOGCOLOR_B_MASK					0x000000ff
+#define   NV04_MULTITEX_TRIANGLE_FOGCOLOR_G_SHIFT					8
+#define   NV04_MULTITEX_TRIANGLE_FOGCOLOR_G_MASK					0x0000ff00
+#define   NV04_MULTITEX_TRIANGLE_FOGCOLOR_R_SHIFT					16
+#define   NV04_MULTITEX_TRIANGLE_FOGCOLOR_R_MASK					0x00ff0000
+#define   NV04_MULTITEX_TRIANGLE_FOGCOLOR_A_SHIFT					24
+#define   NV04_MULTITEX_TRIANGLE_FOGCOLOR_A_MASK					0xff000000
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SX(x)					(0x00000400+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SX__SIZE					0x00000008
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SY(x)					(0x00000404+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SY__SIZE					0x00000008
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SZ(x)					(0x00000408+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SZ__SIZE					0x00000008
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_RHW(x)					(0x0000040c+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_RHW__SIZE					0x00000008
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR(x)					(0x00000410+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR__SIZE					0x00000008
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_B_SHIFT				0
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_B_MASK				0x000000ff
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_G_SHIFT				8
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_G_MASK				0x0000ff00
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_R_SHIFT				16
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_R_MASK				0x00ff0000
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_A_SHIFT				24
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_COLOR_A_MASK				0xff000000
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR(x)					(0x00000414+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR__SIZE				0x00000008
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_B_SHIFT				0
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_B_MASK				0x000000ff
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_G_SHIFT				8
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_G_MASK				0x0000ff00
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_R_SHIFT				16
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_R_MASK				0x00ff0000
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_FOG_SHIFT				24
+#define   NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SPECULAR_FOG_MASK				0xff000000
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU0(x)					(0x00000418+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU0__SIZE					0x00000008
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV0(x)					(0x0000041c+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV0__SIZE					0x00000008
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU1(x)					(0x00000420+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TU1__SIZE					0x00000008
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV1(x)					(0x00000424+((x)*40))
+#define  NV04_MULTITEX_TRIANGLE_TLMTVERTEX_TV1__SIZE					0x00000008
+#define  NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE(x)					(0x00000540+((x)*4))
+#define  NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE__SIZE					0x00000030
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I0_SHIFT					0
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I0_MASK					0x0000000f
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I1_SHIFT					4
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I1_MASK					0x000000f0
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I2_SHIFT					8
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I2_MASK					0x00000f00
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I3_SHIFT					12
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I3_MASK					0x0000f000
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I4_SHIFT					16
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I4_MASK					0x000f0000
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I5_SHIFT					20
+#define   NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE_I5_MASK					0x00f00000
+
+
+#define NV10_MULTITEX_TRIANGLE								0x00000095
+
+
+
+#define NV10TCL										0x00000056
+
+#define  NV10TCL_NOP									0x00000100
+#define  NV10TCL_NOTIFY									0x00000104
+#define  NV10TCL_DMA_NOTIFY								0x00000180
+#define  NV10TCL_DMA_IN_MEMORY0								0x00000184
+#define  NV10TCL_DMA_IN_MEMORY1								0x00000188
+#define  NV10TCL_DMA_VTXBUF0								0x0000018c
+#define  NV10TCL_DMA_IN_MEMORY2								0x00000194
+#define  NV10TCL_DMA_IN_MEMORY3								0x00000198
+#define  NV10TCL_RT_HORIZ								0x00000200
+#define   NV10TCL_RT_HORIZ_X_SHIFT							0
+#define   NV10TCL_RT_HORIZ_X_MASK							0x0000ffff
+#define   NV10TCL_RT_HORIZ_W_SHIFT							16
+#define   NV10TCL_RT_HORIZ_W_MASK							0xffff0000
+#define  NV10TCL_RT_VERT								0x00000204
+#define   NV10TCL_RT_VERT_Y_SHIFT							0
+#define   NV10TCL_RT_VERT_Y_MASK							0x0000ffff
+#define   NV10TCL_RT_VERT_H_SHIFT							16
+#define   NV10TCL_RT_VERT_H_MASK							0xffff0000
+#define  NV10TCL_RT_FORMAT								0x00000208
+#define   NV10TCL_RT_FORMAT_TYPE_SHIFT							8
+#define   NV10TCL_RT_FORMAT_TYPE_MASK							0x00000f00
+#define    NV10TCL_RT_FORMAT_TYPE_LINEAR						0x00000100
+#define    NV10TCL_RT_FORMAT_TYPE_SWIZZLED						0x00000200
+#define   NV10TCL_RT_FORMAT_COLOR_SHIFT							0
+#define   NV10TCL_RT_FORMAT_COLOR_MASK							0x0000001f
+#define    NV10TCL_RT_FORMAT_COLOR_R5G6B5						0x00000003
+#define    NV10TCL_RT_FORMAT_COLOR_X8R8G8B8						0x00000005
+#define    NV10TCL_RT_FORMAT_COLOR_A8R8G8B8						0x00000008
+#define    NV10TCL_RT_FORMAT_COLOR_B8							0x00000009
+#define    NV10TCL_RT_FORMAT_COLOR_UNKNOWN						0x0000000d
+#define    NV10TCL_RT_FORMAT_COLOR_X8B8G8R8						0x0000000f
+#define    NV10TCL_RT_FORMAT_COLOR_A8B8G8R8						0x00000010
+#define  NV10TCL_RT_PITCH								0x0000020c
+#define   NV10TCL_RT_PITCH_COLOR_PITCH_SHIFT						0
+#define   NV10TCL_RT_PITCH_COLOR_PITCH_MASK						0x0000ffff
+#define   NV10TCL_RT_PITCH_ZETA_PITCH_SHIFT						16
+#define   NV10TCL_RT_PITCH_ZETA_PITCH_MASK						0xffff0000
+#define  NV10TCL_COLOR_OFFSET								0x00000210
+#define  NV10TCL_ZETA_OFFSET								0x00000214
+#define  NV10TCL_TX_OFFSET(x)								(0x00000218+((x)*4))
+#define  NV10TCL_TX_OFFSET__SIZE							0x00000002
+#define  NV10TCL_TX_FORMAT(x)								(0x00000220+((x)*4))
+#define  NV10TCL_TX_FORMAT__SIZE							0x00000002
+#define   NV10TCL_TX_FORMAT_DMA0							(1 <<  0)
+#define   NV10TCL_TX_FORMAT_DMA1							(1 <<  1)
+#define   NV10TCL_TX_FORMAT_CUBE_MAP							(1 <<  2)
+#define   NV10TCL_TX_FORMAT_FORMAT_SHIFT						7
+#define   NV10TCL_TX_FORMAT_FORMAT_MASK							0x00000f80
+#define    NV10TCL_TX_FORMAT_FORMAT_L8							0x00000000
+#define    NV10TCL_TX_FORMAT_FORMAT_A8							0x00000080
+#define    NV10TCL_TX_FORMAT_FORMAT_A1R5G5B5						0x00000100
+#define    NV10TCL_TX_FORMAT_FORMAT_A4R4G4B4						0x00000200
+#define    NV10TCL_TX_FORMAT_FORMAT_R5G6B5						0x00000280
+#define    NV10TCL_TX_FORMAT_FORMAT_A8R8G8B8						0x00000300
+#define    NV10TCL_TX_FORMAT_FORMAT_X8R8G8B8						0x00000380
+#define    NV10TCL_TX_FORMAT_FORMAT_INDEX8						0x00000580
+#define    NV10TCL_TX_FORMAT_FORMAT_DXT1						0x00000600
+#define    NV10TCL_TX_FORMAT_FORMAT_DXT3						0x00000700
+#define    NV10TCL_TX_FORMAT_FORMAT_DXT5						0x00000780
+#define    NV10TCL_TX_FORMAT_FORMAT_A1R5G5B5_RECT					0x00000800
+#define    NV10TCL_TX_FORMAT_FORMAT_R5G6B5_RECT						0x00000880
+#define    NV10TCL_TX_FORMAT_FORMAT_A8R8G8B8_RECT					0x00000900
+#define    NV10TCL_TX_FORMAT_FORMAT_A8_RECT						0x00000980
+#define   NV10TCL_TX_FORMAT_MIPMAP							(1 << 15)
+#define   NV10TCL_TX_FORMAT_BASE_SIZE_U_SHIFT						16
+#define   NV10TCL_TX_FORMAT_BASE_SIZE_U_MASK						0x000f0000
+#define   NV10TCL_TX_FORMAT_BASE_SIZE_V_SHIFT						20
+#define   NV10TCL_TX_FORMAT_BASE_SIZE_V_MASK						0x00f00000
+#define   NV10TCL_TX_FORMAT_WRAP_S_SHIFT						24
+#define   NV10TCL_TX_FORMAT_WRAP_S_MASK							0x0f000000
+#define    NV10TCL_TX_FORMAT_WRAP_S_REPEAT						0x01000000
+#define    NV10TCL_TX_FORMAT_WRAP_S_MIRRORED_REPEAT					0x02000000
+#define    NV10TCL_TX_FORMAT_WRAP_S_CLAMP_TO_EDGE					0x03000000
+#define    NV10TCL_TX_FORMAT_WRAP_S_CLAMP_TO_BORDER					0x04000000
+#define    NV10TCL_TX_FORMAT_WRAP_S_CLAMP						0x05000000
+#define   NV10TCL_TX_FORMAT_WRAP_T_SHIFT						28
+#define   NV10TCL_TX_FORMAT_WRAP_T_MASK							0xf0000000
+#define    NV10TCL_TX_FORMAT_WRAP_T_REPEAT						0x10000000
+#define    NV10TCL_TX_FORMAT_WRAP_T_MIRRORED_REPEAT					0x20000000
+#define    NV10TCL_TX_FORMAT_WRAP_T_CLAMP_TO_EDGE					0x30000000
+#define    NV10TCL_TX_FORMAT_WRAP_T_CLAMP_TO_BORDER					0x40000000
+#define    NV10TCL_TX_FORMAT_WRAP_T_CLAMP						0x50000000
+#define  NV10TCL_TX_ENABLE(x)								(0x00000228+((x)*4))
+#define  NV10TCL_TX_ENABLE__SIZE							0x00000002
+#define   NV10TCL_TX_ENABLE_CULL_SHIFT							0
+#define   NV10TCL_TX_ENABLE_CULL_MASK							0x0000000f
+#define    NV10TCL_TX_ENABLE_CULL_DISABLED						0x00000000
+#define    NV10TCL_TX_ENABLE_CULL_TEST_ALL						0x00000003
+#define    NV10TCL_TX_ENABLE_CULL_TEST_ALPHA						0x00000004
+#define   NV10TCL_TX_ENABLE_ANISOTROPY_SHIFT						4
+#define   NV10TCL_TX_ENABLE_ANISOTROPY_MASK						0x00000030
+#define   NV10TCL_TX_ENABLE_MIPMAP_MAX_LOD_SHIFT					14
+#define   NV10TCL_TX_ENABLE_MIPMAP_MAX_LOD_MASK						0x0003c000
+#define   NV10TCL_TX_ENABLE_MIPMAP_MIN_LOD_SHIFT					26
+#define   NV10TCL_TX_ENABLE_MIPMAP_MIN_LOD_MASK						0x3c000000
+#define   NV10TCL_TX_ENABLE_ENABLE							(1 << 30)
+#define  NV10TCL_TX_NPOT_PITCH(x)							(0x00000230+((x)*4))
+#define  NV10TCL_TX_NPOT_PITCH__SIZE							0x00000002
+#define   NV10TCL_TX_NPOT_PITCH_PITCH_SHIFT						16
+#define   NV10TCL_TX_NPOT_PITCH_PITCH_MASK						0xffff0000
+#define  NV10TCL_TX_NPOT_SIZE(x)							(0x00000240+((x)*4))
+#define  NV10TCL_TX_NPOT_SIZE__SIZE							0x00000002
+#define   NV10TCL_TX_NPOT_SIZE_H_SHIFT							0
+#define   NV10TCL_TX_NPOT_SIZE_H_MASK							0x0000ffff
+#define   NV10TCL_TX_NPOT_SIZE_W_SHIFT							16
+#define   NV10TCL_TX_NPOT_SIZE_W_MASK							0xffff0000
+#define  NV10TCL_TX_FILTER(x)								(0x00000248+((x)*4))
+#define  NV10TCL_TX_FILTER__SIZE							0x00000002
+#define   NV10TCL_TX_FILTER_LOD_BIAS_SHIFT						8
+#define   NV10TCL_TX_FILTER_LOD_BIAS_MASK						0x00000f00
+#define   NV10TCL_TX_FILTER_MINIFY_SHIFT						24
+#define   NV10TCL_TX_FILTER_MINIFY_MASK							0x0f000000
+#define    NV10TCL_TX_FILTER_MINIFY_NEAREST						0x01000000
+#define    NV10TCL_TX_FILTER_MINIFY_LINEAR						0x02000000
+#define    NV10TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST				0x03000000
+#define    NV10TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST				0x04000000
+#define    NV10TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR				0x05000000
+#define    NV10TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR				0x06000000
+#define   NV10TCL_TX_FILTER_MAGNIFY_SHIFT						28
+#define   NV10TCL_TX_FILTER_MAGNIFY_MASK						0xf0000000
+#define    NV10TCL_TX_FILTER_MAGNIFY_NEAREST						0x10000000
+#define    NV10TCL_TX_FILTER_MAGNIFY_LINEAR						0x20000000
+#define  NV10TCL_TX_PALETTE_OFFSET(x)							(0x00000250+((x)*4))
+#define  NV10TCL_TX_PALETTE_OFFSET__SIZE						0x00000002
+#define  NV10TCL_RC_IN_ALPHA(x)								(0x00000260+((x)*4))
+#define  NV10TCL_RC_IN_ALPHA__SIZE							0x00000002
+#define   NV10TCL_RC_IN_ALPHA_D_INPUT_SHIFT						0
+#define   NV10TCL_RC_IN_ALPHA_D_INPUT_MASK						0x0000000f
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR0					0x00000001
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR1					0x00000002
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_FOG						0x00000003
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_PRIMARY_COLOR					0x00000004
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_SECONDARY_COLOR					0x00000005
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_TEXTURE0						0x00000008
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_TEXTURE1						0x00000009
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_SPARE0						0x0000000c
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_SPARE1						0x0000000d
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_E_TIMES_F					0x0000000f
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_TEXTURE2						0x0000000a
+#define    NV10TCL_RC_IN_ALPHA_D_INPUT_TEXTURE3						0x0000000b
+#define   NV10TCL_RC_IN_ALPHA_D_COMPONENT_USAGE						(1 <<  4)
+#define    NV10TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV10TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_ALPHA					0x00000010
+#define   NV10TCL_RC_IN_ALPHA_D_MAPPING_SHIFT						5
+#define   NV10TCL_RC_IN_ALPHA_D_MAPPING_MASK						0x000000e0
+#define    NV10TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_INVERT				0x00000020
+#define    NV10TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NORMAL					0x00000040
+#define    NV10TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NEGATE					0x00000060
+#define    NV10TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NORMAL				0x00000080
+#define    NV10TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NEGATE				0x000000a0
+#define    NV10TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_IDENTITY				0x000000c0
+#define    NV10TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_NEGATE					0x000000e0
+#define   NV10TCL_RC_IN_ALPHA_C_INPUT_SHIFT						8
+#define   NV10TCL_RC_IN_ALPHA_C_INPUT_MASK						0x00000f00
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_FOG						0x00000300
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_TEXTURE0						0x00000800
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_TEXTURE1						0x00000900
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_SPARE0						0x00000c00
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_SPARE1						0x00000d00
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_E_TIMES_F					0x00000f00
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_TEXTURE2						0x00000a00
+#define    NV10TCL_RC_IN_ALPHA_C_INPUT_TEXTURE3						0x00000b00
+#define   NV10TCL_RC_IN_ALPHA_C_COMPONENT_USAGE						(1 << 12)
+#define    NV10TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV10TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV10TCL_RC_IN_ALPHA_C_MAPPING_SHIFT						13
+#define   NV10TCL_RC_IN_ALPHA_C_MAPPING_MASK						0x0000e000
+#define    NV10TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_INVERT				0x00002000
+#define    NV10TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV10TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV10TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NORMAL				0x00008000
+#define    NV10TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NEGATE				0x0000a000
+#define    NV10TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_IDENTITY				0x0000c000
+#define    NV10TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV10TCL_RC_IN_ALPHA_B_INPUT_SHIFT						16
+#define   NV10TCL_RC_IN_ALPHA_B_INPUT_MASK						0x000f0000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_FOG						0x00030000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_TEXTURE0						0x00080000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_TEXTURE1						0x00090000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_SPARE0						0x000c0000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_SPARE1						0x000d0000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_E_TIMES_F					0x000f0000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_TEXTURE2						0x000a0000
+#define    NV10TCL_RC_IN_ALPHA_B_INPUT_TEXTURE3						0x000b0000
+#define   NV10TCL_RC_IN_ALPHA_B_COMPONENT_USAGE						(1 << 20)
+#define    NV10TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV10TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV10TCL_RC_IN_ALPHA_B_MAPPING_SHIFT						21
+#define   NV10TCL_RC_IN_ALPHA_B_MAPPING_MASK						0x00e00000
+#define    NV10TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_INVERT				0x00200000
+#define    NV10TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV10TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV10TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NORMAL				0x00800000
+#define    NV10TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NEGATE				0x00a00000
+#define    NV10TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_IDENTITY				0x00c00000
+#define    NV10TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV10TCL_RC_IN_ALPHA_A_INPUT_SHIFT						24
+#define   NV10TCL_RC_IN_ALPHA_A_INPUT_MASK						0x0f000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_FOG						0x03000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_TEXTURE0						0x08000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_TEXTURE1						0x09000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_SPARE0						0x0c000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_SPARE1						0x0d000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_E_TIMES_F					0x0f000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_TEXTURE2						0x0a000000
+#define    NV10TCL_RC_IN_ALPHA_A_INPUT_TEXTURE3						0x0b000000
+#define   NV10TCL_RC_IN_ALPHA_A_COMPONENT_USAGE						(1 << 28)
+#define    NV10TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV10TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV10TCL_RC_IN_ALPHA_A_MAPPING_SHIFT						29
+#define   NV10TCL_RC_IN_ALPHA_A_MAPPING_MASK						0xe0000000
+#define    NV10TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_INVERT				0x20000000
+#define    NV10TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV10TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV10TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NORMAL				0x80000000
+#define    NV10TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NEGATE				0xa0000000
+#define    NV10TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_IDENTITY				0xc0000000
+#define    NV10TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV10TCL_RC_IN_RGB(x)								(0x00000268+((x)*4))
+#define  NV10TCL_RC_IN_RGB__SIZE							0x00000002
+#define   NV10TCL_RC_IN_RGB_D_INPUT_SHIFT						0
+#define   NV10TCL_RC_IN_RGB_D_INPUT_MASK						0x0000000f
+#define    NV10TCL_RC_IN_RGB_D_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR0					0x00000001
+#define    NV10TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR1					0x00000002
+#define    NV10TCL_RC_IN_RGB_D_INPUT_FOG						0x00000003
+#define    NV10TCL_RC_IN_RGB_D_INPUT_PRIMARY_COLOR					0x00000004
+#define    NV10TCL_RC_IN_RGB_D_INPUT_SECONDARY_COLOR					0x00000005
+#define    NV10TCL_RC_IN_RGB_D_INPUT_TEXTURE0						0x00000008
+#define    NV10TCL_RC_IN_RGB_D_INPUT_TEXTURE1						0x00000009
+#define    NV10TCL_RC_IN_RGB_D_INPUT_SPARE0						0x0000000c
+#define    NV10TCL_RC_IN_RGB_D_INPUT_SPARE1						0x0000000d
+#define    NV10TCL_RC_IN_RGB_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV10TCL_RC_IN_RGB_D_INPUT_E_TIMES_F						0x0000000f
+#define    NV10TCL_RC_IN_RGB_D_INPUT_TEXTURE2						0x0000000a
+#define    NV10TCL_RC_IN_RGB_D_INPUT_TEXTURE3						0x0000000b
+#define   NV10TCL_RC_IN_RGB_D_COMPONENT_USAGE						(1 <<  4)
+#define    NV10TCL_RC_IN_RGB_D_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_IN_RGB_D_COMPONENT_USAGE_ALPHA					0x00000010
+#define   NV10TCL_RC_IN_RGB_D_MAPPING_SHIFT						5
+#define   NV10TCL_RC_IN_RGB_D_MAPPING_MASK						0x000000e0
+#define    NV10TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_INVERT					0x00000020
+#define    NV10TCL_RC_IN_RGB_D_MAPPING_EXPAND_NORMAL					0x00000040
+#define    NV10TCL_RC_IN_RGB_D_MAPPING_EXPAND_NEGATE					0x00000060
+#define    NV10TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NORMAL					0x00000080
+#define    NV10TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NEGATE					0x000000a0
+#define    NV10TCL_RC_IN_RGB_D_MAPPING_SIGNED_IDENTITY					0x000000c0
+#define    NV10TCL_RC_IN_RGB_D_MAPPING_SIGNED_NEGATE					0x000000e0
+#define   NV10TCL_RC_IN_RGB_C_INPUT_SHIFT						8
+#define   NV10TCL_RC_IN_RGB_C_INPUT_MASK						0x00000f00
+#define    NV10TCL_RC_IN_RGB_C_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV10TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV10TCL_RC_IN_RGB_C_INPUT_FOG						0x00000300
+#define    NV10TCL_RC_IN_RGB_C_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV10TCL_RC_IN_RGB_C_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV10TCL_RC_IN_RGB_C_INPUT_TEXTURE0						0x00000800
+#define    NV10TCL_RC_IN_RGB_C_INPUT_TEXTURE1						0x00000900
+#define    NV10TCL_RC_IN_RGB_C_INPUT_SPARE0						0x00000c00
+#define    NV10TCL_RC_IN_RGB_C_INPUT_SPARE1						0x00000d00
+#define    NV10TCL_RC_IN_RGB_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV10TCL_RC_IN_RGB_C_INPUT_E_TIMES_F						0x00000f00
+#define    NV10TCL_RC_IN_RGB_C_INPUT_TEXTURE2						0x00000a00
+#define    NV10TCL_RC_IN_RGB_C_INPUT_TEXTURE3						0x00000b00
+#define   NV10TCL_RC_IN_RGB_C_COMPONENT_USAGE						(1 << 12)
+#define    NV10TCL_RC_IN_RGB_C_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_IN_RGB_C_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV10TCL_RC_IN_RGB_C_MAPPING_SHIFT						13
+#define   NV10TCL_RC_IN_RGB_C_MAPPING_MASK						0x0000e000
+#define    NV10TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_INVERT					0x00002000
+#define    NV10TCL_RC_IN_RGB_C_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV10TCL_RC_IN_RGB_C_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV10TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NORMAL					0x00008000
+#define    NV10TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NEGATE					0x0000a000
+#define    NV10TCL_RC_IN_RGB_C_MAPPING_SIGNED_IDENTITY					0x0000c000
+#define    NV10TCL_RC_IN_RGB_C_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV10TCL_RC_IN_RGB_B_INPUT_SHIFT						16
+#define   NV10TCL_RC_IN_RGB_B_INPUT_MASK						0x000f0000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_FOG						0x00030000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_TEXTURE0						0x00080000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_TEXTURE1						0x00090000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_SPARE0						0x000c0000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_SPARE1						0x000d0000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_E_TIMES_F						0x000f0000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_TEXTURE2						0x000a0000
+#define    NV10TCL_RC_IN_RGB_B_INPUT_TEXTURE3						0x000b0000
+#define   NV10TCL_RC_IN_RGB_B_COMPONENT_USAGE						(1 << 20)
+#define    NV10TCL_RC_IN_RGB_B_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_IN_RGB_B_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV10TCL_RC_IN_RGB_B_MAPPING_SHIFT						21
+#define   NV10TCL_RC_IN_RGB_B_MAPPING_MASK						0x00e00000
+#define    NV10TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_INVERT					0x00200000
+#define    NV10TCL_RC_IN_RGB_B_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV10TCL_RC_IN_RGB_B_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV10TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NORMAL					0x00800000
+#define    NV10TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NEGATE					0x00a00000
+#define    NV10TCL_RC_IN_RGB_B_MAPPING_SIGNED_IDENTITY					0x00c00000
+#define    NV10TCL_RC_IN_RGB_B_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV10TCL_RC_IN_RGB_A_INPUT_SHIFT						24
+#define   NV10TCL_RC_IN_RGB_A_INPUT_MASK						0x0f000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_FOG						0x03000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_TEXTURE0						0x08000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_TEXTURE1						0x09000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_SPARE0						0x0c000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_SPARE1						0x0d000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_E_TIMES_F						0x0f000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_TEXTURE2						0x0a000000
+#define    NV10TCL_RC_IN_RGB_A_INPUT_TEXTURE3						0x0b000000
+#define   NV10TCL_RC_IN_RGB_A_COMPONENT_USAGE						(1 << 28)
+#define    NV10TCL_RC_IN_RGB_A_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_IN_RGB_A_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV10TCL_RC_IN_RGB_A_MAPPING_SHIFT						29
+#define   NV10TCL_RC_IN_RGB_A_MAPPING_MASK						0xe0000000
+#define    NV10TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_INVERT					0x20000000
+#define    NV10TCL_RC_IN_RGB_A_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV10TCL_RC_IN_RGB_A_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV10TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NORMAL					0x80000000
+#define    NV10TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NEGATE					0xa0000000
+#define    NV10TCL_RC_IN_RGB_A_MAPPING_SIGNED_IDENTITY					0xc0000000
+#define    NV10TCL_RC_IN_RGB_A_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV10TCL_RC_COLOR(x)								(0x00000270+((x)*4))
+#define  NV10TCL_RC_COLOR__SIZE								0x00000002
+#define   NV10TCL_RC_COLOR_B_SHIFT							0
+#define   NV10TCL_RC_COLOR_B_MASK							0x000000ff
+#define   NV10TCL_RC_COLOR_G_SHIFT							8
+#define   NV10TCL_RC_COLOR_G_MASK							0x0000ff00
+#define   NV10TCL_RC_COLOR_R_SHIFT							16
+#define   NV10TCL_RC_COLOR_R_MASK							0x00ff0000
+#define   NV10TCL_RC_COLOR_A_SHIFT							24
+#define   NV10TCL_RC_COLOR_A_MASK							0xff000000
+#define  NV10TCL_RC_OUT_ALPHA(x)							(0x00000278+((x)*4))
+#define  NV10TCL_RC_OUT_ALPHA__SIZE							0x00000002
+#define   NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SHIFT						0
+#define   NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_MASK						0x0000000f
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_ZERO						0x00000000
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR0				0x00000001
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR1				0x00000002
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_FOG						0x00000003
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_PRIMARY_COLOR					0x00000004
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SECONDARY_COLOR				0x00000005
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE0					0x00000008
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE1					0x00000009
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0					0x0000000c
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE1					0x0000000d
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_E_TIMES_F					0x0000000f
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE2					0x0000000a
+#define    NV10TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE3					0x0000000b
+#define   NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SHIFT						4
+#define   NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_MASK						0x000000f0
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_ZERO						0x00000000
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR0				0x00000010
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR1				0x00000020
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_FOG						0x00000030
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_PRIMARY_COLOR					0x00000040
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SECONDARY_COLOR				0x00000050
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE0					0x00000080
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE1					0x00000090
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0					0x000000c0
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE1					0x000000d0
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000000e0
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_E_TIMES_F					0x000000f0
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE2					0x000000a0
+#define    NV10TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE3					0x000000b0
+#define   NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SHIFT						8
+#define   NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_MASK						0x00000f00
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_ZERO						0x00000000
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR0				0x00000100
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR1				0x00000200
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_FOG						0x00000300
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_PRIMARY_COLOR				0x00000400
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SECONDARY_COLOR				0x00000500
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE0					0x00000800
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE1					0x00000900
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0					0x00000c00
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE1					0x00000d00
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_E_TIMES_F					0x00000f00
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE2					0x00000a00
+#define    NV10TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE3					0x00000b00
+#define   NV10TCL_RC_OUT_ALPHA_CD_DOT_PRODUCT						(1 << 12)
+#define   NV10TCL_RC_OUT_ALPHA_AB_DOT_PRODUCT						(1 << 13)
+#define   NV10TCL_RC_OUT_ALPHA_MUX_SUM							(1 << 14)
+#define   NV10TCL_RC_OUT_ALPHA_BIAS							(1 << 15)
+#define    NV10TCL_RC_OUT_ALPHA_BIAS_NONE						0x00000000
+#define    NV10TCL_RC_OUT_ALPHA_BIAS_BIAS_BY_NEGATIVE_ONE_HALF				0x00008000
+#define   NV10TCL_RC_OUT_ALPHA_SCALE_SHIFT						17
+#define   NV10TCL_RC_OUT_ALPHA_SCALE_MASK						0x00000000
+#define    NV10TCL_RC_OUT_ALPHA_SCALE_NONE						0x00000000
+#define    NV10TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_TWO					0x00020000
+#define    NV10TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_FOUR					0x00040000
+#define    NV10TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_ONE_HALF					0x00060000
+#define  NV10TCL_RC_OUT_RGB(x)								(0x00000280+((x)*4))
+#define  NV10TCL_RC_OUT_RGB__SIZE							0x00000002
+#define   NV10TCL_RC_OUT_RGB_CD_OUTPUT_SHIFT						0
+#define   NV10TCL_RC_OUT_RGB_CD_OUTPUT_MASK						0x0000000f
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_ZERO						0x00000000
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR0					0x00000001
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR1					0x00000002
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_FOG						0x00000003
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_PRIMARY_COLOR					0x00000004
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_SECONDARY_COLOR					0x00000005
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE0					0x00000008
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE1					0x00000009
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0						0x0000000c
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_SPARE1						0x0000000d
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_E_TIMES_F					0x0000000f
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE2					0x0000000a
+#define    NV10TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE3					0x0000000b
+#define   NV10TCL_RC_OUT_RGB_AB_OUTPUT_SHIFT						4
+#define   NV10TCL_RC_OUT_RGB_AB_OUTPUT_MASK						0x000000f0
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_ZERO						0x00000000
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR0					0x00000010
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR1					0x00000020
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_FOG						0x00000030
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_PRIMARY_COLOR					0x00000040
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_SECONDARY_COLOR					0x00000050
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE0					0x00000080
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE1					0x00000090
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0						0x000000c0
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_SPARE1						0x000000d0
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000000e0
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_E_TIMES_F					0x000000f0
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE2					0x000000a0
+#define    NV10TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE3					0x000000b0
+#define   NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SHIFT						8
+#define   NV10TCL_RC_OUT_RGB_SUM_OUTPUT_MASK						0x00000f00
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_ZERO						0x00000000
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR0				0x00000100
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR1				0x00000200
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_FOG						0x00000300
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_PRIMARY_COLOR					0x00000400
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SECONDARY_COLOR				0x00000500
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE0					0x00000800
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE1					0x00000900
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0						0x00000c00
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE1						0x00000d00
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_E_TIMES_F					0x00000f00
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE2					0x00000a00
+#define    NV10TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE3					0x00000b00
+#define   NV10TCL_RC_OUT_RGB_CD_DOT_PRODUCT						(1 << 12)
+#define   NV10TCL_RC_OUT_RGB_AB_DOT_PRODUCT						(1 << 13)
+#define   NV10TCL_RC_OUT_RGB_MUX_SUM							(1 << 14)
+#define   NV10TCL_RC_OUT_RGB_BIAS							(1 << 15)
+#define    NV10TCL_RC_OUT_RGB_BIAS_NONE							0x00000000
+#define    NV10TCL_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF				0x00008000
+#define   NV10TCL_RC_OUT_RGB_SCALE_SHIFT						17
+#define   NV10TCL_RC_OUT_RGB_SCALE_MASK							0x00000000
+#define    NV10TCL_RC_OUT_RGB_SCALE_NONE						0x00000000
+#define    NV10TCL_RC_OUT_RGB_SCALE_SCALE_BY_TWO					0x00020000
+#define    NV10TCL_RC_OUT_RGB_SCALE_SCALE_BY_FOUR					0x00040000
+#define    NV10TCL_RC_OUT_RGB_SCALE_SCALE_BY_ONE_HALF					0x00060000
+#define   NV10TCL_RC_OUT_RGB_OPERATION_SHIFT						27
+#define   NV10TCL_RC_OUT_RGB_OPERATION_MASK						0x38000000
+#define  NV10TCL_RC_FINAL0								0x00000288
+#define   NV10TCL_RC_FINAL0_D_INPUT_SHIFT						0
+#define   NV10TCL_RC_FINAL0_D_INPUT_MASK						0x0000000f
+#define    NV10TCL_RC_FINAL0_D_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR0					0x00000001
+#define    NV10TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR1					0x00000002
+#define    NV10TCL_RC_FINAL0_D_INPUT_FOG						0x00000003
+#define    NV10TCL_RC_FINAL0_D_INPUT_PRIMARY_COLOR					0x00000004
+#define    NV10TCL_RC_FINAL0_D_INPUT_SECONDARY_COLOR					0x00000005
+#define    NV10TCL_RC_FINAL0_D_INPUT_TEXTURE0						0x00000008
+#define    NV10TCL_RC_FINAL0_D_INPUT_TEXTURE1						0x00000009
+#define    NV10TCL_RC_FINAL0_D_INPUT_SPARE0						0x0000000c
+#define    NV10TCL_RC_FINAL0_D_INPUT_SPARE1						0x0000000d
+#define    NV10TCL_RC_FINAL0_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV10TCL_RC_FINAL0_D_INPUT_E_TIMES_F						0x0000000f
+#define    NV10TCL_RC_FINAL0_D_INPUT_TEXTURE2						0x0000000a
+#define    NV10TCL_RC_FINAL0_D_INPUT_TEXTURE3						0x0000000b
+#define   NV10TCL_RC_FINAL0_D_COMPONENT_USAGE						(1 <<  4)
+#define    NV10TCL_RC_FINAL0_D_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_FINAL0_D_COMPONENT_USAGE_ALPHA					0x00000010
+#define   NV10TCL_RC_FINAL0_D_MAPPING_SHIFT						5
+#define   NV10TCL_RC_FINAL0_D_MAPPING_MASK						0x000000e0
+#define    NV10TCL_RC_FINAL0_D_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_FINAL0_D_MAPPING_UNSIGNED_INVERT					0x00000020
+#define    NV10TCL_RC_FINAL0_D_MAPPING_EXPAND_NORMAL					0x00000040
+#define    NV10TCL_RC_FINAL0_D_MAPPING_EXPAND_NEGATE					0x00000060
+#define    NV10TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NORMAL					0x00000080
+#define    NV10TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NEGATE					0x000000a0
+#define    NV10TCL_RC_FINAL0_D_MAPPING_SIGNED_IDENTITY					0x000000c0
+#define    NV10TCL_RC_FINAL0_D_MAPPING_SIGNED_NEGATE					0x000000e0
+#define   NV10TCL_RC_FINAL0_C_INPUT_SHIFT						8
+#define   NV10TCL_RC_FINAL0_C_INPUT_MASK						0x00000f00
+#define    NV10TCL_RC_FINAL0_C_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV10TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV10TCL_RC_FINAL0_C_INPUT_FOG						0x00000300
+#define    NV10TCL_RC_FINAL0_C_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV10TCL_RC_FINAL0_C_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV10TCL_RC_FINAL0_C_INPUT_TEXTURE0						0x00000800
+#define    NV10TCL_RC_FINAL0_C_INPUT_TEXTURE1						0x00000900
+#define    NV10TCL_RC_FINAL0_C_INPUT_SPARE0						0x00000c00
+#define    NV10TCL_RC_FINAL0_C_INPUT_SPARE1						0x00000d00
+#define    NV10TCL_RC_FINAL0_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV10TCL_RC_FINAL0_C_INPUT_E_TIMES_F						0x00000f00
+#define    NV10TCL_RC_FINAL0_C_INPUT_TEXTURE2						0x00000a00
+#define    NV10TCL_RC_FINAL0_C_INPUT_TEXTURE3						0x00000b00
+#define   NV10TCL_RC_FINAL0_C_COMPONENT_USAGE						(1 << 12)
+#define    NV10TCL_RC_FINAL0_C_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_FINAL0_C_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV10TCL_RC_FINAL0_C_MAPPING_SHIFT						13
+#define   NV10TCL_RC_FINAL0_C_MAPPING_MASK						0x0000e000
+#define    NV10TCL_RC_FINAL0_C_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_FINAL0_C_MAPPING_UNSIGNED_INVERT					0x00002000
+#define    NV10TCL_RC_FINAL0_C_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV10TCL_RC_FINAL0_C_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV10TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NORMAL					0x00008000
+#define    NV10TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NEGATE					0x0000a000
+#define    NV10TCL_RC_FINAL0_C_MAPPING_SIGNED_IDENTITY					0x0000c000
+#define    NV10TCL_RC_FINAL0_C_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV10TCL_RC_FINAL0_B_INPUT_SHIFT						16
+#define   NV10TCL_RC_FINAL0_B_INPUT_MASK						0x000f0000
+#define    NV10TCL_RC_FINAL0_B_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV10TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV10TCL_RC_FINAL0_B_INPUT_FOG						0x00030000
+#define    NV10TCL_RC_FINAL0_B_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV10TCL_RC_FINAL0_B_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV10TCL_RC_FINAL0_B_INPUT_TEXTURE0						0x00080000
+#define    NV10TCL_RC_FINAL0_B_INPUT_TEXTURE1						0x00090000
+#define    NV10TCL_RC_FINAL0_B_INPUT_SPARE0						0x000c0000
+#define    NV10TCL_RC_FINAL0_B_INPUT_SPARE1						0x000d0000
+#define    NV10TCL_RC_FINAL0_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV10TCL_RC_FINAL0_B_INPUT_E_TIMES_F						0x000f0000
+#define    NV10TCL_RC_FINAL0_B_INPUT_TEXTURE2						0x000a0000
+#define    NV10TCL_RC_FINAL0_B_INPUT_TEXTURE3						0x000b0000
+#define   NV10TCL_RC_FINAL0_B_COMPONENT_USAGE						(1 << 20)
+#define    NV10TCL_RC_FINAL0_B_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_FINAL0_B_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV10TCL_RC_FINAL0_B_MAPPING_SHIFT						21
+#define   NV10TCL_RC_FINAL0_B_MAPPING_MASK						0x00e00000
+#define    NV10TCL_RC_FINAL0_B_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_FINAL0_B_MAPPING_UNSIGNED_INVERT					0x00200000
+#define    NV10TCL_RC_FINAL0_B_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV10TCL_RC_FINAL0_B_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV10TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NORMAL					0x00800000
+#define    NV10TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NEGATE					0x00a00000
+#define    NV10TCL_RC_FINAL0_B_MAPPING_SIGNED_IDENTITY					0x00c00000
+#define    NV10TCL_RC_FINAL0_B_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV10TCL_RC_FINAL0_A_INPUT_SHIFT						24
+#define   NV10TCL_RC_FINAL0_A_INPUT_MASK						0x0f000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_FOG						0x03000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_TEXTURE0						0x08000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_TEXTURE1						0x09000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_SPARE0						0x0c000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_SPARE1						0x0d000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_E_TIMES_F						0x0f000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_TEXTURE2						0x0a000000
+#define    NV10TCL_RC_FINAL0_A_INPUT_TEXTURE3						0x0b000000
+#define   NV10TCL_RC_FINAL0_A_COMPONENT_USAGE						(1 << 28)
+#define    NV10TCL_RC_FINAL0_A_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_FINAL0_A_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV10TCL_RC_FINAL0_A_MAPPING_SHIFT						29
+#define   NV10TCL_RC_FINAL0_A_MAPPING_MASK						0xe0000000
+#define    NV10TCL_RC_FINAL0_A_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_FINAL0_A_MAPPING_UNSIGNED_INVERT					0x20000000
+#define    NV10TCL_RC_FINAL0_A_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV10TCL_RC_FINAL0_A_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV10TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NORMAL					0x80000000
+#define    NV10TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NEGATE					0xa0000000
+#define    NV10TCL_RC_FINAL0_A_MAPPING_SIGNED_IDENTITY					0xc0000000
+#define    NV10TCL_RC_FINAL0_A_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV10TCL_RC_FINAL1								0x0000028c
+#define   NV10TCL_RC_FINAL1_COLOR_SUM_CLAMP						(1 <<  7)
+#define   NV10TCL_RC_FINAL1_G_INPUT_SHIFT						8
+#define   NV10TCL_RC_FINAL1_G_INPUT_MASK						0x00000f00
+#define    NV10TCL_RC_FINAL1_G_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV10TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV10TCL_RC_FINAL1_G_INPUT_FOG						0x00000300
+#define    NV10TCL_RC_FINAL1_G_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV10TCL_RC_FINAL1_G_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV10TCL_RC_FINAL1_G_INPUT_TEXTURE0						0x00000800
+#define    NV10TCL_RC_FINAL1_G_INPUT_TEXTURE1						0x00000900
+#define    NV10TCL_RC_FINAL1_G_INPUT_SPARE0						0x00000c00
+#define    NV10TCL_RC_FINAL1_G_INPUT_SPARE1						0x00000d00
+#define    NV10TCL_RC_FINAL1_G_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV10TCL_RC_FINAL1_G_INPUT_E_TIMES_F						0x00000f00
+#define    NV10TCL_RC_FINAL1_G_INPUT_TEXTURE2						0x00000a00
+#define    NV10TCL_RC_FINAL1_G_INPUT_TEXTURE3						0x00000b00
+#define   NV10TCL_RC_FINAL1_G_COMPONENT_USAGE						(1 << 12)
+#define    NV10TCL_RC_FINAL1_G_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_FINAL1_G_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV10TCL_RC_FINAL1_G_MAPPING_SHIFT						13
+#define   NV10TCL_RC_FINAL1_G_MAPPING_MASK						0x0000e000
+#define    NV10TCL_RC_FINAL1_G_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_FINAL1_G_MAPPING_UNSIGNED_INVERT					0x00002000
+#define    NV10TCL_RC_FINAL1_G_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV10TCL_RC_FINAL1_G_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV10TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NORMAL					0x00008000
+#define    NV10TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NEGATE					0x0000a000
+#define    NV10TCL_RC_FINAL1_G_MAPPING_SIGNED_IDENTITY					0x0000c000
+#define    NV10TCL_RC_FINAL1_G_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV10TCL_RC_FINAL1_F_INPUT_SHIFT						16
+#define   NV10TCL_RC_FINAL1_F_INPUT_MASK						0x000f0000
+#define    NV10TCL_RC_FINAL1_F_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV10TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV10TCL_RC_FINAL1_F_INPUT_FOG						0x00030000
+#define    NV10TCL_RC_FINAL1_F_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV10TCL_RC_FINAL1_F_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV10TCL_RC_FINAL1_F_INPUT_TEXTURE0						0x00080000
+#define    NV10TCL_RC_FINAL1_F_INPUT_TEXTURE1						0x00090000
+#define    NV10TCL_RC_FINAL1_F_INPUT_SPARE0						0x000c0000
+#define    NV10TCL_RC_FINAL1_F_INPUT_SPARE1						0x000d0000
+#define    NV10TCL_RC_FINAL1_F_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV10TCL_RC_FINAL1_F_INPUT_E_TIMES_F						0x000f0000
+#define    NV10TCL_RC_FINAL1_F_INPUT_TEXTURE2						0x000a0000
+#define    NV10TCL_RC_FINAL1_F_INPUT_TEXTURE3						0x000b0000
+#define   NV10TCL_RC_FINAL1_F_COMPONENT_USAGE						(1 << 20)
+#define    NV10TCL_RC_FINAL1_F_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_FINAL1_F_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV10TCL_RC_FINAL1_F_MAPPING_SHIFT						21
+#define   NV10TCL_RC_FINAL1_F_MAPPING_MASK						0x00e00000
+#define    NV10TCL_RC_FINAL1_F_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_FINAL1_F_MAPPING_UNSIGNED_INVERT					0x00200000
+#define    NV10TCL_RC_FINAL1_F_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV10TCL_RC_FINAL1_F_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV10TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NORMAL					0x00800000
+#define    NV10TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NEGATE					0x00a00000
+#define    NV10TCL_RC_FINAL1_F_MAPPING_SIGNED_IDENTITY					0x00c00000
+#define    NV10TCL_RC_FINAL1_F_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV10TCL_RC_FINAL1_E_INPUT_SHIFT						24
+#define   NV10TCL_RC_FINAL1_E_INPUT_MASK						0x0f000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_ZERO						0x00000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_FOG						0x03000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_TEXTURE0						0x08000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_TEXTURE1						0x09000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_SPARE0						0x0c000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_SPARE1						0x0d000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_E_TIMES_F						0x0f000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_TEXTURE2						0x0a000000
+#define    NV10TCL_RC_FINAL1_E_INPUT_TEXTURE3						0x0b000000
+#define   NV10TCL_RC_FINAL1_E_COMPONENT_USAGE						(1 << 28)
+#define    NV10TCL_RC_FINAL1_E_COMPONENT_USAGE_RGB					0x00000000
+#define    NV10TCL_RC_FINAL1_E_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV10TCL_RC_FINAL1_E_MAPPING_SHIFT						29
+#define   NV10TCL_RC_FINAL1_E_MAPPING_MASK						0xe0000000
+#define    NV10TCL_RC_FINAL1_E_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV10TCL_RC_FINAL1_E_MAPPING_UNSIGNED_INVERT					0x20000000
+#define    NV10TCL_RC_FINAL1_E_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV10TCL_RC_FINAL1_E_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV10TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NORMAL					0x80000000
+#define    NV10TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NEGATE					0xa0000000
+#define    NV10TCL_RC_FINAL1_E_MAPPING_SIGNED_IDENTITY					0xc0000000
+#define    NV10TCL_RC_FINAL1_E_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV10TCL_LIGHT_MODEL								0x00000294
+#define   NV10TCL_LIGHT_MODEL_VERTEX_SPECULAR						(1 <<  0)
+#define   NV10TCL_LIGHT_MODEL_SEPARATE_SPECULAR						(1 <<  1)
+#define   NV10TCL_LIGHT_MODEL_LOCAL_VIEWER						(1 << 16)
+#define  NV10TCL_COLOR_MATERIAL								0x00000298
+#define   NV10TCL_COLOR_MATERIAL_EMISSION						(1 <<  0)
+#define   NV10TCL_COLOR_MATERIAL_AMBIENT						(1 <<  1)
+#define   NV10TCL_COLOR_MATERIAL_DIFFUSE						(1 <<  2)
+#define   NV10TCL_COLOR_MATERIAL_SPECULAR						(1 <<  3)
+#define  NV10TCL_FOG_MODE								0x0000029c
+#define   NV10TCL_FOG_MODE_LINEAR							0x00002601
+#define   NV10TCL_FOG_MODE_EXP								0x00000800
+#define   NV10TCL_FOG_MODE_EXP_ABS							0x00000802
+#define   NV10TCL_FOG_MODE_EXP2								0x00000803
+#define  NV10TCL_FOG_COORD								0x000002a0
+#define   NV10TCL_FOG_COORD_FOG								0x00000000
+#define   NV10TCL_FOG_COORD_DIST_RADIAL							0x00000001
+#define   NV10TCL_FOG_COORD_DIST_ORTHOGONAL						0x00000002
+#define   NV10TCL_FOG_COORD_DIST_ORTHOGONAL_ABS						0x00000003
+#define  NV10TCL_FOG_ENABLE								0x000002a4
+#define  NV10TCL_FOG_COLOR								0x000002a8
+#define   NV10TCL_FOG_COLOR_R_SHIFT							0
+#define   NV10TCL_FOG_COLOR_R_MASK							0x000000ff
+#define   NV10TCL_FOG_COLOR_G_SHIFT							8
+#define   NV10TCL_FOG_COLOR_G_MASK							0x0000ff00
+#define   NV10TCL_FOG_COLOR_B_SHIFT							16
+#define   NV10TCL_FOG_COLOR_B_MASK							0x00ff0000
+#define   NV10TCL_FOG_COLOR_A_SHIFT							24
+#define   NV10TCL_FOG_COLOR_A_MASK							0xff000000
+#define  NV10TCL_VIEWPORT_CLIP_MODE							0x000002b4
+#define  NV10TCL_VIEWPORT_CLIP_HORIZ(x)							(0x000002c0+((x)*4))
+#define  NV10TCL_VIEWPORT_CLIP_HORIZ__SIZE						0x00000008
+#define   NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_L_SHIFT					0
+#define   NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_L_MASK					0x000007ff
+#define   NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_LEFT_ENABLE					(1 << 11)
+#define   NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_R_SHIFT					16
+#define   NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_R_MASK					0x07ff0000
+#define   NV10TCL_VIEWPORT_CLIP_HORIZ_CLIP_RIGHT_ENABLE					(1 << 27)
+#define  NV10TCL_VIEWPORT_CLIP_VERT(x)							(0x000002e0+((x)*4))
+#define  NV10TCL_VIEWPORT_CLIP_VERT__SIZE						0x00000008
+#define   NV10TCL_VIEWPORT_CLIP_VERT_CLIP_T_SHIFT					0
+#define   NV10TCL_VIEWPORT_CLIP_VERT_CLIP_T_MASK					0x000007ff
+#define   NV10TCL_VIEWPORT_CLIP_VERT_CLIP_TOP_ENABLE					(1 << 11)
+#define   NV10TCL_VIEWPORT_CLIP_VERT_CLIP_B_SHIFT					16
+#define   NV10TCL_VIEWPORT_CLIP_VERT_CLIP_B_MASK					0x07ff0000
+#define   NV10TCL_VIEWPORT_CLIP_VERT_CLIP_BOTTOM_ENABLE					(1 << 27)
+#define  NV10TCL_ALPHA_FUNC_ENABLE							0x00000300
+#define  NV10TCL_BLEND_FUNC_ENABLE							0x00000304
+#define  NV10TCL_CULL_FACE_ENABLE							0x00000308
+#define  NV10TCL_DEPTH_TEST_ENABLE							0x0000030c
+#define  NV10TCL_DITHER_ENABLE								0x00000310
+#define  NV10TCL_LIGHTING_ENABLE							0x00000314
+#define  NV10TCL_POINT_PARAMETERS_ENABLE						0x00000318
+#define  NV10TCL_POINT_SMOOTH_ENABLE							0x0000031c
+#define  NV10TCL_LINE_SMOOTH_ENABLE							0x00000320
+#define  NV10TCL_POLYGON_SMOOTH_ENABLE							0x00000324
+#define  NV10TCL_VERTEX_WEIGHT_ENABLE							0x00000328
+#define  NV10TCL_STENCIL_ENABLE								0x0000032c
+#define  NV10TCL_POLYGON_OFFSET_POINT_ENABLE						0x00000330
+#define  NV10TCL_POLYGON_OFFSET_LINE_ENABLE						0x00000334
+#define  NV10TCL_POLYGON_OFFSET_FILL_ENABLE						0x00000338
+#define  NV10TCL_ALPHA_FUNC_FUNC							0x0000033c
+#define   NV10TCL_ALPHA_FUNC_FUNC_NEVER							0x00000200
+#define   NV10TCL_ALPHA_FUNC_FUNC_LESS							0x00000201
+#define   NV10TCL_ALPHA_FUNC_FUNC_EQUAL							0x00000202
+#define   NV10TCL_ALPHA_FUNC_FUNC_LEQUAL						0x00000203
+#define   NV10TCL_ALPHA_FUNC_FUNC_GREATER						0x00000204
+#define   NV10TCL_ALPHA_FUNC_FUNC_NOTEQUAL						0x00000205
+#define   NV10TCL_ALPHA_FUNC_FUNC_GEQUAL						0x00000206
+#define   NV10TCL_ALPHA_FUNC_FUNC_ALWAYS						0x00000207
+#define  NV10TCL_ALPHA_FUNC_REF								0x00000340
+#define  NV10TCL_BLEND_FUNC_SRC								0x00000344
+#define   NV10TCL_BLEND_FUNC_SRC_ZERO							0x00000000
+#define   NV10TCL_BLEND_FUNC_SRC_ONE							0x00000001
+#define   NV10TCL_BLEND_FUNC_SRC_SRC_COLOR						0x00000300
+#define   NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_SRC_COLOR					0x00000301
+#define   NV10TCL_BLEND_FUNC_SRC_SRC_ALPHA						0x00000302
+#define   NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_SRC_ALPHA					0x00000303
+#define   NV10TCL_BLEND_FUNC_SRC_DST_ALPHA						0x00000304
+#define   NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_DST_ALPHA					0x00000305
+#define   NV10TCL_BLEND_FUNC_SRC_DST_COLOR						0x00000306
+#define   NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_DST_COLOR					0x00000307
+#define   NV10TCL_BLEND_FUNC_SRC_SRC_ALPHA_SATURATE					0x00000308
+#define   NV10TCL_BLEND_FUNC_SRC_CONSTANT_COLOR						0x00008001
+#define   NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define   NV10TCL_BLEND_FUNC_SRC_CONSTANT_ALPHA						0x00008003
+#define   NV10TCL_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define  NV10TCL_BLEND_FUNC_DST								0x00000348
+#define   NV10TCL_BLEND_FUNC_DST_ZERO							0x00000000
+#define   NV10TCL_BLEND_FUNC_DST_ONE							0x00000001
+#define   NV10TCL_BLEND_FUNC_DST_SRC_COLOR						0x00000300
+#define   NV10TCL_BLEND_FUNC_DST_ONE_MINUS_SRC_COLOR					0x00000301
+#define   NV10TCL_BLEND_FUNC_DST_SRC_ALPHA						0x00000302
+#define   NV10TCL_BLEND_FUNC_DST_ONE_MINUS_SRC_ALPHA					0x00000303
+#define   NV10TCL_BLEND_FUNC_DST_DST_ALPHA						0x00000304
+#define   NV10TCL_BLEND_FUNC_DST_ONE_MINUS_DST_ALPHA					0x00000305
+#define   NV10TCL_BLEND_FUNC_DST_DST_COLOR						0x00000306
+#define   NV10TCL_BLEND_FUNC_DST_ONE_MINUS_DST_COLOR					0x00000307
+#define   NV10TCL_BLEND_FUNC_DST_SRC_ALPHA_SATURATE					0x00000308
+#define   NV10TCL_BLEND_FUNC_DST_CONSTANT_COLOR						0x00008001
+#define   NV10TCL_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define   NV10TCL_BLEND_FUNC_DST_CONSTANT_ALPHA						0x00008003
+#define   NV10TCL_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define  NV10TCL_BLEND_COLOR								0x0000034c
+#define   NV10TCL_BLEND_COLOR_B_SHIFT							0
+#define   NV10TCL_BLEND_COLOR_B_MASK							0x000000ff
+#define   NV10TCL_BLEND_COLOR_G_SHIFT							8
+#define   NV10TCL_BLEND_COLOR_G_MASK							0x0000ff00
+#define   NV10TCL_BLEND_COLOR_R_SHIFT							16
+#define   NV10TCL_BLEND_COLOR_R_MASK							0x00ff0000
+#define   NV10TCL_BLEND_COLOR_A_SHIFT							24
+#define   NV10TCL_BLEND_COLOR_A_MASK							0xff000000
+#define  NV10TCL_BLEND_EQUATION								0x00000350
+#define   NV10TCL_BLEND_EQUATION_FUNC_ADD						0x00008006
+#define   NV10TCL_BLEND_EQUATION_MIN							0x00008007
+#define   NV10TCL_BLEND_EQUATION_MAX							0x00008008
+#define   NV10TCL_BLEND_EQUATION_FUNC_SUBTRACT						0x0000800a
+#define   NV10TCL_BLEND_EQUATION_FUNC_REVERSE_SUBTRACT					0x0000800b
+#define  NV10TCL_DEPTH_FUNC								0x00000354
+#define   NV10TCL_DEPTH_FUNC_NEVER							0x00000200
+#define   NV10TCL_DEPTH_FUNC_LESS							0x00000201
+#define   NV10TCL_DEPTH_FUNC_EQUAL							0x00000202
+#define   NV10TCL_DEPTH_FUNC_LEQUAL							0x00000203
+#define   NV10TCL_DEPTH_FUNC_GREATER							0x00000204
+#define   NV10TCL_DEPTH_FUNC_NOTEQUAL							0x00000205
+#define   NV10TCL_DEPTH_FUNC_GEQUAL							0x00000206
+#define   NV10TCL_DEPTH_FUNC_ALWAYS							0x00000207
+#define  NV10TCL_COLOR_MASK								0x00000358
+#define   NV10TCL_COLOR_MASK_B								(1 <<  0)
+#define   NV10TCL_COLOR_MASK_G								(1 <<  8)
+#define   NV10TCL_COLOR_MASK_R								(1 << 16)
+#define   NV10TCL_COLOR_MASK_A								(1 << 24)
+#define  NV10TCL_DEPTH_WRITE_ENABLE							0x0000035c
+#define  NV10TCL_STENCIL_MASK								0x00000360
+#define  NV10TCL_STENCIL_FUNC_FUNC							0x00000364
+#define   NV10TCL_STENCIL_FUNC_FUNC_NEVER						0x00000200
+#define   NV10TCL_STENCIL_FUNC_FUNC_LESS						0x00000201
+#define   NV10TCL_STENCIL_FUNC_FUNC_EQUAL						0x00000202
+#define   NV10TCL_STENCIL_FUNC_FUNC_LEQUAL						0x00000203
+#define   NV10TCL_STENCIL_FUNC_FUNC_GREATER						0x00000204
+#define   NV10TCL_STENCIL_FUNC_FUNC_NOTEQUAL						0x00000205
+#define   NV10TCL_STENCIL_FUNC_FUNC_GEQUAL						0x00000206
+#define   NV10TCL_STENCIL_FUNC_FUNC_ALWAYS						0x00000207
+#define  NV10TCL_STENCIL_FUNC_REF							0x00000368
+#define  NV10TCL_STENCIL_FUNC_MASK							0x0000036c
+#define  NV10TCL_STENCIL_OP_FAIL							0x00000370
+#define   NV10TCL_STENCIL_OP_FAIL_ZERO							0x00000000
+#define   NV10TCL_STENCIL_OP_FAIL_INVERT						0x0000150a
+#define   NV10TCL_STENCIL_OP_FAIL_KEEP							0x00001e00
+#define   NV10TCL_STENCIL_OP_FAIL_REPLACE						0x00001e01
+#define   NV10TCL_STENCIL_OP_FAIL_INCR							0x00001e02
+#define   NV10TCL_STENCIL_OP_FAIL_DECR							0x00001e03
+#define   NV10TCL_STENCIL_OP_FAIL_INCR_WRAP						0x00008507
+#define   NV10TCL_STENCIL_OP_FAIL_DECR_WRAP						0x00008508
+#define  NV10TCL_STENCIL_OP_ZFAIL							0x00000374
+#define   NV10TCL_STENCIL_OP_ZFAIL_ZERO							0x00000000
+#define   NV10TCL_STENCIL_OP_ZFAIL_INVERT						0x0000150a
+#define   NV10TCL_STENCIL_OP_ZFAIL_KEEP							0x00001e00
+#define   NV10TCL_STENCIL_OP_ZFAIL_REPLACE						0x00001e01
+#define   NV10TCL_STENCIL_OP_ZFAIL_INCR							0x00001e02
+#define   NV10TCL_STENCIL_OP_ZFAIL_DECR							0x00001e03
+#define   NV10TCL_STENCIL_OP_ZFAIL_INCR_WRAP						0x00008507
+#define   NV10TCL_STENCIL_OP_ZFAIL_DECR_WRAP						0x00008508
+#define  NV10TCL_STENCIL_OP_ZPASS							0x00000378
+#define   NV10TCL_STENCIL_OP_ZPASS_ZERO							0x00000000
+#define   NV10TCL_STENCIL_OP_ZPASS_INVERT						0x0000150a
+#define   NV10TCL_STENCIL_OP_ZPASS_KEEP							0x00001e00
+#define   NV10TCL_STENCIL_OP_ZPASS_REPLACE						0x00001e01
+#define   NV10TCL_STENCIL_OP_ZPASS_INCR							0x00001e02
+#define   NV10TCL_STENCIL_OP_ZPASS_DECR							0x00001e03
+#define   NV10TCL_STENCIL_OP_ZPASS_INCR_WRAP						0x00008507
+#define   NV10TCL_STENCIL_OP_ZPASS_DECR_WRAP						0x00008508
+#define  NV10TCL_SHADE_MODEL								0x0000037c
+#define   NV10TCL_SHADE_MODEL_FLAT							0x00001d00
+#define   NV10TCL_SHADE_MODEL_SMOOTH							0x00001d01
+#define  NV10TCL_LINE_WIDTH								0x00000380
+#define  NV10TCL_POLYGON_OFFSET_FACTOR							0x00000384
+#define  NV10TCL_POLYGON_OFFSET_UNITS							0x00000388
+#define  NV10TCL_POLYGON_MODE_FRONT							0x0000038c
+#define   NV10TCL_POLYGON_MODE_FRONT_POINT						0x00001b00
+#define   NV10TCL_POLYGON_MODE_FRONT_LINE						0x00001b01
+#define   NV10TCL_POLYGON_MODE_FRONT_FILL						0x00001b02
+#define  NV10TCL_POLYGON_MODE_BACK							0x00000390
+#define   NV10TCL_POLYGON_MODE_BACK_POINT						0x00001b00
+#define   NV10TCL_POLYGON_MODE_BACK_LINE						0x00001b01
+#define   NV10TCL_POLYGON_MODE_BACK_FILL						0x00001b02
+#define  NV10TCL_DEPTH_RANGE_NEAR							0x00000394
+#define  NV10TCL_DEPTH_RANGE_FAR							0x00000398
+#define  NV10TCL_CULL_FACE								0x0000039c
+#define   NV10TCL_CULL_FACE_FRONT							0x00000404
+#define   NV10TCL_CULL_FACE_BACK							0x00000405
+#define   NV10TCL_CULL_FACE_FRONT_AND_BACK						0x00000408
+#define  NV10TCL_FRONT_FACE								0x000003a0
+#define   NV10TCL_FRONT_FACE_CW								0x00000900
+#define   NV10TCL_FRONT_FACE_CCW							0x00000901
+#define  NV10TCL_NORMALIZE_ENABLE							0x000003a4
+#define  NV10TCL_MATERIAL_FACTOR_R							0x000003a8
+#define  NV10TCL_MATERIAL_FACTOR_G							0x000003ac
+#define  NV10TCL_MATERIAL_FACTOR_B							0x000003b0
+#define  NV10TCL_MATERIAL_FACTOR_A							0x000003b4
+#define  NV10TCL_SEPARATE_SPECULAR_ENABLE						0x000003b8
+#define  NV10TCL_ENABLED_LIGHTS								0x000003bc
+#define   NV10TCL_ENABLED_LIGHTS_0_SHIFT						0
+#define   NV10TCL_ENABLED_LIGHTS_0_MASK							0x00000003
+#define    NV10TCL_ENABLED_LIGHTS_0_DISABLED						0x00000000
+#define    NV10TCL_ENABLED_LIGHTS_0_NONPOSITIONAL					0x00000001
+#define    NV10TCL_ENABLED_LIGHTS_0_POSITIONAL						0x00000002
+#define    NV10TCL_ENABLED_LIGHTS_0_DIRECTIONAL						0x00000003
+#define   NV10TCL_ENABLED_LIGHTS_1_SHIFT						2
+#define   NV10TCL_ENABLED_LIGHTS_1_MASK							0x0000000c
+#define    NV10TCL_ENABLED_LIGHTS_1_DISABLED						0x00000000
+#define    NV10TCL_ENABLED_LIGHTS_1_NONPOSITIONAL					0x00000004
+#define    NV10TCL_ENABLED_LIGHTS_1_POSITIONAL						0x00000008
+#define    NV10TCL_ENABLED_LIGHTS_1_DIRECTIONAL						0x0000000c
+#define   NV10TCL_ENABLED_LIGHTS_2_SHIFT						4
+#define   NV10TCL_ENABLED_LIGHTS_2_MASK							0x00000030
+#define    NV10TCL_ENABLED_LIGHTS_2_DISABLED						0x00000000
+#define    NV10TCL_ENABLED_LIGHTS_2_NONPOSITIONAL					0x00000010
+#define    NV10TCL_ENABLED_LIGHTS_2_POSITIONAL						0x00000020
+#define    NV10TCL_ENABLED_LIGHTS_2_DIRECTIONAL						0x00000030
+#define   NV10TCL_ENABLED_LIGHTS_3_SHIFT						6
+#define   NV10TCL_ENABLED_LIGHTS_3_MASK							0x000000c0
+#define    NV10TCL_ENABLED_LIGHTS_3_DISABLED						0x00000000
+#define    NV10TCL_ENABLED_LIGHTS_3_NONPOSITIONAL					0x00000040
+#define    NV10TCL_ENABLED_LIGHTS_3_POSITIONAL						0x00000080
+#define    NV10TCL_ENABLED_LIGHTS_3_DIRECTIONAL						0x000000c0
+#define   NV10TCL_ENABLED_LIGHTS_4_SHIFT						8
+#define   NV10TCL_ENABLED_LIGHTS_4_MASK							0x00000300
+#define    NV10TCL_ENABLED_LIGHTS_4_DISABLED						0x00000000
+#define    NV10TCL_ENABLED_LIGHTS_4_NONPOSITIONAL					0x00000100
+#define    NV10TCL_ENABLED_LIGHTS_4_POSITIONAL						0x00000200
+#define    NV10TCL_ENABLED_LIGHTS_4_DIRECTIONAL						0x00000300
+#define   NV10TCL_ENABLED_LIGHTS_5_SHIFT						10
+#define   NV10TCL_ENABLED_LIGHTS_5_MASK							0x00000c00
+#define    NV10TCL_ENABLED_LIGHTS_5_DISABLED						0x00000000
+#define    NV10TCL_ENABLED_LIGHTS_5_NONPOSITIONAL					0x00000400
+#define    NV10TCL_ENABLED_LIGHTS_5_POSITIONAL						0x00000800
+#define    NV10TCL_ENABLED_LIGHTS_5_DIRECTIONAL						0x00000c00
+#define   NV10TCL_ENABLED_LIGHTS_6_SHIFT						12
+#define   NV10TCL_ENABLED_LIGHTS_6_MASK							0x00003000
+#define    NV10TCL_ENABLED_LIGHTS_6_DISABLED						0x00000000
+#define    NV10TCL_ENABLED_LIGHTS_6_NONPOSITIONAL					0x00001000
+#define    NV10TCL_ENABLED_LIGHTS_6_POSITIONAL						0x00002000
+#define    NV10TCL_ENABLED_LIGHTS_6_DIRECTIONAL						0x00003000
+#define   NV10TCL_ENABLED_LIGHTS_7_SHIFT						14
+#define   NV10TCL_ENABLED_LIGHTS_7_MASK							0x0000c000
+#define    NV10TCL_ENABLED_LIGHTS_7_DISABLED						0x00000000
+#define    NV10TCL_ENABLED_LIGHTS_7_NONPOSITIONAL					0x00004000
+#define    NV10TCL_ENABLED_LIGHTS_7_POSITIONAL						0x00008000
+#define    NV10TCL_ENABLED_LIGHTS_7_DIRECTIONAL						0x0000c000
+#define  NV10TCL_TX_GEN_MODE_S(x)							(0x000003c0+((x)*16))
+#define  NV10TCL_TX_GEN_MODE_S__SIZE							0x00000002
+#define   NV10TCL_TX_GEN_MODE_S_FALSE							0x00000000
+#define   NV10TCL_TX_GEN_MODE_S_EYE_LINEAR						0x00002400
+#define   NV10TCL_TX_GEN_MODE_S_OBJECT_LINEAR						0x00002401
+#define   NV10TCL_TX_GEN_MODE_S_SPHERE_MAP						0x00002402
+#define   NV10TCL_TX_GEN_MODE_S_NORMAL_MAP						0x00008511
+#define   NV10TCL_TX_GEN_MODE_S_REFLECTION_MAP						0x00008512
+#define  NV10TCL_TX_GEN_MODE_T(x)							(0x000003c4+((x)*16))
+#define  NV10TCL_TX_GEN_MODE_T__SIZE							0x00000002
+#define   NV10TCL_TX_GEN_MODE_T_FALSE							0x00000000
+#define   NV10TCL_TX_GEN_MODE_T_EYE_LINEAR						0x00002400
+#define   NV10TCL_TX_GEN_MODE_T_OBJECT_LINEAR						0x00002401
+#define   NV10TCL_TX_GEN_MODE_T_SPHERE_MAP						0x00002402
+#define   NV10TCL_TX_GEN_MODE_T_NORMAL_MAP						0x00008511
+#define   NV10TCL_TX_GEN_MODE_T_REFLECTION_MAP						0x00008512
+#define  NV10TCL_TX_GEN_MODE_R(x)							(0x000003c8+((x)*16))
+#define  NV10TCL_TX_GEN_MODE_R__SIZE							0x00000002
+#define   NV10TCL_TX_GEN_MODE_R_FALSE							0x00000000
+#define   NV10TCL_TX_GEN_MODE_R_EYE_LINEAR						0x00002400
+#define   NV10TCL_TX_GEN_MODE_R_OBJECT_LINEAR						0x00002401
+#define   NV10TCL_TX_GEN_MODE_R_SPHERE_MAP						0x00002402
+#define   NV10TCL_TX_GEN_MODE_R_NORMAL_MAP						0x00008511
+#define   NV10TCL_TX_GEN_MODE_R_REFLECTION_MAP						0x00008512
+#define  NV10TCL_TX_GEN_MODE_Q(x)							(0x000003cc+((x)*16))
+#define  NV10TCL_TX_GEN_MODE_Q__SIZE							0x00000002
+#define   NV10TCL_TX_GEN_MODE_Q_FALSE							0x00000000
+#define   NV10TCL_TX_GEN_MODE_Q_EYE_LINEAR						0x00002400
+#define   NV10TCL_TX_GEN_MODE_Q_OBJECT_LINEAR						0x00002401
+#define   NV10TCL_TX_GEN_MODE_Q_SPHERE_MAP						0x00002402
+#define   NV10TCL_TX_GEN_MODE_Q_NORMAL_MAP						0x00008511
+#define   NV10TCL_TX_GEN_MODE_Q_REFLECTION_MAP						0x00008512
+#define  NV10TCL_TX_MATRIX_ENABLE(x)							(0x000003e0+((x)*4))
+#define  NV10TCL_TX_MATRIX_ENABLE__SIZE							0x00000002
+#define  NV10TCL_VIEW_MATRIX_ENABLE							0x000003e8
+#define   NV10TCL_VIEW_MATRIX_ENABLE_MODELVIEW1						(1 <<  0)
+#define   NV10TCL_VIEW_MATRIX_ENABLE_MODELVIEW0						(1 <<  1)
+#define   NV10TCL_VIEW_MATRIX_ENABLE_PROJECTION						(1 <<  2)
+#define  NV10TCL_POINT_SIZE								0x000003ec
+#define  NV10TCL_MODELVIEW0_MATRIX(x)							(0x00000400+((x)*4))
+#define  NV10TCL_MODELVIEW0_MATRIX__SIZE						0x00000010
+#define  NV10TCL_MODELVIEW1_MATRIX(x)							(0x00000440+((x)*4))
+#define  NV10TCL_MODELVIEW1_MATRIX__SIZE						0x00000010
+#define  NV10TCL_INVERSE_MODELVIEW0_MATRIX(x)						(0x00000480+((x)*4))
+#define  NV10TCL_INVERSE_MODELVIEW0_MATRIX__SIZE					0x00000010
+#define  NV10TCL_INVERSE_MODELVIEW1_MATRIX(x)						(0x000004c0+((x)*4))
+#define  NV10TCL_INVERSE_MODELVIEW1_MATRIX__SIZE					0x00000010
+#define  NV10TCL_PROJECTION_MATRIX(x)							(0x00000500+((x)*4))
+#define  NV10TCL_PROJECTION_MATRIX__SIZE						0x00000010
+#define  NV10TCL_TX0_MATRIX(x)								(0x00000540+((x)*4))
+#define  NV10TCL_TX0_MATRIX__SIZE							0x00000010
+#define  NV10TCL_TX1_MATRIX(x)								(0x00000580+((x)*4))
+#define  NV10TCL_TX1_MATRIX__SIZE							0x00000010
+#define  NV10TCL_TX_GEN_COEFF_S_A(x)							(0x00000600+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_S_A__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_S_B(x)							(0x00000604+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_S_B__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_S_C(x)							(0x00000608+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_S_C__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_S_D(x)							(0x0000060c+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_S_D__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_T_A(x)							(0x00000610+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_T_A__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_T_B(x)							(0x00000614+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_T_B__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_T_C(x)							(0x00000618+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_T_C__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_T_D(x)							(0x0000061c+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_T_D__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_R_A(x)							(0x00000620+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_R_A__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_R_B(x)							(0x00000624+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_R_B__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_R_C(x)							(0x00000628+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_R_C__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_R_D(x)							(0x0000062c+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_R_D__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_Q_A(x)							(0x00000630+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_Q_A__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_Q_B(x)							(0x00000634+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_Q_B__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_Q_C(x)							(0x00000638+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_Q_C__SIZE							0x00000002
+#define  NV10TCL_TX_GEN_COEFF_Q_D(x)							(0x0000063c+((x)*64))
+#define  NV10TCL_TX_GEN_COEFF_Q_D__SIZE							0x00000002
+#define  NV10TCL_FOG_EQUATION_CONSTANT							0x00000680
+#define  NV10TCL_FOG_EQUATION_LINEAR							0x00000684
+#define  NV10TCL_FOG_EQUATION_QUADRATIC							0x00000688
+#define  NV10TCL_MATERIAL_SHININESS(x)							(0x000006a0+((x)*4))
+#define  NV10TCL_MATERIAL_SHININESS__SIZE						0x00000006
+#define  NV10TCL_LIGHT_MODEL_AMBIENT_R							0x000006c4
+#define  NV10TCL_LIGHT_MODEL_AMBIENT_G							0x000006c8
+#define  NV10TCL_LIGHT_MODEL_AMBIENT_B							0x000006cc
+#define  NV10TCL_VIEWPORT_TRANSLATE_X							0x000006e8
+#define  NV10TCL_VIEWPORT_TRANSLATE_Y							0x000006ec
+#define  NV10TCL_VIEWPORT_TRANSLATE_Z							0x000006f0
+#define  NV10TCL_VIEWPORT_TRANSLATE_W							0x000006f4
+#define  NV10TCL_POINT_PARAMETER(x)							(0x000006f8+((x)*4))
+#define  NV10TCL_POINT_PARAMETER__SIZE							0x00000008
+#define  NV10TCL_LIGHT_AMBIENT_R(x)							(0x00000800+((x)*128))
+#define  NV10TCL_LIGHT_AMBIENT_R__SIZE							0x00000008
+#define  NV10TCL_LIGHT_AMBIENT_G(x)							(0x00000804+((x)*128))
+#define  NV10TCL_LIGHT_AMBIENT_G__SIZE							0x00000008
+#define  NV10TCL_LIGHT_AMBIENT_B(x)							(0x00000808+((x)*128))
+#define  NV10TCL_LIGHT_AMBIENT_B__SIZE							0x00000008
+#define  NV10TCL_LIGHT_DIFFUSE_R(x)							(0x0000080c+((x)*128))
+#define  NV10TCL_LIGHT_DIFFUSE_R__SIZE							0x00000008
+#define  NV10TCL_LIGHT_DIFFUSE_G(x)							(0x00000810+((x)*128))
+#define  NV10TCL_LIGHT_DIFFUSE_G__SIZE							0x00000008
+#define  NV10TCL_LIGHT_DIFFUSE_B(x)							(0x00000814+((x)*128))
+#define  NV10TCL_LIGHT_DIFFUSE_B__SIZE							0x00000008
+#define  NV10TCL_LIGHT_SPECULAR_R(x)							(0x00000818+((x)*128))
+#define  NV10TCL_LIGHT_SPECULAR_R__SIZE							0x00000008
+#define  NV10TCL_LIGHT_SPECULAR_G(x)							(0x0000081c+((x)*128))
+#define  NV10TCL_LIGHT_SPECULAR_G__SIZE							0x00000008
+#define  NV10TCL_LIGHT_SPECULAR_B(x)							(0x00000820+((x)*128))
+#define  NV10TCL_LIGHT_SPECULAR_B__SIZE							0x00000008
+#define  NV10TCL_LIGHT_HALF_VECTOR_X(x)							(0x00000828+((x)*128))
+#define  NV10TCL_LIGHT_HALF_VECTOR_X__SIZE						0x00000008
+#define  NV10TCL_LIGHT_HALF_VECTOR_Y(x)							(0x0000082c+((x)*128))
+#define  NV10TCL_LIGHT_HALF_VECTOR_Y__SIZE						0x00000008
+#define  NV10TCL_LIGHT_HALF_VECTOR_Z(x)							(0x00000830+((x)*128))
+#define  NV10TCL_LIGHT_HALF_VECTOR_Z__SIZE						0x00000008
+#define  NV10TCL_LIGHT_DIRECTION_X(x)							(0x00000834+((x)*128))
+#define  NV10TCL_LIGHT_DIRECTION_X__SIZE						0x00000008
+#define  NV10TCL_LIGHT_DIRECTION_Y(x)							(0x00000838+((x)*128))
+#define  NV10TCL_LIGHT_DIRECTION_Y__SIZE						0x00000008
+#define  NV10TCL_LIGHT_DIRECTION_Z(x)							(0x0000083c+((x)*128))
+#define  NV10TCL_LIGHT_DIRECTION_Z__SIZE						0x00000008
+#define  NV10TCL_LIGHT_SPOT_CUTOFF_A(x)							(0x00000840+((x)*128))
+#define  NV10TCL_LIGHT_SPOT_CUTOFF_A__SIZE						0x00000008
+#define  NV10TCL_LIGHT_SPOT_CUTOFF_B(x)							(0x00000844+((x)*128))
+#define  NV10TCL_LIGHT_SPOT_CUTOFF_B__SIZE						0x00000008
+#define  NV10TCL_LIGHT_SPOT_CUTOFF_C(x)							(0x00000848+((x)*128))
+#define  NV10TCL_LIGHT_SPOT_CUTOFF_C__SIZE						0x00000008
+#define  NV10TCL_LIGHT_SPOT_DIR_X(x)							(0x0000084c+((x)*128))
+#define  NV10TCL_LIGHT_SPOT_DIR_X__SIZE							0x00000008
+#define  NV10TCL_LIGHT_SPOT_DIR_Y(x)							(0x00000850+((x)*128))
+#define  NV10TCL_LIGHT_SPOT_DIR_Y__SIZE							0x00000008
+#define  NV10TCL_LIGHT_SPOT_DIR_Z(x)							(0x00000854+((x)*128))
+#define  NV10TCL_LIGHT_SPOT_DIR_Z__SIZE							0x00000008
+#define  NV10TCL_LIGHT_SPOT_CUTOFF_D(x)							(0x00000858+((x)*128))
+#define  NV10TCL_LIGHT_SPOT_CUTOFF_D__SIZE						0x00000008
+#define  NV10TCL_LIGHT_POSITION_X(x)							(0x0000085c+((x)*128))
+#define  NV10TCL_LIGHT_POSITION_X__SIZE							0x00000008
+#define  NV10TCL_LIGHT_POSITION_Y(x)							(0x00000860+((x)*128))
+#define  NV10TCL_LIGHT_POSITION_Y__SIZE							0x00000008
+#define  NV10TCL_LIGHT_POSITION_Z(x)							(0x00000864+((x)*128))
+#define  NV10TCL_LIGHT_POSITION_Z__SIZE							0x00000008
+#define  NV10TCL_LIGHT_ATTENUATION_CONSTANT(x)						(0x00000868+((x)*128))
+#define  NV10TCL_LIGHT_ATTENUATION_CONSTANT__SIZE					0x00000008
+#define  NV10TCL_LIGHT_ATTENUATION_LINEAR(x)						(0x0000086c+((x)*128))
+#define  NV10TCL_LIGHT_ATTENUATION_LINEAR__SIZE						0x00000008
+#define  NV10TCL_LIGHT_ATTENUATION_QUADRATIC(x)						(0x00000870+((x)*128))
+#define  NV10TCL_LIGHT_ATTENUATION_QUADRATIC__SIZE					0x00000008
+#define  NV10TCL_VERTEX_POS_3F_X							0x00000c00
+#define  NV10TCL_VERTEX_POS_3F_Y							0x00000c04
+#define  NV10TCL_VERTEX_POS_3F_Z							0x00000c08
+#define  NV10TCL_VERTEX_POS_4F_X							0x00000c18
+#define  NV10TCL_VERTEX_POS_4F_Y							0x00000c1c
+#define  NV10TCL_VERTEX_POS_4F_Z							0x00000c20
+#define  NV10TCL_VERTEX_POS_4F_W							0x00000c24
+#define  NV10TCL_VERTEX_NOR_3F_X							0x00000c30
+#define  NV10TCL_VERTEX_NOR_3F_Y							0x00000c34
+#define  NV10TCL_VERTEX_NOR_3F_Z							0x00000c38
+#define  NV10TCL_VERTEX_NOR_3I_XY							0x00000c40
+#define   NV10TCL_VERTEX_NOR_3I_XY_X_SHIFT						0
+#define   NV10TCL_VERTEX_NOR_3I_XY_X_MASK						0x0000ffff
+#define   NV10TCL_VERTEX_NOR_3I_XY_Y_SHIFT						16
+#define   NV10TCL_VERTEX_NOR_3I_XY_Y_MASK						0xffff0000
+#define  NV10TCL_VERTEX_NOR_3I_Z							0x00000c44
+#define   NV10TCL_VERTEX_NOR_3I_Z_Z_SHIFT						0
+#define   NV10TCL_VERTEX_NOR_3I_Z_Z_MASK						0x0000ffff
+#define  NV10TCL_VERTEX_COL_4F_R							0x00000c50
+#define  NV10TCL_VERTEX_COL_4F_G							0x00000c54
+#define  NV10TCL_VERTEX_COL_4F_B							0x00000c58
+#define  NV10TCL_VERTEX_COL_4F_A							0x00000c5c
+#define  NV10TCL_VERTEX_COL_3F_R							0x00000c60
+#define  NV10TCL_VERTEX_COL_3F_G							0x00000c64
+#define  NV10TCL_VERTEX_COL_3F_B							0x00000c68
+#define  NV10TCL_VERTEX_COL_4I								0x00000c6c
+#define   NV10TCL_VERTEX_COL_4I_R_SHIFT							0
+#define   NV10TCL_VERTEX_COL_4I_R_MASK							0x000000ff
+#define   NV10TCL_VERTEX_COL_4I_G_SHIFT							8
+#define   NV10TCL_VERTEX_COL_4I_G_MASK							0x0000ff00
+#define   NV10TCL_VERTEX_COL_4I_B_SHIFT							16
+#define   NV10TCL_VERTEX_COL_4I_B_MASK							0x00ff0000
+#define   NV10TCL_VERTEX_COL_4I_A_SHIFT							24
+#define   NV10TCL_VERTEX_COL_4I_A_MASK							0xff000000
+#define  NV10TCL_VERTEX_COL2_3F_R							0x00000c80
+#define  NV10TCL_VERTEX_COL2_3F_G							0x00000c84
+#define  NV10TCL_VERTEX_COL2_3F_B							0x00000c88
+#define  NV10TCL_VERTEX_COL2_3I								0x00000c8c
+#define   NV10TCL_VERTEX_COL2_3I_R_SHIFT						0
+#define   NV10TCL_VERTEX_COL2_3I_R_MASK							0x000000ff
+#define   NV10TCL_VERTEX_COL2_3I_G_SHIFT						8
+#define   NV10TCL_VERTEX_COL2_3I_G_MASK							0x0000ff00
+#define   NV10TCL_VERTEX_COL2_3I_B_SHIFT						16
+#define   NV10TCL_VERTEX_COL2_3I_B_MASK							0x00ff0000
+#define  NV10TCL_VERTEX_TX0_2F_S							0x00000c90
+#define  NV10TCL_VERTEX_TX0_2F_T							0x00000c94
+#define  NV10TCL_VERTEX_TX0_2I								0x00000c98
+#define   NV10TCL_VERTEX_TX0_2I_S_SHIFT							0
+#define   NV10TCL_VERTEX_TX0_2I_S_MASK							0x0000ffff
+#define   NV10TCL_VERTEX_TX0_2I_T_SHIFT							16
+#define   NV10TCL_VERTEX_TX0_2I_T_MASK							0xffff0000
+#define  NV10TCL_VERTEX_TX0_4F_S							0x00000ca0
+#define  NV10TCL_VERTEX_TX0_4F_T							0x00000ca4
+#define  NV10TCL_VERTEX_TX0_4F_R							0x00000ca8
+#define  NV10TCL_VERTEX_TX0_4F_Q							0x00000cac
+#define  NV10TCL_VERTEX_TX0_4I_ST							0x00000cb0
+#define   NV10TCL_VERTEX_TX0_4I_ST_S_SHIFT						0
+#define   NV10TCL_VERTEX_TX0_4I_ST_S_MASK						0x0000ffff
+#define   NV10TCL_VERTEX_TX0_4I_ST_T_SHIFT						16
+#define   NV10TCL_VERTEX_TX0_4I_ST_T_MASK						0xffff0000
+#define  NV10TCL_VERTEX_TX0_4I_RQ							0x00000cb4
+#define   NV10TCL_VERTEX_TX0_4I_RQ_R_SHIFT						0
+#define   NV10TCL_VERTEX_TX0_4I_RQ_R_MASK						0x0000ffff
+#define   NV10TCL_VERTEX_TX0_4I_RQ_Q_SHIFT						16
+#define   NV10TCL_VERTEX_TX0_4I_RQ_Q_MASK						0xffff0000
+#define  NV10TCL_VERTEX_TX1_2F_S							0x00000cb8
+#define  NV10TCL_VERTEX_TX1_2F_T							0x00000cbc
+#define  NV10TCL_VERTEX_TX1_2I								0x00000cc0
+#define   NV10TCL_VERTEX_TX1_2I_S_SHIFT							0
+#define   NV10TCL_VERTEX_TX1_2I_S_MASK							0x0000ffff
+#define   NV10TCL_VERTEX_TX1_2I_T_SHIFT							16
+#define   NV10TCL_VERTEX_TX1_2I_T_MASK							0xffff0000
+#define  NV10TCL_VERTEX_TX1_4F_S							0x00000cc8
+#define  NV10TCL_VERTEX_TX1_4F_T							0x00000ccc
+#define  NV10TCL_VERTEX_TX1_4F_R							0x00000cd0
+#define  NV10TCL_VERTEX_TX1_4F_Q							0x00000cd4
+#define  NV10TCL_VERTEX_TX1_4I_ST							0x00000cd8
+#define   NV10TCL_VERTEX_TX1_4I_ST_S_SHIFT						0
+#define   NV10TCL_VERTEX_TX1_4I_ST_S_MASK						0x0000ffff
+#define   NV10TCL_VERTEX_TX1_4I_ST_T_SHIFT						16
+#define   NV10TCL_VERTEX_TX1_4I_ST_T_MASK						0xffff0000
+#define  NV10TCL_VERTEX_TX1_4I_RQ							0x00000cdc
+#define   NV10TCL_VERTEX_TX1_4I_RQ_R_SHIFT						0
+#define   NV10TCL_VERTEX_TX1_4I_RQ_R_MASK						0x0000ffff
+#define   NV10TCL_VERTEX_TX1_4I_RQ_Q_SHIFT						16
+#define   NV10TCL_VERTEX_TX1_4I_RQ_Q_MASK						0xffff0000
+#define  NV10TCL_VERTEX_FOG_1F								0x00000ce0
+#define  NV10TCL_VERTEX_WGH_1F								0x00000ce4
+#define  NV10TCL_EDGEFLAG_ENABLE							0x00000cec
+#define  NV10TCL_VERTEX_ARRAY_VALIDATE							0x00000cf0
+#define  NV10TCL_VTXBUF_ADDRESS(x)							(0x00000d00+((x)*8))
+#define  NV10TCL_VTXBUF_ADDRESS__SIZE							0x00000008
+#define  NV10TCL_VTXFMT(x)								(0x00000d04+((x)*8))
+#define  NV10TCL_VTXFMT__SIZE								0x00000008
+#define   NV10TCL_VTXFMT_TYPE_SHIFT							0
+#define   NV10TCL_VTXFMT_TYPE_MASK							0x0000000f
+#define    NV10TCL_VTXFMT_TYPE_BYTE_BGRA						0x00000000
+#define    NV10TCL_VTXFMT_TYPE_SHORT							0x00000001
+#define    NV10TCL_VTXFMT_TYPE_FLOAT							0x00000002
+#define    NV10TCL_VTXFMT_TYPE_BYTE_RGBA						0x00000004
+#define   NV10TCL_VTXFMT_FIELDS_SHIFT							4
+#define   NV10TCL_VTXFMT_FIELDS_MASK							0x000000f0
+#define   NV10TCL_VTXFMT_STRIDE_SHIFT							8
+#define   NV10TCL_VTXFMT_STRIDE_MASK							0x0000ff00
+#define   NV10TCL_VTXFMT_POS_HOMOGENEOUS						(1 << 24)
+#define  NV10TCL_VERTEX_BEGIN_END							0x00000dfc
+#define   NV10TCL_VERTEX_BEGIN_END_STOP							0x00000000
+#define   NV10TCL_VERTEX_BEGIN_END_POINTS						0x00000001
+#define   NV10TCL_VERTEX_BEGIN_END_LINES						0x00000002
+#define   NV10TCL_VERTEX_BEGIN_END_LINE_LOOP						0x00000003
+#define   NV10TCL_VERTEX_BEGIN_END_LINE_STRIP						0x00000004
+#define   NV10TCL_VERTEX_BEGIN_END_TRIANGLES						0x00000005
+#define   NV10TCL_VERTEX_BEGIN_END_TRIANGLE_STRIP					0x00000006
+#define   NV10TCL_VERTEX_BEGIN_END_TRIANGLE_FAN						0x00000007
+#define   NV10TCL_VERTEX_BEGIN_END_QUADS						0x00000008
+#define   NV10TCL_VERTEX_BEGIN_END_QUAD_STRIP						0x00000009
+#define   NV10TCL_VERTEX_BEGIN_END_POLYGON						0x0000000a
+#define  NV10TCL_VB_ELEMENT_U16								0x00000e00
+#define   NV10TCL_VB_ELEMENT_U16_I0_SHIFT						0
+#define   NV10TCL_VB_ELEMENT_U16_I0_MASK						0x0000ffff
+#define   NV10TCL_VB_ELEMENT_U16_I1_SHIFT						16
+#define   NV10TCL_VB_ELEMENT_U16_I1_MASK						0xffff0000
+#define  NV10TCL_VB_ELEMENT_U32								0x00001100
+#define  NV10TCL_VERTEX_BUFFER_BEGIN_END						0x000013fc
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_STOP						0x00000000
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_POINTS					0x00000001
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_LINES						0x00000002
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_LINE_LOOP					0x00000003
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_LINE_STRIP					0x00000004
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_TRIANGLES					0x00000005
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_TRIANGLE_STRIP				0x00000006
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_TRIANGLE_FAN					0x00000007
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_QUADS						0x00000008
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_QUAD_STRIP					0x00000009
+#define   NV10TCL_VERTEX_BUFFER_BEGIN_END_POLYGON					0x0000000a
+#define  NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS						0x00001400
+#define   NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS_FIRST_SHIFT					0
+#define   NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS_FIRST_MASK					0x0000ffff
+#define   NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS_LAST_SHIFT					24
+#define   NV10TCL_VERTEX_BUFFER_DRAW_ARRAYS_LAST_MASK					0xff000000
+#define  NV10TCL_VERTEX_ARRAY_DATA							0x00001800
+
+
+#define NV11TCL										0x00000096
+
+#define  NV11TCL_COLOR_LOGIC_OP_ENABLE							0x00000d40
+#define  NV11TCL_COLOR_LOGIC_OP_OP							0x00000d44
+#define   NV11TCL_COLOR_LOGIC_OP_OP_CLEAR						0x00001500
+#define   NV11TCL_COLOR_LOGIC_OP_OP_AND							0x00001501
+#define   NV11TCL_COLOR_LOGIC_OP_OP_AND_REVERSE						0x00001502
+#define   NV11TCL_COLOR_LOGIC_OP_OP_COPY						0x00001503
+#define   NV11TCL_COLOR_LOGIC_OP_OP_AND_INVERTED					0x00001504
+#define   NV11TCL_COLOR_LOGIC_OP_OP_NOOP						0x00001505
+#define   NV11TCL_COLOR_LOGIC_OP_OP_XOR							0x00001506
+#define   NV11TCL_COLOR_LOGIC_OP_OP_OR							0x00001507
+#define   NV11TCL_COLOR_LOGIC_OP_OP_NOR							0x00001508
+#define   NV11TCL_COLOR_LOGIC_OP_OP_EQUIV						0x00001509
+#define   NV11TCL_COLOR_LOGIC_OP_OP_INVERT						0x0000150a
+#define   NV11TCL_COLOR_LOGIC_OP_OP_OR_REVERSE						0x0000150b
+#define   NV11TCL_COLOR_LOGIC_OP_OP_COPY_INVERTED					0x0000150c
+#define   NV11TCL_COLOR_LOGIC_OP_OP_OR_INVERTED						0x0000150d
+#define   NV11TCL_COLOR_LOGIC_OP_OP_NAND						0x0000150e
+#define   NV11TCL_COLOR_LOGIC_OP_OP_SET							0x0000150f
+
+
+#define NV17TCL										0x00000099
+
+#define  NV17TCL_DMA_IN_MEMORY4								0x000001ac
+#define  NV17TCL_DMA_IN_MEMORY5								0x000001b0
+#define  NV17TCL_COLOR_MASK_ENABLE							0x000002bc
+#define  NV17TCL_LMA_DEPTH_BUFFER_PITCH							0x00000d5c
+#define  NV17TCL_LMA_DEPTH_BUFFER_OFFSET						0x00000d60
+#define  NV17TCL_LMA_DEPTH_FILL_VALUE							0x00000d68
+#define  NV17TCL_LMA_DEPTH_BUFFER_CLEAR							0x00000d6c
+#define  NV17TCL_LMA_DEPTH_WINDOW_X							0x00001638
+#define  NV17TCL_LMA_DEPTH_WINDOW_Y							0x0000163c
+#define  NV17TCL_LMA_DEPTH_WINDOW_Z							0x00001640
+#define  NV17TCL_LMA_DEPTH_WINDOW_W							0x00001644
+#define  NV17TCL_LMA_DEPTH_ENABLE							0x00001658
+
+
+#define NV03_CONTEXT_SURFACES_2D							0x00000058
+
+#define  NV03_CONTEXT_SURFACES_2D_SYNCHRONIZE						0x00000100
+#define  NV03_CONTEXT_SURFACES_2D_DMA_NOTIFY						0x00000180
+#define  NV03_CONTEXT_SURFACES_2D_DMA_SOURCE						0x00000184
+#define  NV03_CONTEXT_SURFACES_2D_DMA_DESTIN						0x00000188
+#define  NV03_CONTEXT_SURFACES_2D_COLOR_FORMAT						0x00000300
+#define  NV03_CONTEXT_SURFACES_2D_PITCH							0x00000304
+#define   NV03_CONTEXT_SURFACES_2D_PITCH_SOURCE_SHIFT					0
+#define   NV03_CONTEXT_SURFACES_2D_PITCH_SOURCE_MASK					0x0000ffff
+#define   NV03_CONTEXT_SURFACES_2D_PITCH_DESTIN_SHIFT					16
+#define   NV03_CONTEXT_SURFACES_2D_PITCH_DESTIN_MASK					0xffff0000
+#define  NV03_CONTEXT_SURFACES_2D_OFFSET_SOURCE						0x00000308
+#define  NV03_CONTEXT_SURFACES_2D_OFFSET_DESTIN						0x0000030c
+
+
+#define NV03_CONTEXT_SURFACES_3D							0x0000005a
+
+#define  NV03_CONTEXT_SURFACES_3D_SYNCHRONIZE						0x00000100
+#define  NV03_CONTEXT_SURFACES_3D_DMA_NOTIFY						0x00000180
+#define  NV03_CONTEXT_SURFACES_3D_DMA_SURFACE						0x00000184
+#define  NV03_CONTEXT_SURFACES_3D_PITCH							0x00000300
+#define  NV03_CONTEXT_SURFACES_3D_OFFSET_COLOR						0x00000304
+#define  NV03_CONTEXT_SURFACES_3D_OFFSET_ZETA						0x00000308
+
+
+#define NV04_INDEXED_IMAGE_FROM_CPU							0x00000060
+
+#define  NV04_INDEXED_IMAGE_FROM_CPU_NOP						0x00000100
+#define  NV04_INDEXED_IMAGE_FROM_CPU_NOTIFY						0x00000104
+#define  NV04_INDEXED_IMAGE_FROM_CPU_PATCH						0x0000010c
+#define  NV04_INDEXED_IMAGE_FROM_CPU_DMA_NOTIFY						0x00000180
+#define  NV04_INDEXED_IMAGE_FROM_CPU_DMA_LUT						0x00000184
+#define  NV04_INDEXED_IMAGE_FROM_CPU_COLOR_KEY						0x00000188
+#define  NV04_INDEXED_IMAGE_FROM_CPU_CLIP_RECTANGLE					0x0000018c
+#define  NV04_INDEXED_IMAGE_FROM_CPU_PATTERN						0x00000190
+#define  NV04_INDEXED_IMAGE_FROM_CPU_ROP						0x00000194
+#define  NV04_INDEXED_IMAGE_FROM_CPU_BETA1						0x00000198
+#define  NV04_INDEXED_IMAGE_FROM_CPU_BETA4						0x0000019c
+#define  NV04_INDEXED_IMAGE_FROM_CPU_SURFACE						0x000001a0
+#define  NV04_INDEXED_IMAGE_FROM_CPU_OPERATION						0x000003e4
+#define  NV04_INDEXED_IMAGE_FROM_CPU_COLOR_FORMAT					0x000003e8
+#define  NV04_INDEXED_IMAGE_FROM_CPU_INDEX_FORMAT					0x000003ec
+#define  NV04_INDEXED_IMAGE_FROM_CPU_LUT_OFFSET						0x000003f0
+#define  NV04_INDEXED_IMAGE_FROM_CPU_POINT						0x000003f4
+#define  NV04_INDEXED_IMAGE_FROM_CPU_SIZE_OUT						0x000003f8
+#define  NV04_INDEXED_IMAGE_FROM_CPU_SIZE_IN						0x000003fc
+#define  NV04_INDEXED_IMAGE_FROM_CPU_COLOR(x)						(0x00000400+((x)*4))
+#define  NV04_INDEXED_IMAGE_FROM_CPU_COLOR__SIZE					0x00000700
+
+
+#define NV05_INDEXED_IMAGE_FROM_CPU							0x00000064
+
+#define  NV05_INDEXED_IMAGE_FROM_CPU_COLOR_CONVERSION					0x000003e0
+
+
+#define NV03_CHANNEL_PIO								0x0000006a
+
+
+
+#define NV03_CHANNEL_DMA								0x0000006b
+
+
+
+#define NV04_BETA_SOLID									0x00000072
+
+#define  NV04_BETA_SOLID_NOP								0x00000100
+#define  NV04_BETA_SOLID_NOTIFY								0x00000104
+#define  NV04_BETA_SOLID_DMA_NOTIFY							0x00000180
+#define  NV04_BETA_SOLID_BETA_OUTPUT							0x00000200
+#define  NV04_BETA_SOLID_BETA_FACTOR							0x00000300
+
+
+#define NV10_TEXTURE_FROM_CPU								0x0000007b
+
+#define  NV10_TEXTURE_FROM_CPU_NOP							0x00000100
+#define  NV10_TEXTURE_FROM_CPU_NOTIFY							0x00000104
+#define  NV10_TEXTURE_FROM_CPU_WAIT_FOR_IDLE						0x00000108
+#define  NV10_TEXTURE_FROM_CPU_PM_TRIGGER						0x00000140
+#define  NV10_TEXTURE_FROM_CPU_DMA_NOTIFY						0x00000180
+#define  NV10_TEXTURE_FROM_CPU_SURFACE							0x00000184
+#define  NV10_TEXTURE_FROM_CPU_COLOR_FORMAT						0x00000300
+#define  NV10_TEXTURE_FROM_CPU_POINT							0x00000304
+#define   NV10_TEXTURE_FROM_CPU_POINT_X_SHIFT						0
+#define   NV10_TEXTURE_FROM_CPU_POINT_X_MASK						0x0000ffff
+#define   NV10_TEXTURE_FROM_CPU_POINT_Y_SHIFT						16
+#define   NV10_TEXTURE_FROM_CPU_POINT_Y_MASK						0xffff0000
+#define  NV10_TEXTURE_FROM_CPU_SIZE							0x00000308
+#define   NV10_TEXTURE_FROM_CPU_SIZE_W_SHIFT						0
+#define   NV10_TEXTURE_FROM_CPU_SIZE_W_MASK						0x0000ffff
+#define   NV10_TEXTURE_FROM_CPU_SIZE_H_SHIFT						16
+#define   NV10_TEXTURE_FROM_CPU_SIZE_H_MASK						0xffff0000
+#define  NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL						0x0000030c
+#define   NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_X_SHIFT					0
+#define   NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_X_MASK					0x0000ffff
+#define   NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_W_SHIFT					16
+#define   NV10_TEXTURE_FROM_CPU_CLIP_HORIZONTAL_W_MASK					0xffff0000
+#define  NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL						0x00000310
+#define   NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_Y_SHIFT					0
+#define   NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_Y_MASK					0x0000ffff
+#define   NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_H_SHIFT					16
+#define   NV10_TEXTURE_FROM_CPU_CLIP_VERTICAL_H_MASK					0xffff0000
+#define  NV10_TEXTURE_FROM_CPU_COLOR(x)							(0x00000400+((x)*4))
+#define  NV10_TEXTURE_FROM_CPU_COLOR__SIZE						0x00000700
+
+
+#define NV30_TEXTURE_FROM_CPU								0x0000037b
+
+
+
+#define NV40_TEXTURE_FROM_CPU								0x0000307b
+
+
+
+#define NV10_VIDEO_DISPLAY								0x0000007c
+
+
+
+#define NV20TCL										0x00000097
+
+#define  NV20TCL_NOP									0x00000100
+#define  NV20TCL_NOTIFY									0x00000104
+#define  NV20TCL_DMA_NOTIFY								0x00000180
+#define  NV20TCL_DMA_TEXTURE0								0x00000184
+#define  NV20TCL_DMA_TEXTURE1								0x00000188
+#define  NV20TCL_DMA_COLOR								0x00000194
+#define  NV20TCL_DMA_ZETA								0x00000198
+#define  NV20TCL_DMA_VTXBUF0								0x0000019c
+#define  NV20TCL_DMA_VTXBUF1								0x000001a0
+#define  NV20TCL_DMA_FENCE								0x000001a4
+#define  NV20TCL_DMA_QUERY								0x000001a8
+#define  NV20TCL_RT_HORIZ								0x00000200
+#define   NV20TCL_RT_HORIZ_X_SHIFT							0
+#define   NV20TCL_RT_HORIZ_X_MASK							0x0000ffff
+#define   NV20TCL_RT_HORIZ_W_SHIFT							16
+#define   NV20TCL_RT_HORIZ_W_MASK							0xffff0000
+#define  NV20TCL_RT_VERT								0x00000204
+#define   NV20TCL_RT_VERT_Y_SHIFT							0
+#define   NV20TCL_RT_VERT_Y_MASK							0x0000ffff
+#define   NV20TCL_RT_VERT_H_SHIFT							16
+#define   NV20TCL_RT_VERT_H_MASK							0xffff0000
+#define  NV20TCL_RT_FORMAT								0x00000208
+#define   NV20TCL_RT_FORMAT_TYPE_SHIFT							8
+#define   NV20TCL_RT_FORMAT_TYPE_MASK							0x00000f00
+#define    NV20TCL_RT_FORMAT_TYPE_LINEAR						0x00000100
+#define    NV20TCL_RT_FORMAT_TYPE_SWIZZLED						0x00000200
+#define   NV20TCL_RT_FORMAT_COLOR_SHIFT							0
+#define   NV20TCL_RT_FORMAT_COLOR_MASK							0x0000001f
+#define    NV20TCL_RT_FORMAT_COLOR_R5G6B5						0x00000003
+#define    NV20TCL_RT_FORMAT_COLOR_X8R8G8B8						0x00000005
+#define    NV20TCL_RT_FORMAT_COLOR_A8R8G8B8						0x00000008
+#define    NV20TCL_RT_FORMAT_COLOR_B8							0x00000009
+#define    NV20TCL_RT_FORMAT_COLOR_UNKNOWN						0x0000000d
+#define    NV20TCL_RT_FORMAT_COLOR_X8B8G8R8						0x0000000f
+#define    NV20TCL_RT_FORMAT_COLOR_A8B8G8R8						0x00000010
+#define  NV20TCL_RT_PITCH								0x0000020c
+#define   NV20TCL_RT_PITCH_COLOR_PITCH_SHIFT						0
+#define   NV20TCL_RT_PITCH_COLOR_PITCH_MASK						0x0000ffff
+#define   NV20TCL_RT_PITCH_ZETA_PITCH_SHIFT						16
+#define   NV20TCL_RT_PITCH_ZETA_PITCH_MASK						0xffff0000
+#define  NV20TCL_COLOR_OFFSET								0x00000210
+#define  NV20TCL_ZETA_OFFSET								0x00000214
+#define  NV20TCL_RC_IN_ALPHA(x)								(0x00000260+((x)*4))
+#define  NV20TCL_RC_IN_ALPHA__SIZE							0x00000008
+#define   NV20TCL_RC_IN_ALPHA_D_INPUT_SHIFT						0
+#define   NV20TCL_RC_IN_ALPHA_D_INPUT_MASK						0x0000000f
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR0					0x00000001
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR1					0x00000002
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_FOG						0x00000003
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_PRIMARY_COLOR					0x00000004
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_SECONDARY_COLOR					0x00000005
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_TEXTURE0						0x00000008
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_TEXTURE1						0x00000009
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_SPARE0						0x0000000c
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_SPARE1						0x0000000d
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_E_TIMES_F					0x0000000f
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_TEXTURE2						0x0000000a
+#define    NV20TCL_RC_IN_ALPHA_D_INPUT_TEXTURE3						0x0000000b
+#define   NV20TCL_RC_IN_ALPHA_D_COMPONENT_USAGE						(1 <<  4)
+#define    NV20TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV20TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_ALPHA					0x00000010
+#define   NV20TCL_RC_IN_ALPHA_D_MAPPING_SHIFT						5
+#define   NV20TCL_RC_IN_ALPHA_D_MAPPING_MASK						0x000000e0
+#define    NV20TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_INVERT				0x00000020
+#define    NV20TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NORMAL					0x00000040
+#define    NV20TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NEGATE					0x00000060
+#define    NV20TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NORMAL				0x00000080
+#define    NV20TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NEGATE				0x000000a0
+#define    NV20TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_IDENTITY				0x000000c0
+#define    NV20TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_NEGATE					0x000000e0
+#define   NV20TCL_RC_IN_ALPHA_C_INPUT_SHIFT						8
+#define   NV20TCL_RC_IN_ALPHA_C_INPUT_MASK						0x00000f00
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_FOG						0x00000300
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_TEXTURE0						0x00000800
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_TEXTURE1						0x00000900
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_SPARE0						0x00000c00
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_SPARE1						0x00000d00
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_E_TIMES_F					0x00000f00
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_TEXTURE2						0x00000a00
+#define    NV20TCL_RC_IN_ALPHA_C_INPUT_TEXTURE3						0x00000b00
+#define   NV20TCL_RC_IN_ALPHA_C_COMPONENT_USAGE						(1 << 12)
+#define    NV20TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV20TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV20TCL_RC_IN_ALPHA_C_MAPPING_SHIFT						13
+#define   NV20TCL_RC_IN_ALPHA_C_MAPPING_MASK						0x0000e000
+#define    NV20TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_INVERT				0x00002000
+#define    NV20TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV20TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV20TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NORMAL				0x00008000
+#define    NV20TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NEGATE				0x0000a000
+#define    NV20TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_IDENTITY				0x0000c000
+#define    NV20TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV20TCL_RC_IN_ALPHA_B_INPUT_SHIFT						16
+#define   NV20TCL_RC_IN_ALPHA_B_INPUT_MASK						0x000f0000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_FOG						0x00030000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_TEXTURE0						0x00080000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_TEXTURE1						0x00090000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_SPARE0						0x000c0000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_SPARE1						0x000d0000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_E_TIMES_F					0x000f0000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_TEXTURE2						0x000a0000
+#define    NV20TCL_RC_IN_ALPHA_B_INPUT_TEXTURE3						0x000b0000
+#define   NV20TCL_RC_IN_ALPHA_B_COMPONENT_USAGE						(1 << 20)
+#define    NV20TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV20TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV20TCL_RC_IN_ALPHA_B_MAPPING_SHIFT						21
+#define   NV20TCL_RC_IN_ALPHA_B_MAPPING_MASK						0x00e00000
+#define    NV20TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_INVERT				0x00200000
+#define    NV20TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV20TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV20TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NORMAL				0x00800000
+#define    NV20TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NEGATE				0x00a00000
+#define    NV20TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_IDENTITY				0x00c00000
+#define    NV20TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV20TCL_RC_IN_ALPHA_A_INPUT_SHIFT						24
+#define   NV20TCL_RC_IN_ALPHA_A_INPUT_MASK						0x0f000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_FOG						0x03000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_TEXTURE0						0x08000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_TEXTURE1						0x09000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_SPARE0						0x0c000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_SPARE1						0x0d000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_E_TIMES_F					0x0f000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_TEXTURE2						0x0a000000
+#define    NV20TCL_RC_IN_ALPHA_A_INPUT_TEXTURE3						0x0b000000
+#define   NV20TCL_RC_IN_ALPHA_A_COMPONENT_USAGE						(1 << 28)
+#define    NV20TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV20TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV20TCL_RC_IN_ALPHA_A_MAPPING_SHIFT						29
+#define   NV20TCL_RC_IN_ALPHA_A_MAPPING_MASK						0xe0000000
+#define    NV20TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_INVERT				0x20000000
+#define    NV20TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV20TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV20TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NORMAL				0x80000000
+#define    NV20TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NEGATE				0xa0000000
+#define    NV20TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_IDENTITY				0xc0000000
+#define    NV20TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV20TCL_RC_FINAL0								0x00000288
+#define   NV20TCL_RC_FINAL0_D_INPUT_SHIFT						0
+#define   NV20TCL_RC_FINAL0_D_INPUT_MASK						0x0000000f
+#define    NV20TCL_RC_FINAL0_D_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR0					0x00000001
+#define    NV20TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR1					0x00000002
+#define    NV20TCL_RC_FINAL0_D_INPUT_FOG						0x00000003
+#define    NV20TCL_RC_FINAL0_D_INPUT_PRIMARY_COLOR					0x00000004
+#define    NV20TCL_RC_FINAL0_D_INPUT_SECONDARY_COLOR					0x00000005
+#define    NV20TCL_RC_FINAL0_D_INPUT_TEXTURE0						0x00000008
+#define    NV20TCL_RC_FINAL0_D_INPUT_TEXTURE1						0x00000009
+#define    NV20TCL_RC_FINAL0_D_INPUT_SPARE0						0x0000000c
+#define    NV20TCL_RC_FINAL0_D_INPUT_SPARE1						0x0000000d
+#define    NV20TCL_RC_FINAL0_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV20TCL_RC_FINAL0_D_INPUT_E_TIMES_F						0x0000000f
+#define    NV20TCL_RC_FINAL0_D_INPUT_TEXTURE2						0x0000000a
+#define    NV20TCL_RC_FINAL0_D_INPUT_TEXTURE3						0x0000000b
+#define   NV20TCL_RC_FINAL0_D_COMPONENT_USAGE						(1 <<  4)
+#define    NV20TCL_RC_FINAL0_D_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_FINAL0_D_COMPONENT_USAGE_ALPHA					0x00000010
+#define   NV20TCL_RC_FINAL0_D_MAPPING_SHIFT						5
+#define   NV20TCL_RC_FINAL0_D_MAPPING_MASK						0x000000e0
+#define    NV20TCL_RC_FINAL0_D_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_FINAL0_D_MAPPING_UNSIGNED_INVERT					0x00000020
+#define    NV20TCL_RC_FINAL0_D_MAPPING_EXPAND_NORMAL					0x00000040
+#define    NV20TCL_RC_FINAL0_D_MAPPING_EXPAND_NEGATE					0x00000060
+#define    NV20TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NORMAL					0x00000080
+#define    NV20TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NEGATE					0x000000a0
+#define    NV20TCL_RC_FINAL0_D_MAPPING_SIGNED_IDENTITY					0x000000c0
+#define    NV20TCL_RC_FINAL0_D_MAPPING_SIGNED_NEGATE					0x000000e0
+#define   NV20TCL_RC_FINAL0_C_INPUT_SHIFT						8
+#define   NV20TCL_RC_FINAL0_C_INPUT_MASK						0x00000f00
+#define    NV20TCL_RC_FINAL0_C_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV20TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV20TCL_RC_FINAL0_C_INPUT_FOG						0x00000300
+#define    NV20TCL_RC_FINAL0_C_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV20TCL_RC_FINAL0_C_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV20TCL_RC_FINAL0_C_INPUT_TEXTURE0						0x00000800
+#define    NV20TCL_RC_FINAL0_C_INPUT_TEXTURE1						0x00000900
+#define    NV20TCL_RC_FINAL0_C_INPUT_SPARE0						0x00000c00
+#define    NV20TCL_RC_FINAL0_C_INPUT_SPARE1						0x00000d00
+#define    NV20TCL_RC_FINAL0_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV20TCL_RC_FINAL0_C_INPUT_E_TIMES_F						0x00000f00
+#define    NV20TCL_RC_FINAL0_C_INPUT_TEXTURE2						0x00000a00
+#define    NV20TCL_RC_FINAL0_C_INPUT_TEXTURE3						0x00000b00
+#define   NV20TCL_RC_FINAL0_C_COMPONENT_USAGE						(1 << 12)
+#define    NV20TCL_RC_FINAL0_C_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_FINAL0_C_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV20TCL_RC_FINAL0_C_MAPPING_SHIFT						13
+#define   NV20TCL_RC_FINAL0_C_MAPPING_MASK						0x0000e000
+#define    NV20TCL_RC_FINAL0_C_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_FINAL0_C_MAPPING_UNSIGNED_INVERT					0x00002000
+#define    NV20TCL_RC_FINAL0_C_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV20TCL_RC_FINAL0_C_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV20TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NORMAL					0x00008000
+#define    NV20TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NEGATE					0x0000a000
+#define    NV20TCL_RC_FINAL0_C_MAPPING_SIGNED_IDENTITY					0x0000c000
+#define    NV20TCL_RC_FINAL0_C_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV20TCL_RC_FINAL0_B_INPUT_SHIFT						16
+#define   NV20TCL_RC_FINAL0_B_INPUT_MASK						0x000f0000
+#define    NV20TCL_RC_FINAL0_B_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV20TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV20TCL_RC_FINAL0_B_INPUT_FOG						0x00030000
+#define    NV20TCL_RC_FINAL0_B_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV20TCL_RC_FINAL0_B_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV20TCL_RC_FINAL0_B_INPUT_TEXTURE0						0x00080000
+#define    NV20TCL_RC_FINAL0_B_INPUT_TEXTURE1						0x00090000
+#define    NV20TCL_RC_FINAL0_B_INPUT_SPARE0						0x000c0000
+#define    NV20TCL_RC_FINAL0_B_INPUT_SPARE1						0x000d0000
+#define    NV20TCL_RC_FINAL0_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV20TCL_RC_FINAL0_B_INPUT_E_TIMES_F						0x000f0000
+#define    NV20TCL_RC_FINAL0_B_INPUT_TEXTURE2						0x000a0000
+#define    NV20TCL_RC_FINAL0_B_INPUT_TEXTURE3						0x000b0000
+#define   NV20TCL_RC_FINAL0_B_COMPONENT_USAGE						(1 << 20)
+#define    NV20TCL_RC_FINAL0_B_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_FINAL0_B_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV20TCL_RC_FINAL0_B_MAPPING_SHIFT						21
+#define   NV20TCL_RC_FINAL0_B_MAPPING_MASK						0x00e00000
+#define    NV20TCL_RC_FINAL0_B_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_FINAL0_B_MAPPING_UNSIGNED_INVERT					0x00200000
+#define    NV20TCL_RC_FINAL0_B_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV20TCL_RC_FINAL0_B_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV20TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NORMAL					0x00800000
+#define    NV20TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NEGATE					0x00a00000
+#define    NV20TCL_RC_FINAL0_B_MAPPING_SIGNED_IDENTITY					0x00c00000
+#define    NV20TCL_RC_FINAL0_B_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV20TCL_RC_FINAL0_A_INPUT_SHIFT						24
+#define   NV20TCL_RC_FINAL0_A_INPUT_MASK						0x0f000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_FOG						0x03000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_TEXTURE0						0x08000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_TEXTURE1						0x09000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_SPARE0						0x0c000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_SPARE1						0x0d000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_E_TIMES_F						0x0f000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_TEXTURE2						0x0a000000
+#define    NV20TCL_RC_FINAL0_A_INPUT_TEXTURE3						0x0b000000
+#define   NV20TCL_RC_FINAL0_A_COMPONENT_USAGE						(1 << 28)
+#define    NV20TCL_RC_FINAL0_A_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_FINAL0_A_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV20TCL_RC_FINAL0_A_MAPPING_SHIFT						29
+#define   NV20TCL_RC_FINAL0_A_MAPPING_MASK						0xe0000000
+#define    NV20TCL_RC_FINAL0_A_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_FINAL0_A_MAPPING_UNSIGNED_INVERT					0x20000000
+#define    NV20TCL_RC_FINAL0_A_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV20TCL_RC_FINAL0_A_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV20TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NORMAL					0x80000000
+#define    NV20TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NEGATE					0xa0000000
+#define    NV20TCL_RC_FINAL0_A_MAPPING_SIGNED_IDENTITY					0xc0000000
+#define    NV20TCL_RC_FINAL0_A_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV20TCL_RC_FINAL1								0x0000028c
+#define   NV20TCL_RC_FINAL1_COLOR_SUM_CLAMP						(1 <<  7)
+#define   NV20TCL_RC_FINAL1_G_INPUT_SHIFT						8
+#define   NV20TCL_RC_FINAL1_G_INPUT_MASK						0x00000f00
+#define    NV20TCL_RC_FINAL1_G_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV20TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV20TCL_RC_FINAL1_G_INPUT_FOG						0x00000300
+#define    NV20TCL_RC_FINAL1_G_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV20TCL_RC_FINAL1_G_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV20TCL_RC_FINAL1_G_INPUT_TEXTURE0						0x00000800
+#define    NV20TCL_RC_FINAL1_G_INPUT_TEXTURE1						0x00000900
+#define    NV20TCL_RC_FINAL1_G_INPUT_SPARE0						0x00000c00
+#define    NV20TCL_RC_FINAL1_G_INPUT_SPARE1						0x00000d00
+#define    NV20TCL_RC_FINAL1_G_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV20TCL_RC_FINAL1_G_INPUT_E_TIMES_F						0x00000f00
+#define    NV20TCL_RC_FINAL1_G_INPUT_TEXTURE2						0x00000a00
+#define    NV20TCL_RC_FINAL1_G_INPUT_TEXTURE3						0x00000b00
+#define   NV20TCL_RC_FINAL1_G_COMPONENT_USAGE						(1 << 12)
+#define    NV20TCL_RC_FINAL1_G_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_FINAL1_G_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV20TCL_RC_FINAL1_G_MAPPING_SHIFT						13
+#define   NV20TCL_RC_FINAL1_G_MAPPING_MASK						0x0000e000
+#define    NV20TCL_RC_FINAL1_G_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_FINAL1_G_MAPPING_UNSIGNED_INVERT					0x00002000
+#define    NV20TCL_RC_FINAL1_G_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV20TCL_RC_FINAL1_G_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV20TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NORMAL					0x00008000
+#define    NV20TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NEGATE					0x0000a000
+#define    NV20TCL_RC_FINAL1_G_MAPPING_SIGNED_IDENTITY					0x0000c000
+#define    NV20TCL_RC_FINAL1_G_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV20TCL_RC_FINAL1_F_INPUT_SHIFT						16
+#define   NV20TCL_RC_FINAL1_F_INPUT_MASK						0x000f0000
+#define    NV20TCL_RC_FINAL1_F_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV20TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV20TCL_RC_FINAL1_F_INPUT_FOG						0x00030000
+#define    NV20TCL_RC_FINAL1_F_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV20TCL_RC_FINAL1_F_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV20TCL_RC_FINAL1_F_INPUT_TEXTURE0						0x00080000
+#define    NV20TCL_RC_FINAL1_F_INPUT_TEXTURE1						0x00090000
+#define    NV20TCL_RC_FINAL1_F_INPUT_SPARE0						0x000c0000
+#define    NV20TCL_RC_FINAL1_F_INPUT_SPARE1						0x000d0000
+#define    NV20TCL_RC_FINAL1_F_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV20TCL_RC_FINAL1_F_INPUT_E_TIMES_F						0x000f0000
+#define    NV20TCL_RC_FINAL1_F_INPUT_TEXTURE2						0x000a0000
+#define    NV20TCL_RC_FINAL1_F_INPUT_TEXTURE3						0x000b0000
+#define   NV20TCL_RC_FINAL1_F_COMPONENT_USAGE						(1 << 20)
+#define    NV20TCL_RC_FINAL1_F_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_FINAL1_F_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV20TCL_RC_FINAL1_F_MAPPING_SHIFT						21
+#define   NV20TCL_RC_FINAL1_F_MAPPING_MASK						0x00e00000
+#define    NV20TCL_RC_FINAL1_F_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_FINAL1_F_MAPPING_UNSIGNED_INVERT					0x00200000
+#define    NV20TCL_RC_FINAL1_F_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV20TCL_RC_FINAL1_F_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV20TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NORMAL					0x00800000
+#define    NV20TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NEGATE					0x00a00000
+#define    NV20TCL_RC_FINAL1_F_MAPPING_SIGNED_IDENTITY					0x00c00000
+#define    NV20TCL_RC_FINAL1_F_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV20TCL_RC_FINAL1_E_INPUT_SHIFT						24
+#define   NV20TCL_RC_FINAL1_E_INPUT_MASK						0x0f000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_FOG						0x03000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_TEXTURE0						0x08000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_TEXTURE1						0x09000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_SPARE0						0x0c000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_SPARE1						0x0d000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_E_TIMES_F						0x0f000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_TEXTURE2						0x0a000000
+#define    NV20TCL_RC_FINAL1_E_INPUT_TEXTURE3						0x0b000000
+#define   NV20TCL_RC_FINAL1_E_COMPONENT_USAGE						(1 << 28)
+#define    NV20TCL_RC_FINAL1_E_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_FINAL1_E_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV20TCL_RC_FINAL1_E_MAPPING_SHIFT						29
+#define   NV20TCL_RC_FINAL1_E_MAPPING_MASK						0xe0000000
+#define    NV20TCL_RC_FINAL1_E_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_FINAL1_E_MAPPING_UNSIGNED_INVERT					0x20000000
+#define    NV20TCL_RC_FINAL1_E_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV20TCL_RC_FINAL1_E_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV20TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NORMAL					0x80000000
+#define    NV20TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NEGATE					0xa0000000
+#define    NV20TCL_RC_FINAL1_E_MAPPING_SIGNED_IDENTITY					0xc0000000
+#define    NV20TCL_RC_FINAL1_E_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV20TCL_LIGHT_MODEL								0x00000294
+#define   NV20TCL_LIGHT_MODEL_VIEWER_SHIFT						16
+#define   NV20TCL_LIGHT_MODEL_VIEWER_MASK						0x00030000
+#define    NV20TCL_LIGHT_MODEL_VIEWER_NONLOCAL						0x00020000
+#define    NV20TCL_LIGHT_MODEL_VIEWER_LOCAL						0x00030000
+#define   NV20TCL_LIGHT_MODEL_SEPARATE_SPECULAR						(1 <<  0)
+#define  NV20TCL_COLOR_MATERIAL								0x00000298
+#define   NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_SHIFT					0
+#define   NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_MASK					0x00000003
+#define    NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_OFF					0x00000000
+#define    NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_COL1					0x00000001
+#define    NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_COL2					0x00000002
+#define   NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_SHIFT					2
+#define   NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_MASK					0x0000000c
+#define    NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_OFF					0x00000000
+#define    NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_COL1					0x00000004
+#define    NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_COL2					0x00000008
+#define   NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_SHIFT					4
+#define   NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_MASK					0x00000030
+#define    NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_OFF					0x00000000
+#define    NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_COL1					0x00000010
+#define    NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_COL2					0x00000020
+#define   NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_SHIFT					6
+#define   NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_MASK					0x000000c0
+#define    NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_OFF					0x00000000
+#define    NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_COL1					0x00000040
+#define    NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_COL2					0x00000080
+#define   NV20TCL_COLOR_MATERIAL_BACK_EMISSION_SHIFT					8
+#define   NV20TCL_COLOR_MATERIAL_BACK_EMISSION_MASK					0x00000300
+#define    NV20TCL_COLOR_MATERIAL_BACK_EMISSION_OFF					0x00000000
+#define    NV20TCL_COLOR_MATERIAL_BACK_EMISSION_COL1					0x00000100
+#define    NV20TCL_COLOR_MATERIAL_BACK_EMISSION_COL2					0x00000200
+#define   NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_SHIFT					10
+#define   NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_MASK					0x00000c00
+#define    NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_OFF					0x00000000
+#define    NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_COL1					0x00000400
+#define    NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_COL2					0x00000800
+#define   NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_SHIFT					12
+#define   NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_MASK					0x00003000
+#define    NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_OFF					0x00000000
+#define    NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_COL1					0x00001000
+#define    NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_COL2					0x00002000
+#define   NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_SHIFT					14
+#define   NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_MASK					0x0000c000
+#define    NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_OFF					0x00000000
+#define    NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_COL1					0x00004000
+#define    NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_COL2					0x00008000
+#define  NV20TCL_FOG_MODE								0x0000029c
+#define   NV20TCL_FOG_MODE_LINEAR_UNSIGNED						0x00000804
+#define   NV20TCL_FOG_MODE_LINEAR_SIGNED						0x00002601
+#define   NV20TCL_FOG_MODE_EXP_UNSIGNED							0x00000802
+#define   NV20TCL_FOG_MODE_EXP_SIGNED							0x00000800
+#define   NV20TCL_FOG_MODE_EXP2_UNSIGNED						0x00000803
+#define   NV20TCL_FOG_MODE_EXP2_SIGNED							0x00000801
+#define  NV20TCL_FOG_COORD								0x000002a0
+#define   NV20TCL_FOG_COORD_DIST_RADIAL							0x00000001
+#define   NV20TCL_FOG_COORD_DIST_ORTHOGONAL						0x00000002
+#define   NV20TCL_FOG_COORD_DIST_ORTHOGONAL_ABS						0x00000003
+#define   NV20TCL_FOG_COORD_FOG								0x00000006
+#define  NV20TCL_FOG_ENABLE								0x000002a4
+#define  NV20TCL_FOG_COLOR								0x000002a8
+#define   NV20TCL_FOG_COLOR_R_SHIFT							0
+#define   NV20TCL_FOG_COLOR_R_MASK							0x000000ff
+#define   NV20TCL_FOG_COLOR_G_SHIFT							8
+#define   NV20TCL_FOG_COLOR_G_MASK							0x0000ff00
+#define   NV20TCL_FOG_COLOR_B_SHIFT							16
+#define   NV20TCL_FOG_COLOR_B_MASK							0x00ff0000
+#define   NV20TCL_FOG_COLOR_A_SHIFT							24
+#define   NV20TCL_FOG_COLOR_A_MASK							0xff000000
+#define  NV20TCL_VIEWPORT_CLIP_MODE							0x000002b4
+#define  NV20TCL_VIEWPORT_CLIP_HORIZ(x)							(0x000002c0+((x)*4))
+#define  NV20TCL_VIEWPORT_CLIP_HORIZ__SIZE						0x00000008
+#define  NV20TCL_VIEWPORT_CLIP_VERT(x)							(0x000002e0+((x)*4))
+#define  NV20TCL_VIEWPORT_CLIP_VERT__SIZE						0x00000008
+#define  NV20TCL_ALPHA_FUNC_ENABLE							0x00000300
+#define  NV20TCL_BLEND_FUNC_ENABLE							0x00000304
+#define  NV20TCL_CULL_FACE_ENABLE							0x00000308
+#define  NV20TCL_DEPTH_TEST_ENABLE							0x0000030c
+#define  NV20TCL_DITHER_ENABLE								0x00000310
+#define  NV20TCL_LIGHTING_ENABLE							0x00000314
+#define  NV20TCL_POINT_PARAMETERS_ENABLE						0x00000318
+#define  NV20TCL_POINT_SMOOTH_ENABLE							0x0000031c
+#define  NV20TCL_LINE_SMOOTH_ENABLE							0x00000320
+#define  NV20TCL_POLYGON_SMOOTH_ENABLE							0x00000324
+#define  NV20TCL_STENCIL_ENABLE								0x0000032c
+#define  NV20TCL_POLYGON_OFFSET_POINT_ENABLE						0x00000330
+#define  NV20TCL_POLYGON_OFFSET_LINE_ENABLE						0x00000334
+#define  NV20TCL_POLYGON_OFFSET_FILL_ENABLE						0x00000338
+#define  NV20TCL_ALPHA_FUNC_FUNC							0x0000033c
+#define   NV20TCL_ALPHA_FUNC_FUNC_NEVER							0x00000200
+#define   NV20TCL_ALPHA_FUNC_FUNC_LESS							0x00000201
+#define   NV20TCL_ALPHA_FUNC_FUNC_EQUAL							0x00000202
+#define   NV20TCL_ALPHA_FUNC_FUNC_LEQUAL						0x00000203
+#define   NV20TCL_ALPHA_FUNC_FUNC_GREATER						0x00000204
+#define   NV20TCL_ALPHA_FUNC_FUNC_NOTEQUAL						0x00000205
+#define   NV20TCL_ALPHA_FUNC_FUNC_GEQUAL						0x00000206
+#define   NV20TCL_ALPHA_FUNC_FUNC_ALWAYS						0x00000207
+#define  NV20TCL_ALPHA_FUNC_REF								0x00000340
+#define  NV20TCL_BLEND_FUNC_SRC								0x00000344
+#define   NV20TCL_BLEND_FUNC_SRC_ZERO							0x00000000
+#define   NV20TCL_BLEND_FUNC_SRC_ONE							0x00000001
+#define   NV20TCL_BLEND_FUNC_SRC_SRC_COLOR						0x00000300
+#define   NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_SRC_COLOR					0x00000301
+#define   NV20TCL_BLEND_FUNC_SRC_SRC_ALPHA						0x00000302
+#define   NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_SRC_ALPHA					0x00000303
+#define   NV20TCL_BLEND_FUNC_SRC_DST_ALPHA						0x00000304
+#define   NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_DST_ALPHA					0x00000305
+#define   NV20TCL_BLEND_FUNC_SRC_DST_COLOR						0x00000306
+#define   NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_DST_COLOR					0x00000307
+#define   NV20TCL_BLEND_FUNC_SRC_SRC_ALPHA_SATURATE					0x00000308
+#define   NV20TCL_BLEND_FUNC_SRC_CONSTANT_COLOR						0x00008001
+#define   NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define   NV20TCL_BLEND_FUNC_SRC_CONSTANT_ALPHA						0x00008003
+#define   NV20TCL_BLEND_FUNC_SRC_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define  NV20TCL_BLEND_FUNC_DST								0x00000348
+#define   NV20TCL_BLEND_FUNC_DST_ZERO							0x00000000
+#define   NV20TCL_BLEND_FUNC_DST_ONE							0x00000001
+#define   NV20TCL_BLEND_FUNC_DST_SRC_COLOR						0x00000300
+#define   NV20TCL_BLEND_FUNC_DST_ONE_MINUS_SRC_COLOR					0x00000301
+#define   NV20TCL_BLEND_FUNC_DST_SRC_ALPHA						0x00000302
+#define   NV20TCL_BLEND_FUNC_DST_ONE_MINUS_SRC_ALPHA					0x00000303
+#define   NV20TCL_BLEND_FUNC_DST_DST_ALPHA						0x00000304
+#define   NV20TCL_BLEND_FUNC_DST_ONE_MINUS_DST_ALPHA					0x00000305
+#define   NV20TCL_BLEND_FUNC_DST_DST_COLOR						0x00000306
+#define   NV20TCL_BLEND_FUNC_DST_ONE_MINUS_DST_COLOR					0x00000307
+#define   NV20TCL_BLEND_FUNC_DST_SRC_ALPHA_SATURATE					0x00000308
+#define   NV20TCL_BLEND_FUNC_DST_CONSTANT_COLOR						0x00008001
+#define   NV20TCL_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define   NV20TCL_BLEND_FUNC_DST_CONSTANT_ALPHA						0x00008003
+#define   NV20TCL_BLEND_FUNC_DST_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define  NV20TCL_BLEND_COLOR								0x0000034c
+#define   NV20TCL_BLEND_COLOR_B_SHIFT							0
+#define   NV20TCL_BLEND_COLOR_B_MASK							0x000000ff
+#define   NV20TCL_BLEND_COLOR_G_SHIFT							8
+#define   NV20TCL_BLEND_COLOR_G_MASK							0x0000ff00
+#define   NV20TCL_BLEND_COLOR_R_SHIFT							16
+#define   NV20TCL_BLEND_COLOR_R_MASK							0x00ff0000
+#define   NV20TCL_BLEND_COLOR_A_SHIFT							24
+#define   NV20TCL_BLEND_COLOR_A_MASK							0xff000000
+#define  NV20TCL_BLEND_EQUATION								0x00000350
+#define   NV20TCL_BLEND_EQUATION_FUNC_ADD						0x00008006
+#define   NV20TCL_BLEND_EQUATION_MIN							0x00008007
+#define   NV20TCL_BLEND_EQUATION_MAX							0x00008008
+#define   NV20TCL_BLEND_EQUATION_FUNC_SUBTRACT						0x0000800a
+#define   NV20TCL_BLEND_EQUATION_FUNC_REVERSE_SUBTRACT					0x0000800b
+#define  NV20TCL_DEPTH_FUNC								0x00000354
+#define   NV20TCL_DEPTH_FUNC_NEVER							0x00000200
+#define   NV20TCL_DEPTH_FUNC_LESS							0x00000201
+#define   NV20TCL_DEPTH_FUNC_EQUAL							0x00000202
+#define   NV20TCL_DEPTH_FUNC_LEQUAL							0x00000203
+#define   NV20TCL_DEPTH_FUNC_GREATER							0x00000204
+#define   NV20TCL_DEPTH_FUNC_NOTEQUAL							0x00000205
+#define   NV20TCL_DEPTH_FUNC_GEQUAL							0x00000206
+#define   NV20TCL_DEPTH_FUNC_ALWAYS							0x00000207
+#define  NV20TCL_COLOR_MASK								0x00000358
+#define   NV20TCL_COLOR_MASK_B								(1 <<  0)
+#define   NV20TCL_COLOR_MASK_G								(1 <<  8)
+#define   NV20TCL_COLOR_MASK_R								(1 << 16)
+#define   NV20TCL_COLOR_MASK_A								(1 << 24)
+#define  NV20TCL_DEPTH_WRITE_ENABLE							0x0000035c
+#define  NV20TCL_STENCIL_MASK								0x00000360
+#define  NV20TCL_STENCIL_FUNC_FUNC							0x00000364
+#define   NV20TCL_STENCIL_FUNC_FUNC_NEVER						0x00000200
+#define   NV20TCL_STENCIL_FUNC_FUNC_LESS						0x00000201
+#define   NV20TCL_STENCIL_FUNC_FUNC_EQUAL						0x00000202
+#define   NV20TCL_STENCIL_FUNC_FUNC_LEQUAL						0x00000203
+#define   NV20TCL_STENCIL_FUNC_FUNC_GREATER						0x00000204
+#define   NV20TCL_STENCIL_FUNC_FUNC_NOTEQUAL						0x00000205
+#define   NV20TCL_STENCIL_FUNC_FUNC_GEQUAL						0x00000206
+#define   NV20TCL_STENCIL_FUNC_FUNC_ALWAYS						0x00000207
+#define  NV20TCL_STENCIL_FUNC_REF							0x00000368
+#define  NV20TCL_STENCIL_FUNC_MASK							0x0000036c
+#define  NV20TCL_STENCIL_OP_FAIL							0x00000370
+#define   NV20TCL_STENCIL_OP_FAIL_ZERO							0x00000000
+#define   NV20TCL_STENCIL_OP_FAIL_INVERT						0x0000150a
+#define   NV20TCL_STENCIL_OP_FAIL_KEEP							0x00001e00
+#define   NV20TCL_STENCIL_OP_FAIL_REPLACE						0x00001e01
+#define   NV20TCL_STENCIL_OP_FAIL_INCR							0x00001e02
+#define   NV20TCL_STENCIL_OP_FAIL_DECR							0x00001e03
+#define   NV20TCL_STENCIL_OP_FAIL_INCR_WRAP						0x00008507
+#define   NV20TCL_STENCIL_OP_FAIL_DECR_WRAP						0x00008508
+#define  NV20TCL_STENCIL_OP_ZFAIL							0x00000374
+#define   NV20TCL_STENCIL_OP_ZFAIL_ZERO							0x00000000
+#define   NV20TCL_STENCIL_OP_ZFAIL_INVERT						0x0000150a
+#define   NV20TCL_STENCIL_OP_ZFAIL_KEEP							0x00001e00
+#define   NV20TCL_STENCIL_OP_ZFAIL_REPLACE						0x00001e01
+#define   NV20TCL_STENCIL_OP_ZFAIL_INCR							0x00001e02
+#define   NV20TCL_STENCIL_OP_ZFAIL_DECR							0x00001e03
+#define   NV20TCL_STENCIL_OP_ZFAIL_INCR_WRAP						0x00008507
+#define   NV20TCL_STENCIL_OP_ZFAIL_DECR_WRAP						0x00008508
+#define  NV20TCL_STENCIL_OP_ZPASS							0x00000378
+#define   NV20TCL_STENCIL_OP_ZPASS_ZERO							0x00000000
+#define   NV20TCL_STENCIL_OP_ZPASS_INVERT						0x0000150a
+#define   NV20TCL_STENCIL_OP_ZPASS_KEEP							0x00001e00
+#define   NV20TCL_STENCIL_OP_ZPASS_REPLACE						0x00001e01
+#define   NV20TCL_STENCIL_OP_ZPASS_INCR							0x00001e02
+#define   NV20TCL_STENCIL_OP_ZPASS_DECR							0x00001e03
+#define   NV20TCL_STENCIL_OP_ZPASS_INCR_WRAP						0x00008507
+#define   NV20TCL_STENCIL_OP_ZPASS_DECR_WRAP						0x00008508
+#define  NV20TCL_SHADE_MODEL								0x0000037c
+#define   NV20TCL_SHADE_MODEL_FLAT							0x00001d00
+#define   NV20TCL_SHADE_MODEL_SMOOTH							0x00001d01
+#define  NV20TCL_LINE_WIDTH								0x00000380
+#define  NV20TCL_POLYGON_OFFSET_FACTOR							0x00000384
+#define  NV20TCL_POLYGON_OFFSET_UNITS							0x00000388
+#define  NV20TCL_POLYGON_MODE_FRONT							0x0000038c
+#define   NV20TCL_POLYGON_MODE_FRONT_POINT						0x00001b00
+#define   NV20TCL_POLYGON_MODE_FRONT_LINE						0x00001b01
+#define   NV20TCL_POLYGON_MODE_FRONT_FILL						0x00001b02
+#define  NV20TCL_POLYGON_MODE_BACK							0x00000390
+#define   NV20TCL_POLYGON_MODE_BACK_POINT						0x00001b00
+#define   NV20TCL_POLYGON_MODE_BACK_LINE						0x00001b01
+#define   NV20TCL_POLYGON_MODE_BACK_FILL						0x00001b02
+#define  NV20TCL_DEPTH_RANGE_NEAR							0x00000394
+#define  NV20TCL_DEPTH_RANGE_FAR							0x00000398
+#define  NV20TCL_CULL_FACE								0x0000039c
+#define   NV20TCL_CULL_FACE_FRONT							0x00000404
+#define   NV20TCL_CULL_FACE_BACK							0x00000405
+#define   NV20TCL_CULL_FACE_FRONT_AND_BACK						0x00000408
+#define  NV20TCL_FRONT_FACE								0x000003a0
+#define   NV20TCL_FRONT_FACE_CW								0x00000900
+#define   NV20TCL_FRONT_FACE_CCW							0x00000901
+#define  NV20TCL_NORMALIZE_ENABLE							0x000003a4
+#define  NV20TCL_MATERIAL_FACTOR_FRONT_R						0x000003a8
+#define  NV20TCL_MATERIAL_FACTOR_FRONT_G						0x000003ac
+#define  NV20TCL_MATERIAL_FACTOR_FRONT_B						0x000003b0
+#define  NV20TCL_MATERIAL_FACTOR_FRONT_A						0x000003b4
+#define  NV20TCL_SEPARATE_SPECULAR_ENABLE						0x000003b8
+#define  NV20TCL_ENABLED_LIGHTS								0x000003bc
+#define   NV20TCL_ENABLED_LIGHTS_0_SHIFT						0
+#define   NV20TCL_ENABLED_LIGHTS_0_MASK							0x00000003
+#define    NV20TCL_ENABLED_LIGHTS_0_DISABLED						0x00000000
+#define    NV20TCL_ENABLED_LIGHTS_0_NONPOSITIONAL					0x00000001
+#define    NV20TCL_ENABLED_LIGHTS_0_POSITIONAL						0x00000002
+#define    NV20TCL_ENABLED_LIGHTS_0_DIRECTIONAL						0x00000003
+#define   NV20TCL_ENABLED_LIGHTS_1_SHIFT						2
+#define   NV20TCL_ENABLED_LIGHTS_1_MASK							0x0000000c
+#define    NV20TCL_ENABLED_LIGHTS_1_DISABLED						0x00000000
+#define    NV20TCL_ENABLED_LIGHTS_1_NONPOSITIONAL					0x00000004
+#define    NV20TCL_ENABLED_LIGHTS_1_POSITIONAL						0x00000008
+#define    NV20TCL_ENABLED_LIGHTS_1_DIRECTIONAL						0x0000000c
+#define   NV20TCL_ENABLED_LIGHTS_2_SHIFT						4
+#define   NV20TCL_ENABLED_LIGHTS_2_MASK							0x00000030
+#define    NV20TCL_ENABLED_LIGHTS_2_DISABLED						0x00000000
+#define    NV20TCL_ENABLED_LIGHTS_2_NONPOSITIONAL					0x00000010
+#define    NV20TCL_ENABLED_LIGHTS_2_POSITIONAL						0x00000020
+#define    NV20TCL_ENABLED_LIGHTS_2_DIRECTIONAL						0x00000030
+#define   NV20TCL_ENABLED_LIGHTS_3_SHIFT						6
+#define   NV20TCL_ENABLED_LIGHTS_3_MASK							0x000000c0
+#define    NV20TCL_ENABLED_LIGHTS_3_DISABLED						0x00000000
+#define    NV20TCL_ENABLED_LIGHTS_3_NONPOSITIONAL					0x00000040
+#define    NV20TCL_ENABLED_LIGHTS_3_POSITIONAL						0x00000080
+#define    NV20TCL_ENABLED_LIGHTS_3_DIRECTIONAL						0x000000c0
+#define   NV20TCL_ENABLED_LIGHTS_4_SHIFT						8
+#define   NV20TCL_ENABLED_LIGHTS_4_MASK							0x00000300
+#define    NV20TCL_ENABLED_LIGHTS_4_DISABLED						0x00000000
+#define    NV20TCL_ENABLED_LIGHTS_4_NONPOSITIONAL					0x00000100
+#define    NV20TCL_ENABLED_LIGHTS_4_POSITIONAL						0x00000200
+#define    NV20TCL_ENABLED_LIGHTS_4_DIRECTIONAL						0x00000300
+#define   NV20TCL_ENABLED_LIGHTS_5_SHIFT						10
+#define   NV20TCL_ENABLED_LIGHTS_5_MASK							0x00000c00
+#define    NV20TCL_ENABLED_LIGHTS_5_DISABLED						0x00000000
+#define    NV20TCL_ENABLED_LIGHTS_5_NONPOSITIONAL					0x00000400
+#define    NV20TCL_ENABLED_LIGHTS_5_POSITIONAL						0x00000800
+#define    NV20TCL_ENABLED_LIGHTS_5_DIRECTIONAL						0x00000c00
+#define   NV20TCL_ENABLED_LIGHTS_6_SHIFT						12
+#define   NV20TCL_ENABLED_LIGHTS_6_MASK							0x00003000
+#define    NV20TCL_ENABLED_LIGHTS_6_DISABLED						0x00000000
+#define    NV20TCL_ENABLED_LIGHTS_6_NONPOSITIONAL					0x00001000
+#define    NV20TCL_ENABLED_LIGHTS_6_POSITIONAL						0x00002000
+#define    NV20TCL_ENABLED_LIGHTS_6_DIRECTIONAL						0x00003000
+#define   NV20TCL_ENABLED_LIGHTS_7_SHIFT						14
+#define   NV20TCL_ENABLED_LIGHTS_7_MASK							0x0000c000
+#define    NV20TCL_ENABLED_LIGHTS_7_DISABLED						0x00000000
+#define    NV20TCL_ENABLED_LIGHTS_7_NONPOSITIONAL					0x00004000
+#define    NV20TCL_ENABLED_LIGHTS_7_POSITIONAL						0x00008000
+#define    NV20TCL_ENABLED_LIGHTS_7_DIRECTIONAL						0x0000c000
+#define  NV20TCL_TX_GEN_MODE_S(x)							(0x000003c0+((x)*16))
+#define  NV20TCL_TX_GEN_MODE_S__SIZE							0x00000004
+#define   NV20TCL_TX_GEN_MODE_S_FALSE							0x00000000
+#define   NV20TCL_TX_GEN_MODE_S_EYE_LINEAR						0x00002400
+#define   NV20TCL_TX_GEN_MODE_S_OBJECT_LINEAR						0x00002401
+#define   NV20TCL_TX_GEN_MODE_S_SPHERE_MAP						0x00002402
+#define   NV20TCL_TX_GEN_MODE_S_NORMAL_MAP						0x00008511
+#define   NV20TCL_TX_GEN_MODE_S_REFLECTION_MAP						0x00008512
+#define  NV20TCL_TX_GEN_MODE_T(x)							(0x000003c4+((x)*16))
+#define  NV20TCL_TX_GEN_MODE_T__SIZE							0x00000004
+#define   NV20TCL_TX_GEN_MODE_T_FALSE							0x00000000
+#define   NV20TCL_TX_GEN_MODE_T_EYE_LINEAR						0x00002400
+#define   NV20TCL_TX_GEN_MODE_T_OBJECT_LINEAR						0x00002401
+#define   NV20TCL_TX_GEN_MODE_T_SPHERE_MAP						0x00002402
+#define   NV20TCL_TX_GEN_MODE_T_NORMAL_MAP						0x00008511
+#define   NV20TCL_TX_GEN_MODE_T_REFLECTION_MAP						0x00008512
+#define  NV20TCL_TX_GEN_MODE_R(x)							(0x000003c8+((x)*16))
+#define  NV20TCL_TX_GEN_MODE_R__SIZE							0x00000004
+#define   NV20TCL_TX_GEN_MODE_R_FALSE							0x00000000
+#define   NV20TCL_TX_GEN_MODE_R_EYE_LINEAR						0x00002400
+#define   NV20TCL_TX_GEN_MODE_R_OBJECT_LINEAR						0x00002401
+#define   NV20TCL_TX_GEN_MODE_R_SPHERE_MAP						0x00002402
+#define   NV20TCL_TX_GEN_MODE_R_NORMAL_MAP						0x00008511
+#define   NV20TCL_TX_GEN_MODE_R_REFLECTION_MAP						0x00008512
+#define  NV20TCL_TX_GEN_MODE_Q(x)							(0x000003cc+((x)*16))
+#define  NV20TCL_TX_GEN_MODE_Q__SIZE							0x00000004
+#define   NV20TCL_TX_GEN_MODE_Q_FALSE							0x00000000
+#define   NV20TCL_TX_GEN_MODE_Q_EYE_LINEAR						0x00002400
+#define   NV20TCL_TX_GEN_MODE_Q_OBJECT_LINEAR						0x00002401
+#define   NV20TCL_TX_GEN_MODE_Q_SPHERE_MAP						0x00002402
+#define   NV20TCL_TX_GEN_MODE_Q_NORMAL_MAP						0x00008511
+#define   NV20TCL_TX_GEN_MODE_Q_REFLECTION_MAP						0x00008512
+#define  NV20TCL_TX_MATRIX_ENABLE(x)							(0x00000420+((x)*4))
+#define  NV20TCL_TX_MATRIX_ENABLE__SIZE							0x00000004
+#define  NV20TCL_POINT_SIZE								0x0000043c
+#define  NV20TCL_MODELVIEW0_MATRIX(x)							(0x00000480+((x)*4))
+#define  NV20TCL_MODELVIEW0_MATRIX__SIZE						0x00000010
+#define  NV20TCL_MODELVIEW1_MATRIX(x)							(0x000004c0+((x)*4))
+#define  NV20TCL_MODELVIEW1_MATRIX__SIZE						0x00000010
+#define  NV20TCL_MODELVIEW2_MATRIX(x)							(0x00000500+((x)*4))
+#define  NV20TCL_MODELVIEW2_MATRIX__SIZE						0x00000010
+#define  NV20TCL_MODELVIEW3_MATRIX(x)							(0x00000540+((x)*4))
+#define  NV20TCL_MODELVIEW3_MATRIX__SIZE						0x00000010
+#define  NV20TCL_INVERSE_MODELVIEW0_MATRIX(x)						(0x00000580+((x)*4))
+#define  NV20TCL_INVERSE_MODELVIEW0_MATRIX__SIZE					0x00000010
+#define  NV20TCL_INVERSE_MODELVIEW1_MATRIX(x)						(0x000005c0+((x)*4))
+#define  NV20TCL_INVERSE_MODELVIEW1_MATRIX__SIZE					0x00000010
+#define  NV20TCL_INVERSE_MODELVIEW2_MATRIX(x)						(0x00000600+((x)*4))
+#define  NV20TCL_INVERSE_MODELVIEW2_MATRIX__SIZE					0x00000010
+#define  NV20TCL_INVERSE_MODELVIEW3_MATRIX(x)						(0x00000640+((x)*4))
+#define  NV20TCL_INVERSE_MODELVIEW3_MATRIX__SIZE					0x00000010
+#define  NV20TCL_PROJECTION_MATRIX(x)							(0x00000680+((x)*4))
+#define  NV20TCL_PROJECTION_MATRIX__SIZE						0x00000010
+#define  NV20TCL_TX0_MATRIX(x)								(0x000006c0+((x)*4))
+#define  NV20TCL_TX0_MATRIX__SIZE							0x00000010
+#define  NV20TCL_TX1_MATRIX(x)								(0x00000700+((x)*4))
+#define  NV20TCL_TX1_MATRIX__SIZE							0x00000010
+#define  NV20TCL_TX2_MATRIX(x)								(0x00000740+((x)*4))
+#define  NV20TCL_TX2_MATRIX__SIZE							0x00000010
+#define  NV20TCL_TX3_MATRIX(x)								(0x00000780+((x)*4))
+#define  NV20TCL_TX3_MATRIX__SIZE							0x00000010
+#define  NV20TCL_TX_GEN_COEFF_S_A(x)							(0x00000840+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_S_A__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_S_B(x)							(0x00000844+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_S_B__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_S_C(x)							(0x00000848+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_S_C__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_S_D(x)							(0x0000084c+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_S_D__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_T_A(x)							(0x00000850+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_T_A__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_T_B(x)							(0x00000854+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_T_B__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_T_C(x)							(0x00000858+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_T_C__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_T_D(x)							(0x0000085c+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_T_D__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_R_A(x)							(0x00000860+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_R_A__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_R_B(x)							(0x00000864+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_R_B__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_R_C(x)							(0x00000868+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_R_C__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_R_D(x)							(0x0000086c+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_R_D__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_Q_A(x)							(0x00000870+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_Q_A__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_Q_B(x)							(0x00000874+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_Q_B__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_Q_C(x)							(0x00000878+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_Q_C__SIZE							0x00000004
+#define  NV20TCL_TX_GEN_COEFF_Q_D(x)							(0x0000087c+((x)*64))
+#define  NV20TCL_TX_GEN_COEFF_Q_D__SIZE							0x00000004
+#define  NV20TCL_FOG_EQUATION_CONSTANT							0x000009c0
+#define  NV20TCL_FOG_EQUATION_LINEAR							0x000009c4
+#define  NV20TCL_FOG_EQUATION_QUADRATIC							0x000009c8
+#define  NV20TCL_FRONT_MATERIAL_SHININESS(x)						(0x000009e0+((x)*4))
+#define  NV20TCL_FRONT_MATERIAL_SHININESS__SIZE						0x00000006
+#define  NV20TCL_LIGHT_MODEL_FRONT_AMBIENT_R						0x00000a10
+#define  NV20TCL_LIGHT_MODEL_FRONT_AMBIENT_G						0x00000a14
+#define  NV20TCL_LIGHT_MODEL_FRONT_AMBIENT_B						0x00000a18
+#define  NV20TCL_VIEWPORT_TRANSLATE_X							0x00000a20
+#define  NV20TCL_VIEWPORT_TRANSLATE_Y							0x00000a24
+#define  NV20TCL_VIEWPORT_TRANSLATE_Z							0x00000a28
+#define  NV20TCL_VIEWPORT_TRANSLATE_W							0x00000a2c
+#define  NV20TCL_POINT_PARAMETER(x)							(0x00000a30+((x)*4))
+#define  NV20TCL_POINT_PARAMETER__SIZE							0x00000008
+#define  NV20TCL_RC_CONSTANT_COLOR0(x)							(0x00000a60+((x)*4))
+#define  NV20TCL_RC_CONSTANT_COLOR0__SIZE						0x00000008
+#define   NV20TCL_RC_CONSTANT_COLOR0_B_SHIFT						0
+#define   NV20TCL_RC_CONSTANT_COLOR0_B_MASK						0x000000ff
+#define   NV20TCL_RC_CONSTANT_COLOR0_G_SHIFT						8
+#define   NV20TCL_RC_CONSTANT_COLOR0_G_MASK						0x0000ff00
+#define   NV20TCL_RC_CONSTANT_COLOR0_R_SHIFT						16
+#define   NV20TCL_RC_CONSTANT_COLOR0_R_MASK						0x00ff0000
+#define   NV20TCL_RC_CONSTANT_COLOR0_A_SHIFT						24
+#define   NV20TCL_RC_CONSTANT_COLOR0_A_MASK						0xff000000
+#define  NV20TCL_RC_CONSTANT_COLOR1(x)							(0x00000a80+((x)*4))
+#define  NV20TCL_RC_CONSTANT_COLOR1__SIZE						0x00000008
+#define   NV20TCL_RC_CONSTANT_COLOR1_B_SHIFT						0
+#define   NV20TCL_RC_CONSTANT_COLOR1_B_MASK						0x000000ff
+#define   NV20TCL_RC_CONSTANT_COLOR1_G_SHIFT						8
+#define   NV20TCL_RC_CONSTANT_COLOR1_G_MASK						0x0000ff00
+#define   NV20TCL_RC_CONSTANT_COLOR1_R_SHIFT						16
+#define   NV20TCL_RC_CONSTANT_COLOR1_R_MASK						0x00ff0000
+#define   NV20TCL_RC_CONSTANT_COLOR1_A_SHIFT						24
+#define   NV20TCL_RC_CONSTANT_COLOR1_A_MASK						0xff000000
+#define  NV20TCL_RC_OUT_ALPHA(x)							(0x00000aa0+((x)*4))
+#define  NV20TCL_RC_OUT_ALPHA__SIZE							0x00000008
+#define   NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SHIFT						0
+#define   NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_MASK						0x0000000f
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_ZERO						0x00000000
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR0				0x00000001
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR1				0x00000002
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_FOG						0x00000003
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_PRIMARY_COLOR					0x00000004
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SECONDARY_COLOR				0x00000005
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE0					0x00000008
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE1					0x00000009
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0					0x0000000c
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE1					0x0000000d
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_E_TIMES_F					0x0000000f
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE2					0x0000000a
+#define    NV20TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE3					0x0000000b
+#define   NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SHIFT						4
+#define   NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_MASK						0x000000f0
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_ZERO						0x00000000
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR0				0x00000010
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR1				0x00000020
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_FOG						0x00000030
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_PRIMARY_COLOR					0x00000040
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SECONDARY_COLOR				0x00000050
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE0					0x00000080
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE1					0x00000090
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0					0x000000c0
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE1					0x000000d0
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000000e0
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_E_TIMES_F					0x000000f0
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE2					0x000000a0
+#define    NV20TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE3					0x000000b0
+#define   NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SHIFT						8
+#define   NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_MASK						0x00000f00
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_ZERO						0x00000000
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR0				0x00000100
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR1				0x00000200
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_FOG						0x00000300
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_PRIMARY_COLOR				0x00000400
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SECONDARY_COLOR				0x00000500
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE0					0x00000800
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE1					0x00000900
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0					0x00000c00
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE1					0x00000d00
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_E_TIMES_F					0x00000f00
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE2					0x00000a00
+#define    NV20TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE3					0x00000b00
+#define   NV20TCL_RC_OUT_ALPHA_CD_DOT_PRODUCT						(1 << 12)
+#define   NV20TCL_RC_OUT_ALPHA_AB_DOT_PRODUCT						(1 << 13)
+#define   NV20TCL_RC_OUT_ALPHA_MUX_SUM							(1 << 14)
+#define   NV20TCL_RC_OUT_ALPHA_BIAS							(1 << 15)
+#define    NV20TCL_RC_OUT_ALPHA_BIAS_NONE						0x00000000
+#define    NV20TCL_RC_OUT_ALPHA_BIAS_BIAS_BY_NEGATIVE_ONE_HALF				0x00008000
+#define   NV20TCL_RC_OUT_ALPHA_SCALE_SHIFT						17
+#define   NV20TCL_RC_OUT_ALPHA_SCALE_MASK						0x00000000
+#define    NV20TCL_RC_OUT_ALPHA_SCALE_NONE						0x00000000
+#define    NV20TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_TWO					0x00020000
+#define    NV20TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_FOUR					0x00040000
+#define    NV20TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_ONE_HALF					0x00060000
+#define  NV20TCL_RC_IN_RGB(x)								(0x00000ac0+((x)*4))
+#define  NV20TCL_RC_IN_RGB__SIZE							0x00000008
+#define   NV20TCL_RC_IN_RGB_D_INPUT_SHIFT						0
+#define   NV20TCL_RC_IN_RGB_D_INPUT_MASK						0x0000000f
+#define    NV20TCL_RC_IN_RGB_D_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR0					0x00000001
+#define    NV20TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR1					0x00000002
+#define    NV20TCL_RC_IN_RGB_D_INPUT_FOG						0x00000003
+#define    NV20TCL_RC_IN_RGB_D_INPUT_PRIMARY_COLOR					0x00000004
+#define    NV20TCL_RC_IN_RGB_D_INPUT_SECONDARY_COLOR					0x00000005
+#define    NV20TCL_RC_IN_RGB_D_INPUT_TEXTURE0						0x00000008
+#define    NV20TCL_RC_IN_RGB_D_INPUT_TEXTURE1						0x00000009
+#define    NV20TCL_RC_IN_RGB_D_INPUT_SPARE0						0x0000000c
+#define    NV20TCL_RC_IN_RGB_D_INPUT_SPARE1						0x0000000d
+#define    NV20TCL_RC_IN_RGB_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV20TCL_RC_IN_RGB_D_INPUT_E_TIMES_F						0x0000000f
+#define    NV20TCL_RC_IN_RGB_D_INPUT_TEXTURE2						0x0000000a
+#define    NV20TCL_RC_IN_RGB_D_INPUT_TEXTURE3						0x0000000b
+#define   NV20TCL_RC_IN_RGB_D_COMPONENT_USAGE						(1 <<  4)
+#define    NV20TCL_RC_IN_RGB_D_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_IN_RGB_D_COMPONENT_USAGE_ALPHA					0x00000010
+#define   NV20TCL_RC_IN_RGB_D_MAPPING_SHIFT						5
+#define   NV20TCL_RC_IN_RGB_D_MAPPING_MASK						0x000000e0
+#define    NV20TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_INVERT					0x00000020
+#define    NV20TCL_RC_IN_RGB_D_MAPPING_EXPAND_NORMAL					0x00000040
+#define    NV20TCL_RC_IN_RGB_D_MAPPING_EXPAND_NEGATE					0x00000060
+#define    NV20TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NORMAL					0x00000080
+#define    NV20TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NEGATE					0x000000a0
+#define    NV20TCL_RC_IN_RGB_D_MAPPING_SIGNED_IDENTITY					0x000000c0
+#define    NV20TCL_RC_IN_RGB_D_MAPPING_SIGNED_NEGATE					0x000000e0
+#define   NV20TCL_RC_IN_RGB_C_INPUT_SHIFT						8
+#define   NV20TCL_RC_IN_RGB_C_INPUT_MASK						0x00000f00
+#define    NV20TCL_RC_IN_RGB_C_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV20TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV20TCL_RC_IN_RGB_C_INPUT_FOG						0x00000300
+#define    NV20TCL_RC_IN_RGB_C_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV20TCL_RC_IN_RGB_C_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV20TCL_RC_IN_RGB_C_INPUT_TEXTURE0						0x00000800
+#define    NV20TCL_RC_IN_RGB_C_INPUT_TEXTURE1						0x00000900
+#define    NV20TCL_RC_IN_RGB_C_INPUT_SPARE0						0x00000c00
+#define    NV20TCL_RC_IN_RGB_C_INPUT_SPARE1						0x00000d00
+#define    NV20TCL_RC_IN_RGB_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV20TCL_RC_IN_RGB_C_INPUT_E_TIMES_F						0x00000f00
+#define    NV20TCL_RC_IN_RGB_C_INPUT_TEXTURE2						0x00000a00
+#define    NV20TCL_RC_IN_RGB_C_INPUT_TEXTURE3						0x00000b00
+#define   NV20TCL_RC_IN_RGB_C_COMPONENT_USAGE						(1 << 12)
+#define    NV20TCL_RC_IN_RGB_C_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_IN_RGB_C_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV20TCL_RC_IN_RGB_C_MAPPING_SHIFT						13
+#define   NV20TCL_RC_IN_RGB_C_MAPPING_MASK						0x0000e000
+#define    NV20TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_INVERT					0x00002000
+#define    NV20TCL_RC_IN_RGB_C_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV20TCL_RC_IN_RGB_C_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV20TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NORMAL					0x00008000
+#define    NV20TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NEGATE					0x0000a000
+#define    NV20TCL_RC_IN_RGB_C_MAPPING_SIGNED_IDENTITY					0x0000c000
+#define    NV20TCL_RC_IN_RGB_C_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV20TCL_RC_IN_RGB_B_INPUT_SHIFT						16
+#define   NV20TCL_RC_IN_RGB_B_INPUT_MASK						0x000f0000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_FOG						0x00030000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_TEXTURE0						0x00080000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_TEXTURE1						0x00090000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_SPARE0						0x000c0000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_SPARE1						0x000d0000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_E_TIMES_F						0x000f0000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_TEXTURE2						0x000a0000
+#define    NV20TCL_RC_IN_RGB_B_INPUT_TEXTURE3						0x000b0000
+#define   NV20TCL_RC_IN_RGB_B_COMPONENT_USAGE						(1 << 20)
+#define    NV20TCL_RC_IN_RGB_B_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_IN_RGB_B_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV20TCL_RC_IN_RGB_B_MAPPING_SHIFT						21
+#define   NV20TCL_RC_IN_RGB_B_MAPPING_MASK						0x00e00000
+#define    NV20TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_INVERT					0x00200000
+#define    NV20TCL_RC_IN_RGB_B_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV20TCL_RC_IN_RGB_B_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV20TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NORMAL					0x00800000
+#define    NV20TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NEGATE					0x00a00000
+#define    NV20TCL_RC_IN_RGB_B_MAPPING_SIGNED_IDENTITY					0x00c00000
+#define    NV20TCL_RC_IN_RGB_B_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV20TCL_RC_IN_RGB_A_INPUT_SHIFT						24
+#define   NV20TCL_RC_IN_RGB_A_INPUT_MASK						0x0f000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_ZERO						0x00000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_FOG						0x03000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_TEXTURE0						0x08000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_TEXTURE1						0x09000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_SPARE0						0x0c000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_SPARE1						0x0d000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_E_TIMES_F						0x0f000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_TEXTURE2						0x0a000000
+#define    NV20TCL_RC_IN_RGB_A_INPUT_TEXTURE3						0x0b000000
+#define   NV20TCL_RC_IN_RGB_A_COMPONENT_USAGE						(1 << 28)
+#define    NV20TCL_RC_IN_RGB_A_COMPONENT_USAGE_RGB					0x00000000
+#define    NV20TCL_RC_IN_RGB_A_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV20TCL_RC_IN_RGB_A_MAPPING_SHIFT						29
+#define   NV20TCL_RC_IN_RGB_A_MAPPING_MASK						0xe0000000
+#define    NV20TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV20TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_INVERT					0x20000000
+#define    NV20TCL_RC_IN_RGB_A_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV20TCL_RC_IN_RGB_A_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV20TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NORMAL					0x80000000
+#define    NV20TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NEGATE					0xa0000000
+#define    NV20TCL_RC_IN_RGB_A_MAPPING_SIGNED_IDENTITY					0xc0000000
+#define    NV20TCL_RC_IN_RGB_A_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV20TCL_VIEWPORT_SCALE_X							0x00000af0
+#define  NV20TCL_VIEWPORT_SCALE_Y							0x00000af4
+#define  NV20TCL_VIEWPORT_SCALE_Z							0x00000af8
+#define  NV20TCL_VIEWPORT_SCALE_W							0x00000afc
+#define  NV20TCL_VP_UPLOAD_INST(x)							(0x00000b00+((x)*4))
+#define  NV20TCL_VP_UPLOAD_INST__SIZE							0x00000004
+#define  NV20TCL_VP_UPLOAD_CONST(x)							(0x00000b80+((x)*4))
+#define  NV20TCL_VP_UPLOAD_CONST__SIZE							0x00000004
+#define  NV20TCL_LIGHT_BACK_AMBIENT_R(x)						(0x00000c00+((x)*64))
+#define  NV20TCL_LIGHT_BACK_AMBIENT_R__SIZE						0x00000008
+#define  NV20TCL_LIGHT_BACK_AMBIENT_G(x)						(0x00000c04+((x)*64))
+#define  NV20TCL_LIGHT_BACK_AMBIENT_G__SIZE						0x00000008
+#define  NV20TCL_LIGHT_BACK_AMBIENT_B(x)						(0x00000c08+((x)*64))
+#define  NV20TCL_LIGHT_BACK_AMBIENT_B__SIZE						0x00000008
+#define  NV20TCL_LIGHT_BACK_DIFFUSE_R(x)						(0x00000c0c+((x)*64))
+#define  NV20TCL_LIGHT_BACK_DIFFUSE_R__SIZE						0x00000008
+#define  NV20TCL_LIGHT_BACK_DIFFUSE_G(x)						(0x00000c10+((x)*64))
+#define  NV20TCL_LIGHT_BACK_DIFFUSE_G__SIZE						0x00000008
+#define  NV20TCL_LIGHT_BACK_DIFFUSE_B(x)						(0x00000c14+((x)*64))
+#define  NV20TCL_LIGHT_BACK_DIFFUSE_B__SIZE						0x00000008
+#define  NV20TCL_LIGHT_BACK_SPECULAR_R(x)						(0x00000c18+((x)*64))
+#define  NV20TCL_LIGHT_BACK_SPECULAR_R__SIZE						0x00000008
+#define  NV20TCL_LIGHT_BACK_SPECULAR_G(x)						(0x00000c1c+((x)*64))
+#define  NV20TCL_LIGHT_BACK_SPECULAR_G__SIZE						0x00000008
+#define  NV20TCL_LIGHT_BACK_SPECULAR_B(x)						(0x00000c20+((x)*64))
+#define  NV20TCL_LIGHT_BACK_SPECULAR_B__SIZE						0x00000008
+#define  NV20TCL_LIGHT_FRONT_AMBIENT_R(x)						(0x00001000+((x)*128))
+#define  NV20TCL_LIGHT_FRONT_AMBIENT_R__SIZE						0x00000008
+#define  NV20TCL_LIGHT_FRONT_AMBIENT_G(x)						(0x00001004+((x)*128))
+#define  NV20TCL_LIGHT_FRONT_AMBIENT_G__SIZE						0x00000008
+#define  NV20TCL_LIGHT_FRONT_AMBIENT_B(x)						(0x00001008+((x)*128))
+#define  NV20TCL_LIGHT_FRONT_AMBIENT_B__SIZE						0x00000008
+#define  NV20TCL_LIGHT_FRONT_DIFFUSE_R(x)						(0x0000100c+((x)*128))
+#define  NV20TCL_LIGHT_FRONT_DIFFUSE_R__SIZE						0x00000008
+#define  NV20TCL_LIGHT_FRONT_DIFFUSE_G(x)						(0x00001010+((x)*128))
+#define  NV20TCL_LIGHT_FRONT_DIFFUSE_G__SIZE						0x00000008
+#define  NV20TCL_LIGHT_FRONT_DIFFUSE_B(x)						(0x00001014+((x)*128))
+#define  NV20TCL_LIGHT_FRONT_DIFFUSE_B__SIZE						0x00000008
+#define  NV20TCL_LIGHT_FRONT_SPECULAR_R(x)						(0x00001018+((x)*128))
+#define  NV20TCL_LIGHT_FRONT_SPECULAR_R__SIZE						0x00000008
+#define  NV20TCL_LIGHT_FRONT_SPECULAR_G(x)						(0x0000101c+((x)*128))
+#define  NV20TCL_LIGHT_FRONT_SPECULAR_G__SIZE						0x00000008
+#define  NV20TCL_LIGHT_FRONT_SPECULAR_B(x)						(0x00001020+((x)*128))
+#define  NV20TCL_LIGHT_FRONT_SPECULAR_B__SIZE						0x00000008
+#define  NV20TCL_LIGHT_HALF_VECTOR_X(x)							(0x00001028+((x)*128))
+#define  NV20TCL_LIGHT_HALF_VECTOR_X__SIZE						0x00000008
+#define  NV20TCL_LIGHT_HALF_VECTOR_Y(x)							(0x0000102c+((x)*128))
+#define  NV20TCL_LIGHT_HALF_VECTOR_Y__SIZE						0x00000008
+#define  NV20TCL_LIGHT_HALF_VECTOR_Z(x)							(0x00001030+((x)*128))
+#define  NV20TCL_LIGHT_HALF_VECTOR_Z__SIZE						0x00000008
+#define  NV20TCL_LIGHT_DIRECTION_X(x)							(0x00001034+((x)*128))
+#define  NV20TCL_LIGHT_DIRECTION_X__SIZE						0x00000008
+#define  NV20TCL_LIGHT_DIRECTION_Y(x)							(0x00001038+((x)*128))
+#define  NV20TCL_LIGHT_DIRECTION_Y__SIZE						0x00000008
+#define  NV20TCL_LIGHT_DIRECTION_Z(x)							(0x0000103c+((x)*128))
+#define  NV20TCL_LIGHT_DIRECTION_Z__SIZE						0x00000008
+#define  NV20TCL_LIGHT_SPOT_CUTOFF_A(x)							(0x00001040+((x)*128))
+#define  NV20TCL_LIGHT_SPOT_CUTOFF_A__SIZE						0x00000008
+#define  NV20TCL_LIGHT_SPOT_CUTOFF_B(x)							(0x00001044+((x)*128))
+#define  NV20TCL_LIGHT_SPOT_CUTOFF_B__SIZE						0x00000008
+#define  NV20TCL_LIGHT_SPOT_CUTOFF_C(x)							(0x00001048+((x)*128))
+#define  NV20TCL_LIGHT_SPOT_CUTOFF_C__SIZE						0x00000008
+#define  NV20TCL_LIGHT_SPOT_DIR_X(x)							(0x0000104c+((x)*128))
+#define  NV20TCL_LIGHT_SPOT_DIR_X__SIZE							0x00000008
+#define  NV20TCL_LIGHT_SPOT_DIR_Y(x)							(0x00001050+((x)*128))
+#define  NV20TCL_LIGHT_SPOT_DIR_Y__SIZE							0x00000008
+#define  NV20TCL_LIGHT_SPOT_DIR_Z(x)							(0x00001054+((x)*128))
+#define  NV20TCL_LIGHT_SPOT_DIR_Z__SIZE							0x00000008
+#define  NV20TCL_LIGHT_SPOT_CUTOFF_D(x)							(0x00001058+((x)*128))
+#define  NV20TCL_LIGHT_SPOT_CUTOFF_D__SIZE						0x00000008
+#define  NV20TCL_LIGHT_POSITION_X(x)							(0x0000105c+((x)*128))
+#define  NV20TCL_LIGHT_POSITION_X__SIZE							0x00000008
+#define  NV20TCL_LIGHT_POSITION_Y(x)							(0x00001060+((x)*128))
+#define  NV20TCL_LIGHT_POSITION_Y__SIZE							0x00000008
+#define  NV20TCL_LIGHT_POSITION_Z(x)							(0x00001064+((x)*128))
+#define  NV20TCL_LIGHT_POSITION_Z__SIZE							0x00000008
+#define  NV20TCL_LIGHT_ATTENUATION_CONSTANT(x)						(0x00001068+((x)*128))
+#define  NV20TCL_LIGHT_ATTENUATION_CONSTANT__SIZE					0x00000008
+#define  NV20TCL_LIGHT_ATTENUATION_LINEAR(x)						(0x0000106c+((x)*128))
+#define  NV20TCL_LIGHT_ATTENUATION_LINEAR__SIZE						0x00000008
+#define  NV20TCL_LIGHT_ATTENUATION_QUADRATIC(x)						(0x00001070+((x)*128))
+#define  NV20TCL_LIGHT_ATTENUATION_QUADRATIC__SIZE					0x00000008
+#define  NV20TCL_POLYGON_STIPPLE_ENABLE							0x0000147c
+#define  NV20TCL_POLYGON_STIPPLE_PATTERN(x)						(0x00001480+((x)*4))
+#define  NV20TCL_POLYGON_STIPPLE_PATTERN__SIZE						0x00000020
+#define  NV20TCL_VERTEX_POS_3F_X							0x00001500
+#define  NV20TCL_VERTEX_POS_3F_Y							0x00001504
+#define  NV20TCL_VERTEX_POS_3F_Z							0x00001508
+#define  NV20TCL_VERTEX_POS_4F_X							0x00001518
+#define  NV20TCL_VERTEX_POS_4F_Y							0x0000151c
+#define  NV20TCL_VERTEX_POS_4F_Z							0x00001520
+#define  NV20TCL_VERTEX_POS_3I_XY							0x00001528
+#define   NV20TCL_VERTEX_POS_3I_XY_X_SHIFT						0
+#define   NV20TCL_VERTEX_POS_3I_XY_X_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_POS_3I_XY_Y_SHIFT						16
+#define   NV20TCL_VERTEX_POS_3I_XY_Y_MASK						0xffff0000
+#define  NV20TCL_VERTEX_POS_3I_Z							0x0000152c
+#define   NV20TCL_VERTEX_POS_3I_Z_Z_SHIFT						0
+#define   NV20TCL_VERTEX_POS_3I_Z_Z_MASK						0x0000ffff
+#define  NV20TCL_VERTEX_NOR_3F_X							0x00001530
+#define  NV20TCL_VERTEX_NOR_3F_Y							0x00001534
+#define  NV20TCL_VERTEX_NOR_3F_Z							0x00001538
+#define  NV20TCL_VERTEX_NOR_3I_XY							0x00001540
+#define   NV20TCL_VERTEX_NOR_3I_XY_X_SHIFT						0
+#define   NV20TCL_VERTEX_NOR_3I_XY_X_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_NOR_3I_XY_Y_SHIFT						16
+#define   NV20TCL_VERTEX_NOR_3I_XY_Y_MASK						0xffff0000
+#define  NV20TCL_VERTEX_NOR_3I_Z							0x00001544
+#define   NV20TCL_VERTEX_NOR_3I_Z_Z_SHIFT						0
+#define   NV20TCL_VERTEX_NOR_3I_Z_Z_MASK						0x0000ffff
+#define  NV20TCL_VERTEX_COL_4F_X							0x00001550
+#define  NV20TCL_VERTEX_COL_4F_Y							0x00001554
+#define  NV20TCL_VERTEX_COL_4F_Z							0x00001558
+#define  NV20TCL_VERTEX_COL_4F_W							0x0000155c
+#define  NV20TCL_VERTEX_COL_3F_X							0x00001560
+#define  NV20TCL_VERTEX_COL_3F_Y							0x00001564
+#define  NV20TCL_VERTEX_COL_3F_Z							0x00001568
+#define  NV20TCL_VERTEX_COL_4I								0x0000156c
+#define   NV20TCL_VERTEX_COL_4I_R_SHIFT							0
+#define   NV20TCL_VERTEX_COL_4I_R_MASK							0x000000ff
+#define   NV20TCL_VERTEX_COL_4I_G_SHIFT							8
+#define   NV20TCL_VERTEX_COL_4I_G_MASK							0x0000ff00
+#define   NV20TCL_VERTEX_COL_4I_B_SHIFT							16
+#define   NV20TCL_VERTEX_COL_4I_B_MASK							0x00ff0000
+#define   NV20TCL_VERTEX_COL_4I_A_SHIFT							24
+#define   NV20TCL_VERTEX_COL_4I_A_MASK							0xff000000
+#define  NV20TCL_VERTEX_COL2_3F_X							0x00001580
+#define  NV20TCL_VERTEX_COL2_3F_Y							0x00001584
+#define  NV20TCL_VERTEX_COL2_3F_Z							0x00001588
+#define  NV20TCL_VERTEX_COL2_4I								0x0000158c
+#define   NV20TCL_VERTEX_COL2_4I_R_SHIFT						0
+#define   NV20TCL_VERTEX_COL2_4I_R_MASK							0x000000ff
+#define   NV20TCL_VERTEX_COL2_4I_G_SHIFT						8
+#define   NV20TCL_VERTEX_COL2_4I_G_MASK							0x0000ff00
+#define   NV20TCL_VERTEX_COL2_4I_B_SHIFT						16
+#define   NV20TCL_VERTEX_COL2_4I_B_MASK							0x00ff0000
+#define   NV20TCL_VERTEX_COL2_4I_A_SHIFT						24
+#define   NV20TCL_VERTEX_COL2_4I_A_MASK							0xff000000
+#define  NV20TCL_VERTEX_TX0_2F_S							0x00001590
+#define  NV20TCL_VERTEX_TX0_2F_T							0x00001594
+#define  NV20TCL_VERTEX_TX0_2I								0x00001598
+#define   NV20TCL_VERTEX_TX0_2I_S_SHIFT							0
+#define   NV20TCL_VERTEX_TX0_2I_S_MASK							0x0000ffff
+#define   NV20TCL_VERTEX_TX0_2I_T_SHIFT							16
+#define   NV20TCL_VERTEX_TX0_2I_T_MASK							0xffff0000
+#define  NV20TCL_VERTEX_TX0_4F_S							0x000015a0
+#define  NV20TCL_VERTEX_TX0_4F_T							0x000015a4
+#define  NV20TCL_VERTEX_TX0_4F_R							0x000015a8
+#define  NV20TCL_VERTEX_TX0_4F_Q							0x000015ac
+#define  NV20TCL_VERTEX_TX0_4I_ST							0x000015b0
+#define   NV20TCL_VERTEX_TX0_4I_ST_S_SHIFT						0
+#define   NV20TCL_VERTEX_TX0_4I_ST_S_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_TX0_4I_ST_T_SHIFT						16
+#define   NV20TCL_VERTEX_TX0_4I_ST_T_MASK						0xffff0000
+#define  NV20TCL_VERTEX_TX0_4I_RQ							0x000015b4
+#define   NV20TCL_VERTEX_TX0_4I_RQ_R_SHIFT						0
+#define   NV20TCL_VERTEX_TX0_4I_RQ_R_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_TX0_4I_RQ_Q_SHIFT						16
+#define   NV20TCL_VERTEX_TX0_4I_RQ_Q_MASK						0xffff0000
+#define  NV20TCL_VERTEX_TX1_2F_S							0x000015b8
+#define  NV20TCL_VERTEX_TX1_2F_T							0x000015bc
+#define  NV20TCL_VERTEX_TX1_2I								0x000015c0
+#define   NV20TCL_VERTEX_TX1_2I_S_SHIFT							0
+#define   NV20TCL_VERTEX_TX1_2I_S_MASK							0x0000ffff
+#define   NV20TCL_VERTEX_TX1_2I_T_SHIFT							16
+#define   NV20TCL_VERTEX_TX1_2I_T_MASK							0xffff0000
+#define  NV20TCL_VERTEX_TX1_4F_S							0x000015c8
+#define  NV20TCL_VERTEX_TX1_4F_T							0x000015cc
+#define  NV20TCL_VERTEX_TX1_4F_R							0x000015d0
+#define  NV20TCL_VERTEX_TX1_4F_Q							0x000015d4
+#define  NV20TCL_VERTEX_TX1_4I_ST							0x000015d8
+#define   NV20TCL_VERTEX_TX1_4I_ST_S_SHIFT						0
+#define   NV20TCL_VERTEX_TX1_4I_ST_S_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_TX1_4I_ST_T_SHIFT						16
+#define   NV20TCL_VERTEX_TX1_4I_ST_T_MASK						0xffff0000
+#define  NV20TCL_VERTEX_TX1_4I_RQ							0x000015dc
+#define   NV20TCL_VERTEX_TX1_4I_RQ_R_SHIFT						0
+#define   NV20TCL_VERTEX_TX1_4I_RQ_R_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_TX1_4I_RQ_Q_SHIFT						16
+#define   NV20TCL_VERTEX_TX1_4I_RQ_Q_MASK						0xffff0000
+#define  NV20TCL_VERTEX_TX2_2F_S							0x000015e0
+#define  NV20TCL_VERTEX_TX2_2F_T							0x000015e4
+#define  NV20TCL_VERTEX_TX2_2I								0x000015e8
+#define   NV20TCL_VERTEX_TX2_2I_S_SHIFT							0
+#define   NV20TCL_VERTEX_TX2_2I_S_MASK							0x0000ffff
+#define   NV20TCL_VERTEX_TX2_2I_T_SHIFT							16
+#define   NV20TCL_VERTEX_TX2_2I_T_MASK							0xffff0000
+#define  NV20TCL_VERTEX_TX2_4F_S							0x000015f0
+#define  NV20TCL_VERTEX_TX2_4F_T							0x000015f4
+#define  NV20TCL_VERTEX_TX2_4F_R							0x000015f8
+#define  NV20TCL_VERTEX_TX2_4F_Q							0x000015fc
+#define  NV20TCL_VERTEX_TX2_4I_ST							0x00001600
+#define   NV20TCL_VERTEX_TX2_4I_ST_S_SHIFT						0
+#define   NV20TCL_VERTEX_TX2_4I_ST_S_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_TX2_4I_ST_T_SHIFT						16
+#define   NV20TCL_VERTEX_TX2_4I_ST_T_MASK						0xffff0000
+#define  NV20TCL_VERTEX_TX2_4I_RQ							0x00001604
+#define   NV20TCL_VERTEX_TX2_4I_RQ_R_SHIFT						0
+#define   NV20TCL_VERTEX_TX2_4I_RQ_R_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_TX2_4I_RQ_Q_SHIFT						16
+#define   NV20TCL_VERTEX_TX2_4I_RQ_Q_MASK						0xffff0000
+#define  NV20TCL_VERTEX_TX3_2F_S							0x00001608
+#define  NV20TCL_VERTEX_TX3_2F_T							0x0000160c
+#define  NV20TCL_VERTEX_TX3_2I								0x00001610
+#define   NV20TCL_VERTEX_TX3_2I_S_SHIFT							0
+#define   NV20TCL_VERTEX_TX3_2I_S_MASK							0x0000ffff
+#define   NV20TCL_VERTEX_TX3_2I_T_SHIFT							16
+#define   NV20TCL_VERTEX_TX3_2I_T_MASK							0xffff0000
+#define  NV20TCL_VERTEX_TX3_4F_S							0x00001620
+#define  NV20TCL_VERTEX_TX3_4F_T							0x00001624
+#define  NV20TCL_VERTEX_TX3_4F_R							0x00001628
+#define  NV20TCL_VERTEX_TX3_4F_Q							0x0000162c
+#define  NV20TCL_VERTEX_TX3_4I_ST							0x00001630
+#define   NV20TCL_VERTEX_TX3_4I_ST_S_SHIFT						0
+#define   NV20TCL_VERTEX_TX3_4I_ST_S_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_TX3_4I_ST_T_SHIFT						16
+#define   NV20TCL_VERTEX_TX3_4I_ST_T_MASK						0xffff0000
+#define  NV20TCL_VERTEX_TX3_4I_RQ							0x00001634
+#define   NV20TCL_VERTEX_TX3_4I_RQ_R_SHIFT						0
+#define   NV20TCL_VERTEX_TX3_4I_RQ_R_MASK						0x0000ffff
+#define   NV20TCL_VERTEX_TX3_4I_RQ_Q_SHIFT						16
+#define   NV20TCL_VERTEX_TX3_4I_RQ_Q_MASK						0xffff0000
+#define  NV20TCL_VERTEX_FOG_1F								0x00001698
+#define  NV20TCL_EDGEFLAG_ENABLE							0x000016bc
+#define  NV20TCL_VTX_CACHE_INVALIDATE							0x00001710
+#define  NV20TCL_VTXBUF_ADDRESS(x)							(0x00001720+((x)*4))
+#define  NV20TCL_VTXBUF_ADDRESS__SIZE							0x00000010
+#define   NV20TCL_VTXBUF_ADDRESS_DMA1							(1 << 31)
+#define   NV20TCL_VTXBUF_ADDRESS_OFFSET_SHIFT						0
+#define   NV20TCL_VTXBUF_ADDRESS_OFFSET_MASK						0x0fffffff
+#define  NV20TCL_VTXFMT(x)								(0x00001760+((x)*4))
+#define  NV20TCL_VTXFMT__SIZE								0x00000010
+#define   NV20TCL_VTXFMT_TYPE_SHIFT							0
+#define   NV20TCL_VTXFMT_TYPE_MASK							0x0000000f
+#define    NV20TCL_VTXFMT_TYPE_FLOAT							0x00000002
+#define    NV20TCL_VTXFMT_TYPE_UBYTE							0x00000004
+#define    NV20TCL_VTXFMT_TYPE_USHORT							0x00000005
+#define   NV20TCL_VTXFMT_SIZE_SHIFT							4
+#define   NV20TCL_VTXFMT_SIZE_MASK							0x000000f0
+#define   NV20TCL_VTXFMT_STRIDE_SHIFT							8
+#define   NV20TCL_VTXFMT_STRIDE_MASK							0x0000ff00
+#define  NV20TCL_LIGHT_MODEL_BACK_AMBIENT_R						0x000017a0
+#define  NV20TCL_LIGHT_MODEL_BACK_AMBIENT_G						0x000017a4
+#define  NV20TCL_LIGHT_MODEL_BACK_AMBIENT_B						0x000017a8
+#define  NV20TCL_MATERIAL_FACTOR_BACK_A							0x000017ac
+#define  NV20TCL_MATERIAL_FACTOR_BACK_R							0x000017b0
+#define  NV20TCL_MATERIAL_FACTOR_BACK_G							0x000017b4
+#define  NV20TCL_MATERIAL_FACTOR_BACK_B							0x000017b8
+#define  NV20TCL_COLOR_LOGIC_OP_ENABLE							0x000017bc
+#define  NV20TCL_COLOR_LOGIC_OP_OP							0x000017c0
+#define   NV20TCL_COLOR_LOGIC_OP_OP_CLEAR						0x00001500
+#define   NV20TCL_COLOR_LOGIC_OP_OP_AND							0x00001501
+#define   NV20TCL_COLOR_LOGIC_OP_OP_AND_REVERSE						0x00001502
+#define   NV20TCL_COLOR_LOGIC_OP_OP_COPY						0x00001503
+#define   NV20TCL_COLOR_LOGIC_OP_OP_AND_INVERTED					0x00001504
+#define   NV20TCL_COLOR_LOGIC_OP_OP_NOOP						0x00001505
+#define   NV20TCL_COLOR_LOGIC_OP_OP_XOR							0x00001506
+#define   NV20TCL_COLOR_LOGIC_OP_OP_OR							0x00001507
+#define   NV20TCL_COLOR_LOGIC_OP_OP_NOR							0x00001508
+#define   NV20TCL_COLOR_LOGIC_OP_OP_EQUIV						0x00001509
+#define   NV20TCL_COLOR_LOGIC_OP_OP_INVERT						0x0000150a
+#define   NV20TCL_COLOR_LOGIC_OP_OP_OR_REVERSE						0x0000150b
+#define   NV20TCL_COLOR_LOGIC_OP_OP_COPY_INVERTED					0x0000150c
+#define   NV20TCL_COLOR_LOGIC_OP_OP_OR_INVERTED						0x0000150d
+#define   NV20TCL_COLOR_LOGIC_OP_OP_NAND						0x0000150e
+#define   NV20TCL_COLOR_LOGIC_OP_OP_SET							0x0000150f
+#define  NV20TCL_LIGHT_MODEL_TWO_SIDE_ENABLE						0x000017c4
+#define  NV20TCL_TX_SHADER_CULL_MODE							0x000017f8
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX0_S						(1 <<  0)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX0_S_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX0_S_LESS					0x00000001
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX0_T						(1 <<  1)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX0_T_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX0_T_LESS					0x00000002
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX0_R						(1 <<  2)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX0_R_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX0_R_LESS					0x00000004
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX0_Q						(1 <<  3)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX0_Q_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX0_Q_LESS					0x00000008
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX1_S						(1 <<  4)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX1_S_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX1_S_LESS					0x00000010
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX1_T						(1 <<  5)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX1_T_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX1_T_LESS					0x00000020
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX1_R						(1 <<  6)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX1_R_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX1_R_LESS					0x00000040
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX1_Q						(1 <<  7)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX1_Q_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX1_Q_LESS					0x00000080
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX2_S						(1 <<  8)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX2_S_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX2_S_LESS					0x00000100
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX2_T						(1 <<  9)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX2_T_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX2_T_LESS					0x00000200
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX2_R						(1 << 10)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX2_R_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX2_R_LESS					0x00000400
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX2_Q						(1 << 11)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX2_Q_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX2_Q_LESS					0x00000800
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX3_S						(1 << 12)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX3_S_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX3_S_LESS					0x00001000
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX3_T						(1 << 13)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX3_T_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX3_T_LESS					0x00002000
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX3_R						(1 << 14)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX3_R_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX3_R_LESS					0x00004000
+#define   NV20TCL_TX_SHADER_CULL_MODE_TX3_Q						(1 << 15)
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX3_Q_GEQUAL					0x00000000
+#define    NV20TCL_TX_SHADER_CULL_MODE_TX3_Q_LESS					0x00008000
+#define  NV20TCL_VERTEX_BEGIN_END							0x000017fc
+#define   NV20TCL_VERTEX_BEGIN_END_STOP							0x00000000
+#define   NV20TCL_VERTEX_BEGIN_END_POINTS						0x00000001
+#define   NV20TCL_VERTEX_BEGIN_END_LINES						0x00000002
+#define   NV20TCL_VERTEX_BEGIN_END_LINE_LOOP						0x00000003
+#define   NV20TCL_VERTEX_BEGIN_END_LINE_STRIP						0x00000004
+#define   NV20TCL_VERTEX_BEGIN_END_TRIANGLES						0x00000005
+#define   NV20TCL_VERTEX_BEGIN_END_TRIANGLE_STRIP					0x00000006
+#define   NV20TCL_VERTEX_BEGIN_END_TRIANGLE_FAN						0x00000007
+#define   NV20TCL_VERTEX_BEGIN_END_QUADS						0x00000008
+#define   NV20TCL_VERTEX_BEGIN_END_QUAD_STRIP						0x00000009
+#define   NV20TCL_VERTEX_BEGIN_END_POLYGON						0x0000000a
+#define  NV20TCL_VB_ELEMENT_U16								0x00001800
+#define   NV20TCL_VB_ELEMENT_U16_I0_SHIFT						0
+#define   NV20TCL_VB_ELEMENT_U16_I0_MASK						0x0000ffff
+#define   NV20TCL_VB_ELEMENT_U16_I1_SHIFT						16
+#define   NV20TCL_VB_ELEMENT_U16_I1_MASK						0xffff0000
+#define  NV20TCL_VB_ELEMENT_U32								0x00001808
+#define  NV20TCL_VB_VERTEX_BATCH							0x00001810
+#define   NV20TCL_VB_VERTEX_BATCH_OFFSET_SHIFT						0
+#define   NV20TCL_VB_VERTEX_BATCH_OFFSET_MASK						0x00ffffff
+#define   NV20TCL_VB_VERTEX_BATCH_COUNT_SHIFT						24
+#define   NV20TCL_VB_VERTEX_BATCH_COUNT_MASK						0xff000000
+#define  NV20TCL_VERTEX_DATA								0x00001818
+#define  NV20TCL_TX_SHADER_CONST_EYE_X							0x0000181c
+#define  NV20TCL_TX_SHADER_CONST_EYE_Y							0x00001820
+#define  NV20TCL_TX_SHADER_CONST_EYE_Z							0x00001824
+#define  NV20TCL_VTX_ATTR_4F_X(x)							(0x00001a00+((x)*16))
+#define  NV20TCL_VTX_ATTR_4F_X__SIZE							0x00000010
+#define  NV20TCL_VTX_ATTR_4F_Y(x)							(0x00001a04+((x)*16))
+#define  NV20TCL_VTX_ATTR_4F_Y__SIZE							0x00000010
+#define  NV20TCL_VTX_ATTR_4F_Z(x)							(0x00001a08+((x)*16))
+#define  NV20TCL_VTX_ATTR_4F_Z__SIZE							0x00000010
+#define  NV20TCL_VTX_ATTR_4F_W(x)							(0x00001a0c+((x)*16))
+#define  NV20TCL_VTX_ATTR_4F_W__SIZE							0x00000010
+#define  NV20TCL_TX_OFFSET(x)								(0x00001b00+((x)*64))
+#define  NV20TCL_TX_OFFSET__SIZE							0x00000004
+#define  NV20TCL_TX_FORMAT(x)								(0x00001b04+((x)*64))
+#define  NV20TCL_TX_FORMAT__SIZE							0x00000004
+#define   NV20TCL_TX_FORMAT_DMA0							(1 <<  0)
+#define   NV20TCL_TX_FORMAT_DMA1							(1 <<  1)
+#define   NV20TCL_TX_FORMAT_CUBIC							(1 <<  2)
+#define   NV20TCL_TX_FORMAT_NO_BORDER							(1 <<  3)
+#define   NV20TCL_TX_FORMAT_DIMS_SHIFT							4
+#define   NV20TCL_TX_FORMAT_DIMS_MASK							0x000000f0
+#define    NV20TCL_TX_FORMAT_DIMS_1D							0x00000010
+#define    NV20TCL_TX_FORMAT_DIMS_2D							0x00000020
+#define    NV20TCL_TX_FORMAT_DIMS_3D							0x00000030
+#define   NV20TCL_TX_FORMAT_FORMAT_SHIFT						8
+#define   NV20TCL_TX_FORMAT_FORMAT_MASK							0x0000ff00
+#define    NV20TCL_TX_FORMAT_FORMAT_L8							0x00000000
+#define    NV20TCL_TX_FORMAT_FORMAT_A8							0x00000100
+#define    NV20TCL_TX_FORMAT_FORMAT_A1R5G5B5						0x00000200
+#define    NV20TCL_TX_FORMAT_FORMAT_A4R4G4B4						0x00000400
+#define    NV20TCL_TX_FORMAT_FORMAT_R5G6B5						0x00000500
+#define    NV20TCL_TX_FORMAT_FORMAT_A8R8G8B8						0x00000600
+#define    NV20TCL_TX_FORMAT_FORMAT_X8R8G8B8						0x00000700
+#define    NV20TCL_TX_FORMAT_FORMAT_INDEX8						0x00000b00
+#define    NV20TCL_TX_FORMAT_FORMAT_DXT1						0x00000c00
+#define    NV20TCL_TX_FORMAT_FORMAT_DXT3						0x00000e00
+#define    NV20TCL_TX_FORMAT_FORMAT_DXT5						0x00000f00
+#define    NV20TCL_TX_FORMAT_FORMAT_A1R5G5B5_RECT					0x00001000
+#define    NV20TCL_TX_FORMAT_FORMAT_R5G6B5_RECT						0x00001100
+#define    NV20TCL_TX_FORMAT_FORMAT_A8R8G8B8_RECT					0x00001200
+#define    NV20TCL_TX_FORMAT_FORMAT_L8_RECT						0x00001300
+#define    NV20TCL_TX_FORMAT_FORMAT_DSDT8_RECT						0x00001700
+#define    NV20TCL_TX_FORMAT_FORMAT_A8L8						0x00001a00
+#define    NV20TCL_TX_FORMAT_FORMAT_A8_RECT						0x00001b00
+#define    NV20TCL_TX_FORMAT_FORMAT_A4R4G4B4_RECT					0x00001d00
+#define    NV20TCL_TX_FORMAT_FORMAT_R8G8B8_RECT						0x00001e00
+#define    NV20TCL_TX_FORMAT_FORMAT_A8L8_RECT						0x00002000
+#define    NV20TCL_TX_FORMAT_FORMAT_DSDT8						0x00002800
+#define    NV20TCL_TX_FORMAT_FORMAT_HILO16						0x00003300
+#define    NV20TCL_TX_FORMAT_FORMAT_HILO16_RECT						0x00003600
+#define    NV20TCL_TX_FORMAT_FORMAT_HILO8						0x00004400
+#define    NV20TCL_TX_FORMAT_FORMAT_SIGNED_HILO8					0x00004500
+#define    NV20TCL_TX_FORMAT_FORMAT_HILO8_RECT						0x00004600
+#define    NV20TCL_TX_FORMAT_FORMAT_SIGNED_HILO8_RECT					0x00004700
+#define    NV20TCL_TX_FORMAT_FORMAT_A16							0x00003200
+#define    NV20TCL_TX_FORMAT_FORMAT_A16_RECT						0x00003500
+#define    NV20TCL_TX_FORMAT_FORMAT_FLOAT_RGBA16_NV					0x00004a00
+#define    NV20TCL_TX_FORMAT_FORMAT_FLOAT_RGBA32_NV					0x00004b00
+#define    NV20TCL_TX_FORMAT_FORMAT_FLOAT_R32_NV					0x00004c00
+#define   NV20TCL_TX_FORMAT_MIPMAP							(1 << 19)
+#define   NV20TCL_TX_FORMAT_BASE_SIZE_U_SHIFT						20
+#define   NV20TCL_TX_FORMAT_BASE_SIZE_U_MASK						0x00f00000
+#define   NV20TCL_TX_FORMAT_BASE_SIZE_V_SHIFT						24
+#define   NV20TCL_TX_FORMAT_BASE_SIZE_V_MASK						0x0f000000
+#define   NV20TCL_TX_FORMAT_BASE_SIZE_W_SHIFT						28
+#define   NV20TCL_TX_FORMAT_BASE_SIZE_W_MASK						0xf0000000
+#define  NV20TCL_TX_WRAP(x)								(0x00001b08+((x)*64))
+#define  NV20TCL_TX_WRAP__SIZE								0x00000004
+#define   NV20TCL_TX_WRAP_S_SHIFT							0
+#define   NV20TCL_TX_WRAP_S_MASK							0x000000ff
+#define    NV20TCL_TX_WRAP_S_REPEAT							0x00000001
+#define    NV20TCL_TX_WRAP_S_MIRRORED_REPEAT						0x00000002
+#define    NV20TCL_TX_WRAP_S_CLAMP_TO_EDGE						0x00000003
+#define    NV20TCL_TX_WRAP_S_CLAMP_TO_BORDER						0x00000004
+#define    NV20TCL_TX_WRAP_S_CLAMP							0x00000005
+#define   NV20TCL_TX_WRAP_T_SHIFT							8
+#define   NV20TCL_TX_WRAP_T_MASK							0x00000f00
+#define    NV20TCL_TX_WRAP_T_REPEAT							0x00000100
+#define    NV20TCL_TX_WRAP_T_MIRRORED_REPEAT						0x00000200
+#define    NV20TCL_TX_WRAP_T_CLAMP_TO_EDGE						0x00000300
+#define    NV20TCL_TX_WRAP_T_CLAMP_TO_BORDER						0x00000400
+#define    NV20TCL_TX_WRAP_T_CLAMP							0x00000500
+#define   NV20TCL_TX_WRAP_R_SHIFT							16
+#define   NV20TCL_TX_WRAP_R_MASK							0x000f0000
+#define    NV20TCL_TX_WRAP_R_REPEAT							0x00010000
+#define    NV20TCL_TX_WRAP_R_MIRRORED_REPEAT						0x00020000
+#define    NV20TCL_TX_WRAP_R_CLAMP_TO_EDGE						0x00030000
+#define    NV20TCL_TX_WRAP_R_CLAMP_TO_BORDER						0x00040000
+#define    NV20TCL_TX_WRAP_R_CLAMP							0x00050000
+#define  NV20TCL_TX_ENABLE(x)								(0x00001b0c+((x)*64))
+#define  NV20TCL_TX_ENABLE__SIZE							0x00000004
+#define   NV20TCL_TX_ENABLE_ANISO_SHIFT							4
+#define   NV20TCL_TX_ENABLE_ANISO_MASK							0x00000030
+#define    NV20TCL_TX_ENABLE_ANISO_NONE							0x00000000
+#define    NV20TCL_TX_ENABLE_ANISO_2X							0x00000010
+#define    NV20TCL_TX_ENABLE_ANISO_4X							0x00000020
+#define    NV20TCL_TX_ENABLE_ANISO_8X							0x00000030
+#define   NV20TCL_TX_ENABLE_MIPMAP_MAX_LOD_SHIFT					14
+#define   NV20TCL_TX_ENABLE_MIPMAP_MAX_LOD_MASK						0x0003c000
+#define   NV20TCL_TX_ENABLE_MIPMAP_MIN_LOD_SHIFT					26
+#define   NV20TCL_TX_ENABLE_MIPMAP_MIN_LOD_MASK						0x3c000000
+#define   NV20TCL_TX_ENABLE_ENABLE							(1 << 30)
+#define  NV20TCL_TX_NPOT_PITCH(x)							(0x00001b10+((x)*64))
+#define  NV20TCL_TX_NPOT_PITCH__SIZE							0x00000004
+#define   NV20TCL_TX_NPOT_PITCH_PITCH_SHIFT						16
+#define   NV20TCL_TX_NPOT_PITCH_PITCH_MASK						0xffff0000
+#define  NV20TCL_TX_FILTER(x)								(0x00001b14+((x)*64))
+#define  NV20TCL_TX_FILTER__SIZE							0x00000004
+#define   NV20TCL_TX_FILTER_LOD_BIAS_SHIFT						8
+#define   NV20TCL_TX_FILTER_LOD_BIAS_MASK						0x00000f00
+#define   NV20TCL_TX_FILTER_MINIFY_SHIFT						16
+#define   NV20TCL_TX_FILTER_MINIFY_MASK							0x000f0000
+#define    NV20TCL_TX_FILTER_MINIFY_NEAREST						0x00010000
+#define    NV20TCL_TX_FILTER_MINIFY_LINEAR						0x00020000
+#define    NV20TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST				0x00030000
+#define    NV20TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST				0x00040000
+#define    NV20TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR				0x00050000
+#define    NV20TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR				0x00060000
+#define   NV20TCL_TX_FILTER_MAGNIFY_SHIFT						24
+#define   NV20TCL_TX_FILTER_MAGNIFY_MASK						0x0f000000
+#define    NV20TCL_TX_FILTER_MAGNIFY_NEAREST						0x01000000
+#define    NV20TCL_TX_FILTER_MAGNIFY_LINEAR						0x02000000
+#define  NV20TCL_TX_NPOT_SIZE(x)							(0x00001b1c+((x)*64))
+#define  NV20TCL_TX_NPOT_SIZE__SIZE							0x00000004
+#define   NV20TCL_TX_NPOT_SIZE_H_SHIFT							0
+#define   NV20TCL_TX_NPOT_SIZE_H_MASK							0x0000ffff
+#define   NV20TCL_TX_NPOT_SIZE_W_SHIFT							16
+#define   NV20TCL_TX_NPOT_SIZE_W_MASK							0xffff0000
+#define  NV20TCL_TX_PALETTE_OFFSET(x)							(0x00001b20+((x)*64))
+#define  NV20TCL_TX_PALETTE_OFFSET__SIZE						0x00000004
+#define  NV20TCL_TX_BORDER_COLOR(x)							(0x00001b24+((x)*64))
+#define  NV20TCL_TX_BORDER_COLOR__SIZE							0x00000004
+#define   NV20TCL_TX_BORDER_COLOR_B_SHIFT						0
+#define   NV20TCL_TX_BORDER_COLOR_B_MASK						0x000000ff
+#define   NV20TCL_TX_BORDER_COLOR_G_SHIFT						8
+#define   NV20TCL_TX_BORDER_COLOR_G_MASK						0x0000ff00
+#define   NV20TCL_TX_BORDER_COLOR_R_SHIFT						16
+#define   NV20TCL_TX_BORDER_COLOR_R_MASK						0x00ff0000
+#define   NV20TCL_TX_BORDER_COLOR_A_SHIFT						24
+#define   NV20TCL_TX_BORDER_COLOR_A_MASK						0xff000000
+#define  NV20TCL_TX_SHADER_OFFSET_MATRIX00(x)						(0x00001b28+((x)*64))
+#define  NV20TCL_TX_SHADER_OFFSET_MATRIX00__SIZE					0x00000004
+#define  NV20TCL_TX_SHADER_OFFSET_MATRIX01(x)						(0x00001b2c+((x)*64))
+#define  NV20TCL_TX_SHADER_OFFSET_MATRIX01__SIZE					0x00000004
+#define  NV20TCL_TX_SHADER_OFFSET_MATRIX11(x)						(0x00001b30+((x)*64))
+#define  NV20TCL_TX_SHADER_OFFSET_MATRIX11__SIZE					0x00000004
+#define  NV20TCL_TX_SHADER_OFFSET_MATRIX10(x)						(0x00001b34+((x)*64))
+#define  NV20TCL_TX_SHADER_OFFSET_MATRIX10__SIZE					0x00000004
+#define  NV20TCL_DEPTH_UNK17D8								0x00001d78
+#define   NV20TCL_DEPTH_UNK17D8_CLAMP_SHIFT						4
+#define   NV20TCL_DEPTH_UNK17D8_CLAMP_MASK						0x000000f0
+#define  NV20TCL_MULTISAMPLE_CONTROL							0x00001d7c
+#define  NV20TCL_CLEAR_DEPTH_VALUE							0x00001d8c
+#define  NV20TCL_CLEAR_VALUE								0x00001d90
+#define  NV20TCL_CLEAR_BUFFERS								0x00001d94
+#define   NV20TCL_CLEAR_BUFFERS_COLOR_A							(1 <<  7)
+#define   NV20TCL_CLEAR_BUFFERS_COLOR_B							(1 <<  6)
+#define   NV20TCL_CLEAR_BUFFERS_COLOR_G							(1 <<  5)
+#define   NV20TCL_CLEAR_BUFFERS_COLOR_R							(1 <<  4)
+#define   NV20TCL_CLEAR_BUFFERS_STENCIL							(1 <<  1)
+#define   NV20TCL_CLEAR_BUFFERS_DEPTH							(1 <<  0)
+#define  NV20TCL_RC_COLOR0								0x00001e20
+#define   NV20TCL_RC_COLOR0_B_SHIFT							0
+#define   NV20TCL_RC_COLOR0_B_MASK							0x000000ff
+#define   NV20TCL_RC_COLOR0_G_SHIFT							8
+#define   NV20TCL_RC_COLOR0_G_MASK							0x0000ff00
+#define   NV20TCL_RC_COLOR0_R_SHIFT							16
+#define   NV20TCL_RC_COLOR0_R_MASK							0x00ff0000
+#define   NV20TCL_RC_COLOR0_A_SHIFT							24
+#define   NV20TCL_RC_COLOR0_A_MASK							0xff000000
+#define  NV20TCL_RC_COLOR1								0x00001e24
+#define   NV20TCL_RC_COLOR1_B_SHIFT							0
+#define   NV20TCL_RC_COLOR1_B_MASK							0x000000ff
+#define   NV20TCL_RC_COLOR1_G_SHIFT							8
+#define   NV20TCL_RC_COLOR1_G_MASK							0x0000ff00
+#define   NV20TCL_RC_COLOR1_R_SHIFT							16
+#define   NV20TCL_RC_COLOR1_R_MASK							0x00ff0000
+#define   NV20TCL_RC_COLOR1_A_SHIFT							24
+#define   NV20TCL_RC_COLOR1_A_MASK							0xff000000
+#define  NV20TCL_BACK_MATERIAL_SHININESS(x)						(0x00001e28+((x)*4))
+#define  NV20TCL_BACK_MATERIAL_SHININESS__SIZE						0x00000006
+#define  NV20TCL_RC_OUT_RGB(x)								(0x00001e40+((x)*4))
+#define  NV20TCL_RC_OUT_RGB__SIZE							0x00000008
+#define   NV20TCL_RC_OUT_RGB_CD_OUTPUT_SHIFT						0
+#define   NV20TCL_RC_OUT_RGB_CD_OUTPUT_MASK						0x0000000f
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_ZERO						0x00000000
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR0					0x00000001
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR1					0x00000002
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_FOG						0x00000003
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_PRIMARY_COLOR					0x00000004
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_SECONDARY_COLOR					0x00000005
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE0					0x00000008
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE1					0x00000009
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0						0x0000000c
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_SPARE1						0x0000000d
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_E_TIMES_F					0x0000000f
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE2					0x0000000a
+#define    NV20TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE3					0x0000000b
+#define   NV20TCL_RC_OUT_RGB_AB_OUTPUT_SHIFT						4
+#define   NV20TCL_RC_OUT_RGB_AB_OUTPUT_MASK						0x000000f0
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_ZERO						0x00000000
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR0					0x00000010
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR1					0x00000020
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_FOG						0x00000030
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_PRIMARY_COLOR					0x00000040
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_SECONDARY_COLOR					0x00000050
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE0					0x00000080
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE1					0x00000090
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0						0x000000c0
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_SPARE1						0x000000d0
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000000e0
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_E_TIMES_F					0x000000f0
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE2					0x000000a0
+#define    NV20TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE3					0x000000b0
+#define   NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SHIFT						8
+#define   NV20TCL_RC_OUT_RGB_SUM_OUTPUT_MASK						0x00000f00
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_ZERO						0x00000000
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR0				0x00000100
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR1				0x00000200
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_FOG						0x00000300
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_PRIMARY_COLOR					0x00000400
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SECONDARY_COLOR				0x00000500
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE0					0x00000800
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE1					0x00000900
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0						0x00000c00
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE1						0x00000d00
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_E_TIMES_F					0x00000f00
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE2					0x00000a00
+#define    NV20TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE3					0x00000b00
+#define   NV20TCL_RC_OUT_RGB_CD_DOT_PRODUCT						(1 << 12)
+#define   NV20TCL_RC_OUT_RGB_AB_DOT_PRODUCT						(1 << 13)
+#define   NV20TCL_RC_OUT_RGB_MUX_SUM							(1 << 14)
+#define   NV20TCL_RC_OUT_RGB_BIAS							(1 << 15)
+#define    NV20TCL_RC_OUT_RGB_BIAS_NONE							0x00000000
+#define    NV20TCL_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF				0x00008000
+#define   NV20TCL_RC_OUT_RGB_SCALE_SHIFT						17
+#define   NV20TCL_RC_OUT_RGB_SCALE_MASK							0x00000000
+#define    NV20TCL_RC_OUT_RGB_SCALE_NONE						0x00000000
+#define    NV20TCL_RC_OUT_RGB_SCALE_SCALE_BY_TWO					0x00020000
+#define    NV20TCL_RC_OUT_RGB_SCALE_SCALE_BY_FOUR					0x00040000
+#define    NV20TCL_RC_OUT_RGB_SCALE_SCALE_BY_ONE_HALF					0x00060000
+#define  NV20TCL_RC_ENABLE								0x00001e60
+#define   NV20TCL_RC_ENABLE_NUM_COMBINERS_SHIFT						0
+#define   NV20TCL_RC_ENABLE_NUM_COMBINERS_MASK						0x0000000f
+#define  NV20TCL_TX_RCOMP								0x00001e6c
+#define   NV20TCL_TX_RCOMP_NEVER							0x00000000
+#define   NV20TCL_TX_RCOMP_GREATER							0x00000001
+#define   NV20TCL_TX_RCOMP_EQUAL							0x00000002
+#define   NV20TCL_TX_RCOMP_GEQUAL							0x00000003
+#define   NV20TCL_TX_RCOMP_LESS								0x00000004
+#define   NV20TCL_TX_RCOMP_NOTEQUAL							0x00000005
+#define   NV20TCL_TX_RCOMP_LEQUAL							0x00000006
+#define   NV20TCL_TX_RCOMP_ALWAYS							0x00000007
+#define  NV20TCL_TX_SHADER_OP								0x00001e70
+#define   NV20TCL_TX_SHADER_OP_TX0_SHIFT						0
+#define   NV20TCL_TX_SHADER_OP_TX0_MASK							0x0000001f
+#define    NV20TCL_TX_SHADER_OP_TX0_NONE						0x00000000
+#define    NV20TCL_TX_SHADER_OP_TX0_TEXTURE_2D						0x00000001
+#define    NV20TCL_TX_SHADER_OP_TX0_PASS_THROUGH					0x00000004
+#define    NV20TCL_TX_SHADER_OP_TX0_CULL_FRAGMENT					0x00000005
+#define    NV20TCL_TX_SHADER_OP_TX0_OFFSET_TEXTURE_2D					0x00000006
+#define    NV20TCL_TX_SHADER_OP_TX0_DOT_PRODUCT_TEXTURE_2D				0x00000009
+#define    NV20TCL_TX_SHADER_OP_TX0_DOT_PRODUCT_DEPTH_REPLACE				0x0000000a
+#define    NV20TCL_TX_SHADER_OP_TX0_DEPENDANT_AR_TEXTURE_2D				0x0000000f
+#define    NV20TCL_TX_SHADER_OP_TX0_DEPENDANT_GB_TEXTURE_2D				0x00000010
+#define    NV20TCL_TX_SHADER_OP_TX0_DOT_PRODUCT						0x00000011
+#define   NV20TCL_TX_SHADER_OP_TX1_SHIFT						5
+#define   NV20TCL_TX_SHADER_OP_TX1_MASK							0x000003e0
+#define    NV20TCL_TX_SHADER_OP_TX1_NONE						0x00000000
+#define    NV20TCL_TX_SHADER_OP_TX1_TEXTURE_2D						0x00000020
+#define    NV20TCL_TX_SHADER_OP_TX1_PASS_THROUGH					0x00000080
+#define    NV20TCL_TX_SHADER_OP_TX1_CULL_FRAGMENT					0x000000a0
+#define    NV20TCL_TX_SHADER_OP_TX1_OFFSET_TEXTURE_2D					0x000000c0
+#define    NV20TCL_TX_SHADER_OP_TX1_DOT_PRODUCT_TEXTURE_2D				0x00000120
+#define    NV20TCL_TX_SHADER_OP_TX1_DOT_PRODUCT_DEPTH_REPLACE				0x00000140
+#define    NV20TCL_TX_SHADER_OP_TX1_DEPENDANT_AR_TEXTURE_2D				0x000001e0
+#define    NV20TCL_TX_SHADER_OP_TX1_DEPENDANT_GB_TEXTURE_2D				0x00000200
+#define    NV20TCL_TX_SHADER_OP_TX1_DOT_PRODUCT						0x00000220
+#define   NV20TCL_TX_SHADER_OP_TX2_SHIFT						10
+#define   NV20TCL_TX_SHADER_OP_TX2_MASK							0x00007c00
+#define    NV20TCL_TX_SHADER_OP_TX2_NONE						0x00000000
+#define    NV20TCL_TX_SHADER_OP_TX2_TEXTURE_2D						0x00000400
+#define    NV20TCL_TX_SHADER_OP_TX2_PASS_THROUGH					0x00001000
+#define    NV20TCL_TX_SHADER_OP_TX2_CULL_FRAGMENT					0x00001400
+#define    NV20TCL_TX_SHADER_OP_TX2_OFFSET_TEXTURE_2D					0x00001800
+#define    NV20TCL_TX_SHADER_OP_TX2_DOT_PRODUCT_TEXTURE_2D				0x00002400
+#define    NV20TCL_TX_SHADER_OP_TX2_DOT_PRODUCT_DEPTH_REPLACE				0x00002800
+#define    NV20TCL_TX_SHADER_OP_TX2_DEPENDANT_AR_TEXTURE_2D				0x00003c00
+#define    NV20TCL_TX_SHADER_OP_TX2_DEPENDANT_GB_TEXTURE_2D				0x00004000
+#define    NV20TCL_TX_SHADER_OP_TX2_DOT_PRODUCT						0x00004400
+#define   NV20TCL_TX_SHADER_OP_TX3_SHIFT						15
+#define   NV20TCL_TX_SHADER_OP_TX3_MASK							0x000f8000
+#define    NV20TCL_TX_SHADER_OP_TX3_NONE						0x00000000
+#define    NV20TCL_TX_SHADER_OP_TX3_TEXTURE_2D						0x00008000
+#define    NV20TCL_TX_SHADER_OP_TX3_PASS_THROUGH					0x00020000
+#define    NV20TCL_TX_SHADER_OP_TX3_CULL_FRAGMENT					0x00028000
+#define    NV20TCL_TX_SHADER_OP_TX3_OFFSET_TEXTURE_2D					0x00030000
+#define    NV20TCL_TX_SHADER_OP_TX3_DOT_PRODUCT_TEXTURE_2D				0x00048000
+#define    NV20TCL_TX_SHADER_OP_TX3_DOT_PRODUCT_DEPTH_REPLACE				0x00050000
+#define    NV20TCL_TX_SHADER_OP_TX3_DEPENDANT_AR_TEXTURE_2D				0x00078000
+#define    NV20TCL_TX_SHADER_OP_TX3_DEPENDANT_GB_TEXTURE_2D				0x00080000
+#define    NV20TCL_TX_SHADER_OP_TX3_DOT_PRODUCT						0x00088000
+#define  NV20TCL_TX_SHADER_DOTMAPPING							0x00001e74
+#define   NV20TCL_TX_SHADER_DOTMAPPING_TX0_SHIFT					0
+#define   NV20TCL_TX_SHADER_DOTMAPPING_TX0_MASK						0x0000000f
+#define   NV20TCL_TX_SHADER_DOTMAPPING_TX1_SHIFT					4
+#define   NV20TCL_TX_SHADER_DOTMAPPING_TX1_MASK						0x000000f0
+#define   NV20TCL_TX_SHADER_DOTMAPPING_TX2_SHIFT					8
+#define   NV20TCL_TX_SHADER_DOTMAPPING_TX2_MASK						0x00000f00
+#define   NV20TCL_TX_SHADER_DOTMAPPING_TX3_SHIFT					12
+#define   NV20TCL_TX_SHADER_DOTMAPPING_TX3_MASK						0x0000f000
+#define  NV20TCL_TX_SHADER_PREVIOUS							0x00001e78
+#define   NV20TCL_TX_SHADER_PREVIOUS_TX0_SHIFT						8
+#define   NV20TCL_TX_SHADER_PREVIOUS_TX0_MASK						0x00000f00
+#define   NV20TCL_TX_SHADER_PREVIOUS_TX1_SHIFT						12
+#define   NV20TCL_TX_SHADER_PREVIOUS_TX1_MASK						0x0000f000
+#define   NV20TCL_TX_SHADER_PREVIOUS_TX2_SHIFT						16
+#define   NV20TCL_TX_SHADER_PREVIOUS_TX2_MASK						0x00030000
+#define   NV20TCL_TX_SHADER_PREVIOUS_TX3_SHIFT						20
+#define   NV20TCL_TX_SHADER_PREVIOUS_TX3_MASK						0x00300000
+#define  NV20TCL_ENGINE									0x00001e94
+#define   NV20TCL_ENGINE_VP								(1 <<  1)
+#define   NV20TCL_ENGINE_FIXED								(1 <<  2)
+#define  NV20TCL_VP_UPLOAD_FROM_ID							0x00001e9c
+#define  NV20TCL_VP_START_FROM_ID							0x00001ea0
+#define  NV20TCL_VP_UPLOAD_CONST_ID							0x00001ea4
+
+
+#define NV25TCL										0x00000597
+
+#define  NV25TCL_DMA_IN_MEMORY4								0x0000019c
+#define  NV25TCL_DMA_IN_MEMORY5								0x000001a0
+#define  NV25TCL_DMA_IN_MEMORY8								0x000001ac
+#define  NV25TCL_DMA_IN_MEMORY9								0x000001b0
+
+
+#define NV30TCL										0x00000397
+
+
+
+#define NV35TCL										0x00000497
+
+
+
+#define NV34TCL										0x00000697
+
+#define  NV34TCL_NOP									0x00000100
+#define  NV34TCL_NOTIFY									0x00000104
+#define  NV34TCL_DMA_NOTIFY								0x00000180
+#define  NV34TCL_DMA_TEXTURE0								0x00000184
+#define  NV34TCL_DMA_TEXTURE1								0x00000188
+#define  NV34TCL_DMA_COLOR1								0x0000018c
+#define  NV34TCL_DMA_COLOR0								0x00000194
+#define  NV34TCL_DMA_ZETA								0x00000198
+#define  NV34TCL_DMA_VTXBUF0								0x0000019c
+#define  NV34TCL_DMA_VTXBUF1								0x000001a0
+#define  NV34TCL_DMA_FENCE								0x000001a4
+#define  NV34TCL_DMA_QUERY								0x000001a8
+#define  NV34TCL_DMA_IN_MEMORY7								0x000001ac
+#define  NV34TCL_DMA_IN_MEMORY8								0x000001b0
+#define  NV34TCL_RT_HORIZ								0x00000200
+#define   NV34TCL_RT_HORIZ_X_SHIFT							0
+#define   NV34TCL_RT_HORIZ_X_MASK							0x0000ffff
+#define   NV34TCL_RT_HORIZ_W_SHIFT							16
+#define   NV34TCL_RT_HORIZ_W_MASK							0xffff0000
+#define  NV34TCL_RT_VERT								0x00000204
+#define   NV34TCL_RT_VERT_Y_SHIFT							0
+#define   NV34TCL_RT_VERT_Y_MASK							0x0000ffff
+#define   NV34TCL_RT_VERT_H_SHIFT							16
+#define   NV34TCL_RT_VERT_H_MASK							0xffff0000
+#define  NV34TCL_RT_FORMAT								0x00000208
+#define   NV34TCL_RT_FORMAT_LOG2_HEIGHT_SHIFT						24
+#define   NV34TCL_RT_FORMAT_LOG2_HEIGHT_MASK						0xff000000
+#define   NV34TCL_RT_FORMAT_LOG2_WIDTH_SHIFT						16
+#define   NV34TCL_RT_FORMAT_LOG2_WIDTH_MASK						0x00ff0000
+#define   NV34TCL_RT_FORMAT_TYPE_SHIFT							8
+#define   NV34TCL_RT_FORMAT_TYPE_MASK							0x00000f00
+#define    NV34TCL_RT_FORMAT_TYPE_LINEAR						0x00000100
+#define    NV34TCL_RT_FORMAT_TYPE_SWIZZLED						0x00000200
+#define   NV34TCL_RT_FORMAT_ZETA_SHIFT							5
+#define   NV34TCL_RT_FORMAT_ZETA_MASK							0x000000e0
+#define    NV34TCL_RT_FORMAT_ZETA_Z16							0x00000020
+#define    NV34TCL_RT_FORMAT_ZETA_Z24S8							0x00000040
+#define   NV34TCL_RT_FORMAT_COLOR_SHIFT							0
+#define   NV34TCL_RT_FORMAT_COLOR_MASK							0x0000001f
+#define    NV34TCL_RT_FORMAT_COLOR_R5G6B5						0x00000003
+#define    NV34TCL_RT_FORMAT_COLOR_X8R8G8B8						0x00000005
+#define    NV34TCL_RT_FORMAT_COLOR_A8R8G8B8						0x00000008
+#define    NV34TCL_RT_FORMAT_COLOR_B8							0x00000009
+#define    NV34TCL_RT_FORMAT_COLOR_UNKNOWN						0x0000000d
+#define    NV34TCL_RT_FORMAT_COLOR_X8B8G8R8						0x0000000f
+#define    NV34TCL_RT_FORMAT_COLOR_A8B8G8R8						0x00000010
+#define  NV34TCL_COLOR0_PITCH								0x0000020c
+#define   NV34TCL_COLOR0_PITCH_COLOR0_SHIFT						0
+#define   NV34TCL_COLOR0_PITCH_COLOR0_MASK						0x0000ffff
+#define   NV34TCL_COLOR0_PITCH_ZETA_SHIFT						16
+#define   NV34TCL_COLOR0_PITCH_ZETA_MASK						0xffff0000
+#define  NV34TCL_COLOR0_OFFSET								0x00000210
+#define  NV34TCL_ZETA_OFFSET								0x00000214
+#define  NV34TCL_COLOR1_OFFSET								0x00000218
+#define  NV34TCL_COLOR1_PITCH								0x0000021c
+#define  NV34TCL_RT_ENABLE								0x00000220
+#define   NV34TCL_RT_ENABLE_MRT								(1 <<  4)
+#define   NV34TCL_RT_ENABLE_COLOR1							(1 <<  1)
+#define   NV34TCL_RT_ENABLE_COLOR0							(1 <<  0)
+#define  NV34TCL_LMA_DEPTH_PITCH							0x0000022c
+#define  NV34TCL_LMA_DEPTH_OFFSET							0x00000230
+#define  NV34TCL_TX_UNITS_ENABLE							0x0000023c
+#define   NV34TCL_TX_UNITS_ENABLE_TX0							(1 <<  0)
+#define   NV34TCL_TX_UNITS_ENABLE_TX1							(1 <<  1)
+#define   NV34TCL_TX_UNITS_ENABLE_TX2							(1 <<  2)
+#define   NV34TCL_TX_UNITS_ENABLE_TX3							(1 <<  3)
+#define   NV34TCL_TX_UNITS_ENABLE_TX4							(1 <<  4)
+#define   NV34TCL_TX_UNITS_ENABLE_TX5							(1 <<  5)
+#define   NV34TCL_TX_UNITS_ENABLE_TX6							(1 <<  6)
+#define   NV34TCL_TX_UNITS_ENABLE_TX7							(1 <<  7)
+#define  NV34TCL_TX_MATRIX_ENABLE(x)							(0x00000240+((x)*4))
+#define  NV34TCL_TX_MATRIX_ENABLE__SIZE							0x00000008
+#define  NV34TCL_VIEWPORT_TX_ORIGIN							0x000002b8
+#define   NV34TCL_VIEWPORT_TX_ORIGIN_X_SHIFT						0
+#define   NV34TCL_VIEWPORT_TX_ORIGIN_X_MASK						0x0000ffff
+#define   NV34TCL_VIEWPORT_TX_ORIGIN_Y_SHIFT						16
+#define   NV34TCL_VIEWPORT_TX_ORIGIN_Y_MASK						0xffff0000
+#define  NV34TCL_VIEWPORT_CLIP_MODE							0x000002bc
+#define  NV34TCL_VIEWPORT_CLIP_HORIZ(x)							(0x000002c0+((x)*8))
+#define  NV34TCL_VIEWPORT_CLIP_HORIZ__SIZE						0x00000008
+#define   NV34TCL_VIEWPORT_CLIP_HORIZ_L_SHIFT						0
+#define   NV34TCL_VIEWPORT_CLIP_HORIZ_L_MASK						0x0000ffff
+#define   NV34TCL_VIEWPORT_CLIP_HORIZ_R_SHIFT						16
+#define   NV34TCL_VIEWPORT_CLIP_HORIZ_R_MASK						0xffff0000
+#define  NV34TCL_VIEWPORT_CLIP_VERT(x)							(0x000002c4+((x)*8))
+#define  NV34TCL_VIEWPORT_CLIP_VERT__SIZE						0x00000008
+#define   NV34TCL_VIEWPORT_CLIP_VERT_T_SHIFT						0
+#define   NV34TCL_VIEWPORT_CLIP_VERT_T_MASK						0x0000ffff
+#define   NV34TCL_VIEWPORT_CLIP_VERT_D_SHIFT						16
+#define   NV34TCL_VIEWPORT_CLIP_VERT_D_MASK						0xffff0000
+#define  NV34TCL_DITHER_ENABLE								0x00000300
+#define  NV34TCL_ALPHA_FUNC_ENABLE							0x00000304
+#define  NV34TCL_ALPHA_FUNC_FUNC							0x00000308
+#define   NV34TCL_ALPHA_FUNC_FUNC_NEVER							0x00000200
+#define   NV34TCL_ALPHA_FUNC_FUNC_LESS							0x00000201
+#define   NV34TCL_ALPHA_FUNC_FUNC_EQUAL							0x00000202
+#define   NV34TCL_ALPHA_FUNC_FUNC_LEQUAL						0x00000203
+#define   NV34TCL_ALPHA_FUNC_FUNC_GREATER						0x00000204
+#define   NV34TCL_ALPHA_FUNC_FUNC_NOTEQUAL						0x00000205
+#define   NV34TCL_ALPHA_FUNC_FUNC_GEQUAL						0x00000206
+#define   NV34TCL_ALPHA_FUNC_FUNC_ALWAYS						0x00000207
+#define  NV34TCL_ALPHA_FUNC_REF								0x0000030c
+#define  NV34TCL_BLEND_FUNC_ENABLE							0x00000310
+#define  NV34TCL_BLEND_FUNC_SRC								0x00000314
+#define   NV34TCL_BLEND_FUNC_SRC_RGB_SHIFT						0
+#define   NV34TCL_BLEND_FUNC_SRC_RGB_MASK						0x0000ffff
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_ZERO						0x00000000
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_ONE						0x00000001
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_SRC_COLOR						0x00000300
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_SRC_COLOR				0x00000301
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_SRC_ALPHA						0x00000302
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_SRC_ALPHA				0x00000303
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_DST_ALPHA						0x00000304
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_DST_ALPHA				0x00000305
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_DST_COLOR						0x00000306
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_DST_COLOR				0x00000307
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_SRC_ALPHA_SATURATE				0x00000308
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_CONSTANT_COLOR					0x00008001
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_CONSTANT_ALPHA					0x00008003
+#define    NV34TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define   NV34TCL_BLEND_FUNC_SRC_ALPHA_SHIFT						16
+#define   NV34TCL_BLEND_FUNC_SRC_ALPHA_MASK						0xffff0000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_ZERO						0x00000000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_ONE						0x00010000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_SRC_COLOR					0x03000000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_SRC_COLOR				0x03010000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_SRC_ALPHA					0x03020000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_SRC_ALPHA				0x03030000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_DST_ALPHA					0x03040000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_DST_ALPHA				0x03050000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_DST_COLOR					0x03060000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_DST_COLOR				0x03070000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_SRC_ALPHA_SATURATE				0x03080000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_CONSTANT_COLOR					0x80010000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_CONSTANT_COLOR			0x80020000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_CONSTANT_ALPHA					0x80030000
+#define    NV34TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_CONSTANT_ALPHA			0x80040000
+#define  NV34TCL_BLEND_FUNC_DST								0x00000318
+#define   NV34TCL_BLEND_FUNC_DST_RGB_SHIFT						0
+#define   NV34TCL_BLEND_FUNC_DST_RGB_MASK						0x0000ffff
+#define    NV34TCL_BLEND_FUNC_DST_RGB_ZERO						0x00000000
+#define    NV34TCL_BLEND_FUNC_DST_RGB_ONE						0x00000001
+#define    NV34TCL_BLEND_FUNC_DST_RGB_SRC_COLOR						0x00000300
+#define    NV34TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_SRC_COLOR				0x00000301
+#define    NV34TCL_BLEND_FUNC_DST_RGB_SRC_ALPHA						0x00000302
+#define    NV34TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_SRC_ALPHA				0x00000303
+#define    NV34TCL_BLEND_FUNC_DST_RGB_DST_ALPHA						0x00000304
+#define    NV34TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_DST_ALPHA				0x00000305
+#define    NV34TCL_BLEND_FUNC_DST_RGB_DST_COLOR						0x00000306
+#define    NV34TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_DST_COLOR				0x00000307
+#define    NV34TCL_BLEND_FUNC_DST_RGB_SRC_ALPHA_SATURATE				0x00000308
+#define    NV34TCL_BLEND_FUNC_DST_RGB_CONSTANT_COLOR					0x00008001
+#define    NV34TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define    NV34TCL_BLEND_FUNC_DST_RGB_CONSTANT_ALPHA					0x00008003
+#define    NV34TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define   NV34TCL_BLEND_FUNC_DST_ALPHA_SHIFT						16
+#define   NV34TCL_BLEND_FUNC_DST_ALPHA_MASK						0xffff0000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_ZERO						0x00000000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_ONE						0x00010000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_SRC_COLOR					0x03000000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_SRC_COLOR				0x03010000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_SRC_ALPHA					0x03020000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_SRC_ALPHA				0x03030000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_DST_ALPHA					0x03040000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_DST_ALPHA				0x03050000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_DST_COLOR					0x03060000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_DST_COLOR				0x03070000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_SRC_ALPHA_SATURATE				0x03080000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_CONSTANT_COLOR					0x80010000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_CONSTANT_COLOR			0x80020000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_CONSTANT_ALPHA					0x80030000
+#define    NV34TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_CONSTANT_ALPHA			0x80040000
+#define  NV34TCL_BLEND_COLOR								0x0000031c
+#define   NV34TCL_BLEND_COLOR_B_SHIFT							0
+#define   NV34TCL_BLEND_COLOR_B_MASK							0x000000ff
+#define   NV34TCL_BLEND_COLOR_G_SHIFT							8
+#define   NV34TCL_BLEND_COLOR_G_MASK							0x0000ff00
+#define   NV34TCL_BLEND_COLOR_R_SHIFT							16
+#define   NV34TCL_BLEND_COLOR_R_MASK							0x00ff0000
+#define   NV34TCL_BLEND_COLOR_A_SHIFT							24
+#define   NV34TCL_BLEND_COLOR_A_MASK							0xff000000
+#define  NV34TCL_BLEND_EQUATION								0x00000320
+#define   NV34TCL_BLEND_EQUATION_FUNC_ADD						0x00008006
+#define   NV34TCL_BLEND_EQUATION_MIN							0x00008007
+#define   NV34TCL_BLEND_EQUATION_MAX							0x00008008
+#define   NV34TCL_BLEND_EQUATION_FUNC_SUBTRACT						0x0000800a
+#define   NV34TCL_BLEND_EQUATION_FUNC_REVERSE_SUBTRACT					0x0000800b
+#define  NV34TCL_COLOR_MASK								0x00000324
+#define   NV34TCL_COLOR_MASK_B_SHIFT							0
+#define   NV34TCL_COLOR_MASK_B_MASK							0x000000ff
+#define   NV34TCL_COLOR_MASK_G_SHIFT							8
+#define   NV34TCL_COLOR_MASK_G_MASK							0x0000ff00
+#define   NV34TCL_COLOR_MASK_R_SHIFT							16
+#define   NV34TCL_COLOR_MASK_R_MASK							0x00ff0000
+#define   NV34TCL_COLOR_MASK_A_SHIFT							24
+#define   NV34TCL_COLOR_MASK_A_MASK							0xff000000
+#define  NV34TCL_STENCIL_FRONT_ENABLE							0x00000328
+#define  NV34TCL_STENCIL_FRONT_MASK							0x0000032c
+#define  NV34TCL_STENCIL_FRONT_FUNC_FUNC						0x00000330
+#define   NV34TCL_STENCIL_FRONT_FUNC_FUNC_NEVER						0x00000200
+#define   NV34TCL_STENCIL_FRONT_FUNC_FUNC_LESS						0x00000201
+#define   NV34TCL_STENCIL_FRONT_FUNC_FUNC_EQUAL						0x00000202
+#define   NV34TCL_STENCIL_FRONT_FUNC_FUNC_LEQUAL					0x00000203
+#define   NV34TCL_STENCIL_FRONT_FUNC_FUNC_GREATER					0x00000204
+#define   NV34TCL_STENCIL_FRONT_FUNC_FUNC_NOTEQUAL					0x00000205
+#define   NV34TCL_STENCIL_FRONT_FUNC_FUNC_GEQUAL					0x00000206
+#define   NV34TCL_STENCIL_FRONT_FUNC_FUNC_ALWAYS					0x00000207
+#define  NV34TCL_STENCIL_FRONT_FUNC_REF							0x00000334
+#define  NV34TCL_STENCIL_FRONT_FUNC_MASK						0x00000338
+#define  NV34TCL_STENCIL_FRONT_OP_FAIL							0x0000033c
+#define   NV34TCL_STENCIL_FRONT_OP_FAIL_ZERO						0x00000000
+#define   NV34TCL_STENCIL_FRONT_OP_FAIL_INVERT						0x0000150a
+#define   NV34TCL_STENCIL_FRONT_OP_FAIL_KEEP						0x00001e00
+#define   NV34TCL_STENCIL_FRONT_OP_FAIL_REPLACE						0x00001e01
+#define   NV34TCL_STENCIL_FRONT_OP_FAIL_INCR						0x00001e02
+#define   NV34TCL_STENCIL_FRONT_OP_FAIL_DECR						0x00001e03
+#define   NV34TCL_STENCIL_FRONT_OP_FAIL_INCR_WRAP					0x00008507
+#define   NV34TCL_STENCIL_FRONT_OP_FAIL_DECR_WRAP					0x00008508
+#define  NV34TCL_STENCIL_FRONT_OP_ZFAIL							0x00000340
+#define   NV34TCL_STENCIL_FRONT_OP_ZFAIL_ZERO						0x00000000
+#define   NV34TCL_STENCIL_FRONT_OP_ZFAIL_INVERT						0x0000150a
+#define   NV34TCL_STENCIL_FRONT_OP_ZFAIL_KEEP						0x00001e00
+#define   NV34TCL_STENCIL_FRONT_OP_ZFAIL_REPLACE					0x00001e01
+#define   NV34TCL_STENCIL_FRONT_OP_ZFAIL_INCR						0x00001e02
+#define   NV34TCL_STENCIL_FRONT_OP_ZFAIL_DECR						0x00001e03
+#define   NV34TCL_STENCIL_FRONT_OP_ZFAIL_INCR_WRAP					0x00008507
+#define   NV34TCL_STENCIL_FRONT_OP_ZFAIL_DECR_WRAP					0x00008508
+#define  NV34TCL_STENCIL_FRONT_OP_ZPASS							0x00000344
+#define   NV34TCL_STENCIL_FRONT_OP_ZPASS_ZERO						0x00000000
+#define   NV34TCL_STENCIL_FRONT_OP_ZPASS_INVERT						0x0000150a
+#define   NV34TCL_STENCIL_FRONT_OP_ZPASS_KEEP						0x00001e00
+#define   NV34TCL_STENCIL_FRONT_OP_ZPASS_REPLACE					0x00001e01
+#define   NV34TCL_STENCIL_FRONT_OP_ZPASS_INCR						0x00001e02
+#define   NV34TCL_STENCIL_FRONT_OP_ZPASS_DECR						0x00001e03
+#define   NV34TCL_STENCIL_FRONT_OP_ZPASS_INCR_WRAP					0x00008507
+#define   NV34TCL_STENCIL_FRONT_OP_ZPASS_DECR_WRAP					0x00008508
+#define  NV34TCL_STENCIL_BACK_ENABLE							0x00000348
+#define  NV34TCL_STENCIL_BACK_MASK							0x0000034c
+#define  NV34TCL_STENCIL_BACK_FUNC_FUNC							0x00000350
+#define   NV34TCL_STENCIL_BACK_FUNC_FUNC_NEVER						0x00000200
+#define   NV34TCL_STENCIL_BACK_FUNC_FUNC_LESS						0x00000201
+#define   NV34TCL_STENCIL_BACK_FUNC_FUNC_EQUAL						0x00000202
+#define   NV34TCL_STENCIL_BACK_FUNC_FUNC_LEQUAL						0x00000203
+#define   NV34TCL_STENCIL_BACK_FUNC_FUNC_GREATER					0x00000204
+#define   NV34TCL_STENCIL_BACK_FUNC_FUNC_NOTEQUAL					0x00000205
+#define   NV34TCL_STENCIL_BACK_FUNC_FUNC_GEQUAL						0x00000206
+#define   NV34TCL_STENCIL_BACK_FUNC_FUNC_ALWAYS						0x00000207
+#define  NV34TCL_STENCIL_BACK_FUNC_REF							0x00000354
+#define  NV34TCL_STENCIL_BACK_FUNC_MASK							0x00000358
+#define  NV34TCL_STENCIL_BACK_OP_FAIL							0x0000035c
+#define   NV34TCL_STENCIL_BACK_OP_FAIL_ZERO						0x00000000
+#define   NV34TCL_STENCIL_BACK_OP_FAIL_INVERT						0x0000150a
+#define   NV34TCL_STENCIL_BACK_OP_FAIL_KEEP						0x00001e00
+#define   NV34TCL_STENCIL_BACK_OP_FAIL_REPLACE						0x00001e01
+#define   NV34TCL_STENCIL_BACK_OP_FAIL_INCR						0x00001e02
+#define   NV34TCL_STENCIL_BACK_OP_FAIL_DECR						0x00001e03
+#define   NV34TCL_STENCIL_BACK_OP_FAIL_INCR_WRAP					0x00008507
+#define   NV34TCL_STENCIL_BACK_OP_FAIL_DECR_WRAP					0x00008508
+#define  NV34TCL_STENCIL_BACK_OP_ZFAIL							0x00000360
+#define   NV34TCL_STENCIL_BACK_OP_ZFAIL_ZERO						0x00000000
+#define   NV34TCL_STENCIL_BACK_OP_ZFAIL_INVERT						0x0000150a
+#define   NV34TCL_STENCIL_BACK_OP_ZFAIL_KEEP						0x00001e00
+#define   NV34TCL_STENCIL_BACK_OP_ZFAIL_REPLACE						0x00001e01
+#define   NV34TCL_STENCIL_BACK_OP_ZFAIL_INCR						0x00001e02
+#define   NV34TCL_STENCIL_BACK_OP_ZFAIL_DECR						0x00001e03
+#define   NV34TCL_STENCIL_BACK_OP_ZFAIL_INCR_WRAP					0x00008507
+#define   NV34TCL_STENCIL_BACK_OP_ZFAIL_DECR_WRAP					0x00008508
+#define  NV34TCL_STENCIL_BACK_OP_ZPASS							0x00000364
+#define   NV34TCL_STENCIL_BACK_OP_ZPASS_ZERO						0x00000000
+#define   NV34TCL_STENCIL_BACK_OP_ZPASS_INVERT						0x0000150a
+#define   NV34TCL_STENCIL_BACK_OP_ZPASS_KEEP						0x00001e00
+#define   NV34TCL_STENCIL_BACK_OP_ZPASS_REPLACE						0x00001e01
+#define   NV34TCL_STENCIL_BACK_OP_ZPASS_INCR						0x00001e02
+#define   NV34TCL_STENCIL_BACK_OP_ZPASS_DECR						0x00001e03
+#define   NV34TCL_STENCIL_BACK_OP_ZPASS_INCR_WRAP					0x00008507
+#define   NV34TCL_STENCIL_BACK_OP_ZPASS_DECR_WRAP					0x00008508
+#define  NV34TCL_SHADE_MODEL								0x00000368
+#define   NV34TCL_SHADE_MODEL_FLAT							0x00001d00
+#define   NV34TCL_SHADE_MODEL_SMOOTH							0x00001d01
+#define  NV34TCL_FOG_ENABLE								0x0000036c
+#define  NV34TCL_FOG_COLOR								0x00000370
+#define   NV34TCL_FOG_COLOR_R_SHIFT							0
+#define   NV34TCL_FOG_COLOR_R_MASK							0x000000ff
+#define   NV34TCL_FOG_COLOR_G_SHIFT							8
+#define   NV34TCL_FOG_COLOR_G_MASK							0x0000ff00
+#define   NV34TCL_FOG_COLOR_B_SHIFT							16
+#define   NV34TCL_FOG_COLOR_B_MASK							0x00ff0000
+#define   NV34TCL_FOG_COLOR_A_SHIFT							24
+#define   NV34TCL_FOG_COLOR_A_MASK							0xff000000
+#define  NV34TCL_COLOR_LOGIC_OP_ENABLE							0x00000374
+#define  NV34TCL_COLOR_LOGIC_OP_OP							0x00000378
+#define   NV34TCL_COLOR_LOGIC_OP_OP_CLEAR						0x00001500
+#define   NV34TCL_COLOR_LOGIC_OP_OP_AND							0x00001501
+#define   NV34TCL_COLOR_LOGIC_OP_OP_AND_REVERSE						0x00001502
+#define   NV34TCL_COLOR_LOGIC_OP_OP_COPY						0x00001503
+#define   NV34TCL_COLOR_LOGIC_OP_OP_AND_INVERTED					0x00001504
+#define   NV34TCL_COLOR_LOGIC_OP_OP_NOOP						0x00001505
+#define   NV34TCL_COLOR_LOGIC_OP_OP_XOR							0x00001506
+#define   NV34TCL_COLOR_LOGIC_OP_OP_OR							0x00001507
+#define   NV34TCL_COLOR_LOGIC_OP_OP_NOR							0x00001508
+#define   NV34TCL_COLOR_LOGIC_OP_OP_EQUIV						0x00001509
+#define   NV34TCL_COLOR_LOGIC_OP_OP_INVERT						0x0000150a
+#define   NV34TCL_COLOR_LOGIC_OP_OP_OR_REVERSE						0x0000150b
+#define   NV34TCL_COLOR_LOGIC_OP_OP_COPY_INVERTED					0x0000150c
+#define   NV34TCL_COLOR_LOGIC_OP_OP_OR_INVERTED						0x0000150d
+#define   NV34TCL_COLOR_LOGIC_OP_OP_NAND						0x0000150e
+#define   NV34TCL_COLOR_LOGIC_OP_OP_SET							0x0000150f
+#define  NV34TCL_NORMALIZE_ENABLE							0x0000037c
+#define  NV34TCL_COLOR_MATERIAL								0x00000390
+#define   NV34TCL_COLOR_MATERIAL_FRONT_EMISSION_ENABLE					(1 <<  0)
+#define   NV34TCL_COLOR_MATERIAL_FRONT_AMBIENT_ENABLE					(1 <<  2)
+#define   NV34TCL_COLOR_MATERIAL_FRONT_DIFFUSE_ENABLE					(1 <<  4)
+#define   NV34TCL_COLOR_MATERIAL_FRONT_SPECULAR_ENABLE					(1 <<  6)
+#define   NV34TCL_COLOR_MATERIAL_BACK_EMISSION_ENABLE					(1 <<  8)
+#define   NV34TCL_COLOR_MATERIAL_BACK_AMBIENT_ENABLE					(1 << 10)
+#define   NV34TCL_COLOR_MATERIAL_BACK_DIFFUSE_ENABLE					(1 << 12)
+#define   NV34TCL_COLOR_MATERIAL_BACK_SPECULAR_ENABLE					(1 << 14)
+#define  NV34TCL_DEPTH_RANGE_NEAR							0x00000394
+#define  NV34TCL_DEPTH_RANGE_FAR							0x00000398
+#define  NV34TCL_COLOR_MATERIAL_FRONT_R							0x000003a0
+#define  NV34TCL_COLOR_MATERIAL_FRONT_G							0x000003a4
+#define  NV34TCL_COLOR_MATERIAL_FRONT_B							0x000003a8
+#define  NV34TCL_COLOR_MATERIAL_FRONT_A							0x000003b4
+#define  NV34TCL_LINE_WIDTH								0x000003b8
+#define  NV34TCL_LINE_SMOOTH_ENABLE							0x000003bc
+#define  NV34TCL_TX_GEN_S(x)								(0x00000400+((x)*16))
+#define  NV34TCL_TX_GEN_S__SIZE								0x00000008
+#define   NV34TCL_TX_GEN_S_FALSE							0x00000000
+#define   NV34TCL_TX_GEN_S_EYE_LINEAR							0x00002400
+#define   NV34TCL_TX_GEN_S_OBJECT_LINEAR						0x00002401
+#define   NV34TCL_TX_GEN_S_SPHERE_MAP							0x00002402
+#define   NV34TCL_TX_GEN_S_NORMAL_MAP							0x00008511
+#define   NV34TCL_TX_GEN_S_REFLECTION_MAP						0x00008512
+#define  NV34TCL_TX_GEN_T(x)								(0x00000404+((x)*16))
+#define  NV34TCL_TX_GEN_T__SIZE								0x00000008
+#define   NV34TCL_TX_GEN_T_FALSE							0x00000000
+#define   NV34TCL_TX_GEN_T_EYE_LINEAR							0x00002400
+#define   NV34TCL_TX_GEN_T_OBJECT_LINEAR						0x00002401
+#define   NV34TCL_TX_GEN_T_SPHERE_MAP							0x00002402
+#define   NV34TCL_TX_GEN_T_NORMAL_MAP							0x00008511
+#define   NV34TCL_TX_GEN_T_REFLECTION_MAP						0x00008512
+#define  NV34TCL_TX_GEN_R(x)								(0x00000408+((x)*16))
+#define  NV34TCL_TX_GEN_R__SIZE								0x00000008
+#define   NV34TCL_TX_GEN_R_FALSE							0x00000000
+#define   NV34TCL_TX_GEN_R_EYE_LINEAR							0x00002400
+#define   NV34TCL_TX_GEN_R_OBJECT_LINEAR						0x00002401
+#define   NV34TCL_TX_GEN_R_SPHERE_MAP							0x00002402
+#define   NV34TCL_TX_GEN_R_NORMAL_MAP							0x00008511
+#define   NV34TCL_TX_GEN_R_REFLECTION_MAP						0x00008512
+#define  NV34TCL_TX_GEN_Q(x)								(0x0000040c+((x)*16))
+#define  NV34TCL_TX_GEN_Q__SIZE								0x00000008
+#define   NV34TCL_TX_GEN_Q_FALSE							0x00000000
+#define   NV34TCL_TX_GEN_Q_EYE_LINEAR							0x00002400
+#define   NV34TCL_TX_GEN_Q_OBJECT_LINEAR						0x00002401
+#define   NV34TCL_TX_GEN_Q_SPHERE_MAP							0x00002402
+#define   NV34TCL_TX_GEN_Q_NORMAL_MAP							0x00008511
+#define   NV34TCL_TX_GEN_Q_REFLECTION_MAP						0x00008512
+#define  NV34TCL_MODELVIEW_MATRIX(x)							(0x00000480+((x)*4))
+#define  NV34TCL_MODELVIEW_MATRIX__SIZE							0x00000010
+#define  NV34TCL_INVERSE_MODELVIEW_MATRIX(x)						(0x00000580+((x)*4))
+#define  NV34TCL_INVERSE_MODELVIEW_MATRIX__SIZE						0x0000000c
+#define  NV34TCL_PROJECTION_MATRIX(x)							(0x00000680+((x)*4))
+#define  NV34TCL_PROJECTION_MATRIX__SIZE						0x00000010
+#define  NV34TCL_TX0_MATRIX(x)								(0x000006c0+((x)*4))
+#define  NV34TCL_TX0_MATRIX__SIZE							0x00000010
+#define  NV34TCL_TX1_MATRIX(x)								(0x00000700+((x)*4))
+#define  NV34TCL_TX1_MATRIX__SIZE							0x00000010
+#define  NV34TCL_TX2_MATRIX(x)								(0x00000740+((x)*4))
+#define  NV34TCL_TX2_MATRIX__SIZE							0x00000010
+#define  NV34TCL_TX3_MATRIX(x)								(0x00000780+((x)*4))
+#define  NV34TCL_TX3_MATRIX__SIZE							0x00000010
+#define  NV34TCL_TX4_MATRIX(x)								(0x000007c0+((x)*4))
+#define  NV34TCL_TX4_MATRIX__SIZE							0x00000010
+#define  NV34TCL_TX5_MATRIX(x)								(0x00000800+((x)*4))
+#define  NV34TCL_TX5_MATRIX__SIZE							0x00000010
+#define  NV34TCL_TX6_MATRIX(x)								(0x00000840+((x)*4))
+#define  NV34TCL_TX6_MATRIX__SIZE							0x00000010
+#define  NV34TCL_TX7_MATRIX(x)								(0x00000880+((x)*4))
+#define  NV34TCL_TX7_MATRIX__SIZE							0x00000010
+#define  NV34TCL_SCISSOR_HORIZ								0x000008c0
+#define   NV34TCL_SCISSOR_HORIZ_X_SHIFT							0
+#define   NV34TCL_SCISSOR_HORIZ_X_MASK							0x0000ffff
+#define   NV34TCL_SCISSOR_HORIZ_W_SHIFT							16
+#define   NV34TCL_SCISSOR_HORIZ_W_MASK							0xffff0000
+#define  NV34TCL_SCISSOR_VERT								0x000008c4
+#define   NV34TCL_SCISSOR_VERT_Y_SHIFT							0
+#define   NV34TCL_SCISSOR_VERT_Y_MASK							0x0000ffff
+#define   NV34TCL_SCISSOR_VERT_H_SHIFT							16
+#define   NV34TCL_SCISSOR_VERT_H_MASK							0xffff0000
+#define  NV34TCL_FOG_COORD_DIST								0x000008c8
+#define  NV34TCL_FOG_MODE								0x000008cc
+#define  NV34TCL_FOG_EQUATION_CONSTANT							0x000008d0
+#define  NV34TCL_FOG_EQUATION_LINEAR							0x000008d4
+#define  NV34TCL_FOG_EQUATION_QUADRATIC							0x000008d8
+#define  NV34TCL_FP_ACTIVE_PROGRAM							0x000008e4
+#define   NV34TCL_FP_ACTIVE_PROGRAM_DMA0						(1 <<  0)
+#define   NV34TCL_FP_ACTIVE_PROGRAM_DMA1						(1 <<  1)
+#define   NV34TCL_FP_ACTIVE_PROGRAM_OFFSET_SHIFT					2
+#define   NV34TCL_FP_ACTIVE_PROGRAM_OFFSET_MASK						0xfffffffc
+#define  NV34TCL_RC_COLOR0								0x000008ec
+#define   NV34TCL_RC_COLOR0_B_SHIFT							0
+#define   NV34TCL_RC_COLOR0_B_MASK							0x000000ff
+#define   NV34TCL_RC_COLOR0_G_SHIFT							8
+#define   NV34TCL_RC_COLOR0_G_MASK							0x0000ff00
+#define   NV34TCL_RC_COLOR0_R_SHIFT							16
+#define   NV34TCL_RC_COLOR0_R_MASK							0x00ff0000
+#define   NV34TCL_RC_COLOR0_A_SHIFT							24
+#define   NV34TCL_RC_COLOR0_A_MASK							0xff000000
+#define  NV34TCL_RC_COLOR1								0x000008f0
+#define   NV34TCL_RC_COLOR1_B_SHIFT							0
+#define   NV34TCL_RC_COLOR1_B_MASK							0x000000ff
+#define   NV34TCL_RC_COLOR1_G_SHIFT							8
+#define   NV34TCL_RC_COLOR1_G_MASK							0x0000ff00
+#define   NV34TCL_RC_COLOR1_R_SHIFT							16
+#define   NV34TCL_RC_COLOR1_R_MASK							0x00ff0000
+#define   NV34TCL_RC_COLOR1_A_SHIFT							24
+#define   NV34TCL_RC_COLOR1_A_MASK							0xff000000
+#define  NV34TCL_RC_FINAL0								0x000008f4
+#define   NV34TCL_RC_FINAL0_D_INPUT_SHIFT						0
+#define   NV34TCL_RC_FINAL0_D_INPUT_MASK						0x0000000f
+#define    NV34TCL_RC_FINAL0_D_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR0					0x00000001
+#define    NV34TCL_RC_FINAL0_D_INPUT_CONSTANT_COLOR1					0x00000002
+#define    NV34TCL_RC_FINAL0_D_INPUT_FOG						0x00000003
+#define    NV34TCL_RC_FINAL0_D_INPUT_PRIMARY_COLOR					0x00000004
+#define    NV34TCL_RC_FINAL0_D_INPUT_SECONDARY_COLOR					0x00000005
+#define    NV34TCL_RC_FINAL0_D_INPUT_TEXTURE0						0x00000008
+#define    NV34TCL_RC_FINAL0_D_INPUT_TEXTURE1						0x00000009
+#define    NV34TCL_RC_FINAL0_D_INPUT_SPARE0						0x0000000c
+#define    NV34TCL_RC_FINAL0_D_INPUT_SPARE1						0x0000000d
+#define    NV34TCL_RC_FINAL0_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV34TCL_RC_FINAL0_D_INPUT_E_TIMES_F						0x0000000f
+#define    NV34TCL_RC_FINAL0_D_INPUT_TEXTURE2						0x0000000a
+#define    NV34TCL_RC_FINAL0_D_INPUT_TEXTURE3						0x0000000b
+#define   NV34TCL_RC_FINAL0_D_COMPONENT_USAGE						(1 <<  4)
+#define    NV34TCL_RC_FINAL0_D_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_FINAL0_D_COMPONENT_USAGE_ALPHA					0x00000010
+#define   NV34TCL_RC_FINAL0_D_MAPPING_SHIFT						5
+#define   NV34TCL_RC_FINAL0_D_MAPPING_MASK						0x000000e0
+#define    NV34TCL_RC_FINAL0_D_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_FINAL0_D_MAPPING_UNSIGNED_INVERT					0x00000020
+#define    NV34TCL_RC_FINAL0_D_MAPPING_EXPAND_NORMAL					0x00000040
+#define    NV34TCL_RC_FINAL0_D_MAPPING_EXPAND_NEGATE					0x00000060
+#define    NV34TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NORMAL					0x00000080
+#define    NV34TCL_RC_FINAL0_D_MAPPING_HALF_BIAS_NEGATE					0x000000a0
+#define    NV34TCL_RC_FINAL0_D_MAPPING_SIGNED_IDENTITY					0x000000c0
+#define    NV34TCL_RC_FINAL0_D_MAPPING_SIGNED_NEGATE					0x000000e0
+#define   NV34TCL_RC_FINAL0_C_INPUT_SHIFT						8
+#define   NV34TCL_RC_FINAL0_C_INPUT_MASK						0x00000f00
+#define    NV34TCL_RC_FINAL0_C_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV34TCL_RC_FINAL0_C_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV34TCL_RC_FINAL0_C_INPUT_FOG						0x00000300
+#define    NV34TCL_RC_FINAL0_C_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV34TCL_RC_FINAL0_C_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV34TCL_RC_FINAL0_C_INPUT_TEXTURE0						0x00000800
+#define    NV34TCL_RC_FINAL0_C_INPUT_TEXTURE1						0x00000900
+#define    NV34TCL_RC_FINAL0_C_INPUT_SPARE0						0x00000c00
+#define    NV34TCL_RC_FINAL0_C_INPUT_SPARE1						0x00000d00
+#define    NV34TCL_RC_FINAL0_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV34TCL_RC_FINAL0_C_INPUT_E_TIMES_F						0x00000f00
+#define    NV34TCL_RC_FINAL0_C_INPUT_TEXTURE2						0x00000a00
+#define    NV34TCL_RC_FINAL0_C_INPUT_TEXTURE3						0x00000b00
+#define   NV34TCL_RC_FINAL0_C_COMPONENT_USAGE						(1 << 12)
+#define    NV34TCL_RC_FINAL0_C_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_FINAL0_C_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV34TCL_RC_FINAL0_C_MAPPING_SHIFT						13
+#define   NV34TCL_RC_FINAL0_C_MAPPING_MASK						0x0000e000
+#define    NV34TCL_RC_FINAL0_C_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_FINAL0_C_MAPPING_UNSIGNED_INVERT					0x00002000
+#define    NV34TCL_RC_FINAL0_C_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV34TCL_RC_FINAL0_C_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV34TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NORMAL					0x00008000
+#define    NV34TCL_RC_FINAL0_C_MAPPING_HALF_BIAS_NEGATE					0x0000a000
+#define    NV34TCL_RC_FINAL0_C_MAPPING_SIGNED_IDENTITY					0x0000c000
+#define    NV34TCL_RC_FINAL0_C_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV34TCL_RC_FINAL0_B_INPUT_SHIFT						16
+#define   NV34TCL_RC_FINAL0_B_INPUT_MASK						0x000f0000
+#define    NV34TCL_RC_FINAL0_B_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV34TCL_RC_FINAL0_B_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV34TCL_RC_FINAL0_B_INPUT_FOG						0x00030000
+#define    NV34TCL_RC_FINAL0_B_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV34TCL_RC_FINAL0_B_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV34TCL_RC_FINAL0_B_INPUT_TEXTURE0						0x00080000
+#define    NV34TCL_RC_FINAL0_B_INPUT_TEXTURE1						0x00090000
+#define    NV34TCL_RC_FINAL0_B_INPUT_SPARE0						0x000c0000
+#define    NV34TCL_RC_FINAL0_B_INPUT_SPARE1						0x000d0000
+#define    NV34TCL_RC_FINAL0_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV34TCL_RC_FINAL0_B_INPUT_E_TIMES_F						0x000f0000
+#define    NV34TCL_RC_FINAL0_B_INPUT_TEXTURE2						0x000a0000
+#define    NV34TCL_RC_FINAL0_B_INPUT_TEXTURE3						0x000b0000
+#define   NV34TCL_RC_FINAL0_B_COMPONENT_USAGE						(1 << 20)
+#define    NV34TCL_RC_FINAL0_B_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_FINAL0_B_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV34TCL_RC_FINAL0_B_MAPPING_SHIFT						21
+#define   NV34TCL_RC_FINAL0_B_MAPPING_MASK						0x00e00000
+#define    NV34TCL_RC_FINAL0_B_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_FINAL0_B_MAPPING_UNSIGNED_INVERT					0x00200000
+#define    NV34TCL_RC_FINAL0_B_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV34TCL_RC_FINAL0_B_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV34TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NORMAL					0x00800000
+#define    NV34TCL_RC_FINAL0_B_MAPPING_HALF_BIAS_NEGATE					0x00a00000
+#define    NV34TCL_RC_FINAL0_B_MAPPING_SIGNED_IDENTITY					0x00c00000
+#define    NV34TCL_RC_FINAL0_B_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV34TCL_RC_FINAL0_A_INPUT_SHIFT						24
+#define   NV34TCL_RC_FINAL0_A_INPUT_MASK						0x0f000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_FOG						0x03000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_TEXTURE0						0x08000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_TEXTURE1						0x09000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_SPARE0						0x0c000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_SPARE1						0x0d000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_E_TIMES_F						0x0f000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_TEXTURE2						0x0a000000
+#define    NV34TCL_RC_FINAL0_A_INPUT_TEXTURE3						0x0b000000
+#define   NV34TCL_RC_FINAL0_A_COMPONENT_USAGE						(1 << 28)
+#define    NV34TCL_RC_FINAL0_A_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_FINAL0_A_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV34TCL_RC_FINAL0_A_MAPPING_SHIFT						29
+#define   NV34TCL_RC_FINAL0_A_MAPPING_MASK						0xe0000000
+#define    NV34TCL_RC_FINAL0_A_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_FINAL0_A_MAPPING_UNSIGNED_INVERT					0x20000000
+#define    NV34TCL_RC_FINAL0_A_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV34TCL_RC_FINAL0_A_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV34TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NORMAL					0x80000000
+#define    NV34TCL_RC_FINAL0_A_MAPPING_HALF_BIAS_NEGATE					0xa0000000
+#define    NV34TCL_RC_FINAL0_A_MAPPING_SIGNED_IDENTITY					0xc0000000
+#define    NV34TCL_RC_FINAL0_A_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV34TCL_RC_FINAL1								0x000008f8
+#define   NV34TCL_RC_FINAL1_COLOR_SUM_CLAMP						(1 <<  7)
+#define   NV34TCL_RC_FINAL1_G_INPUT_SHIFT						8
+#define   NV34TCL_RC_FINAL1_G_INPUT_MASK						0x00000f00
+#define    NV34TCL_RC_FINAL1_G_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV34TCL_RC_FINAL1_G_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV34TCL_RC_FINAL1_G_INPUT_FOG						0x00000300
+#define    NV34TCL_RC_FINAL1_G_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV34TCL_RC_FINAL1_G_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV34TCL_RC_FINAL1_G_INPUT_TEXTURE0						0x00000800
+#define    NV34TCL_RC_FINAL1_G_INPUT_TEXTURE1						0x00000900
+#define    NV34TCL_RC_FINAL1_G_INPUT_SPARE0						0x00000c00
+#define    NV34TCL_RC_FINAL1_G_INPUT_SPARE1						0x00000d00
+#define    NV34TCL_RC_FINAL1_G_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV34TCL_RC_FINAL1_G_INPUT_E_TIMES_F						0x00000f00
+#define    NV34TCL_RC_FINAL1_G_INPUT_TEXTURE2						0x00000a00
+#define    NV34TCL_RC_FINAL1_G_INPUT_TEXTURE3						0x00000b00
+#define   NV34TCL_RC_FINAL1_G_COMPONENT_USAGE						(1 << 12)
+#define    NV34TCL_RC_FINAL1_G_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_FINAL1_G_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV34TCL_RC_FINAL1_G_MAPPING_SHIFT						13
+#define   NV34TCL_RC_FINAL1_G_MAPPING_MASK						0x0000e000
+#define    NV34TCL_RC_FINAL1_G_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_FINAL1_G_MAPPING_UNSIGNED_INVERT					0x00002000
+#define    NV34TCL_RC_FINAL1_G_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV34TCL_RC_FINAL1_G_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV34TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NORMAL					0x00008000
+#define    NV34TCL_RC_FINAL1_G_MAPPING_HALF_BIAS_NEGATE					0x0000a000
+#define    NV34TCL_RC_FINAL1_G_MAPPING_SIGNED_IDENTITY					0x0000c000
+#define    NV34TCL_RC_FINAL1_G_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV34TCL_RC_FINAL1_F_INPUT_SHIFT						16
+#define   NV34TCL_RC_FINAL1_F_INPUT_MASK						0x000f0000
+#define    NV34TCL_RC_FINAL1_F_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV34TCL_RC_FINAL1_F_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV34TCL_RC_FINAL1_F_INPUT_FOG						0x00030000
+#define    NV34TCL_RC_FINAL1_F_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV34TCL_RC_FINAL1_F_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV34TCL_RC_FINAL1_F_INPUT_TEXTURE0						0x00080000
+#define    NV34TCL_RC_FINAL1_F_INPUT_TEXTURE1						0x00090000
+#define    NV34TCL_RC_FINAL1_F_INPUT_SPARE0						0x000c0000
+#define    NV34TCL_RC_FINAL1_F_INPUT_SPARE1						0x000d0000
+#define    NV34TCL_RC_FINAL1_F_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV34TCL_RC_FINAL1_F_INPUT_E_TIMES_F						0x000f0000
+#define    NV34TCL_RC_FINAL1_F_INPUT_TEXTURE2						0x000a0000
+#define    NV34TCL_RC_FINAL1_F_INPUT_TEXTURE3						0x000b0000
+#define   NV34TCL_RC_FINAL1_F_COMPONENT_USAGE						(1 << 20)
+#define    NV34TCL_RC_FINAL1_F_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_FINAL1_F_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV34TCL_RC_FINAL1_F_MAPPING_SHIFT						21
+#define   NV34TCL_RC_FINAL1_F_MAPPING_MASK						0x00e00000
+#define    NV34TCL_RC_FINAL1_F_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_FINAL1_F_MAPPING_UNSIGNED_INVERT					0x00200000
+#define    NV34TCL_RC_FINAL1_F_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV34TCL_RC_FINAL1_F_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV34TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NORMAL					0x00800000
+#define    NV34TCL_RC_FINAL1_F_MAPPING_HALF_BIAS_NEGATE					0x00a00000
+#define    NV34TCL_RC_FINAL1_F_MAPPING_SIGNED_IDENTITY					0x00c00000
+#define    NV34TCL_RC_FINAL1_F_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV34TCL_RC_FINAL1_E_INPUT_SHIFT						24
+#define   NV34TCL_RC_FINAL1_E_INPUT_MASK						0x0f000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_FOG						0x03000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_TEXTURE0						0x08000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_TEXTURE1						0x09000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_SPARE0						0x0c000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_SPARE1						0x0d000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_E_TIMES_F						0x0f000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_TEXTURE2						0x0a000000
+#define    NV34TCL_RC_FINAL1_E_INPUT_TEXTURE3						0x0b000000
+#define   NV34TCL_RC_FINAL1_E_COMPONENT_USAGE						(1 << 28)
+#define    NV34TCL_RC_FINAL1_E_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_FINAL1_E_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV34TCL_RC_FINAL1_E_MAPPING_SHIFT						29
+#define   NV34TCL_RC_FINAL1_E_MAPPING_MASK						0xe0000000
+#define    NV34TCL_RC_FINAL1_E_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_FINAL1_E_MAPPING_UNSIGNED_INVERT					0x20000000
+#define    NV34TCL_RC_FINAL1_E_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV34TCL_RC_FINAL1_E_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV34TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NORMAL					0x80000000
+#define    NV34TCL_RC_FINAL1_E_MAPPING_HALF_BIAS_NEGATE					0xa0000000
+#define    NV34TCL_RC_FINAL1_E_MAPPING_SIGNED_IDENTITY					0xc0000000
+#define    NV34TCL_RC_FINAL1_E_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV34TCL_RC_ENABLE								0x000008fc
+#define   NV34TCL_RC_ENABLE_NUM_COMBINERS_SHIFT						0
+#define   NV34TCL_RC_ENABLE_NUM_COMBINERS_MASK						0x0000000f
+#define   NV34TCL_RC_ENABLE_STAGE_CONSTANT_COLOR0_SHIFT					12
+#define   NV34TCL_RC_ENABLE_STAGE_CONSTANT_COLOR0_MASK					0x0000f000
+#define   NV34TCL_RC_ENABLE_STAGE_CONSTANT_COLOR1_SHIFT					16
+#define   NV34TCL_RC_ENABLE_STAGE_CONSTANT_COLOR1_MASK					0x000f0000
+#define  NV34TCL_RC_IN_ALPHA(x)								(0x00000900+((x)*32))
+#define  NV34TCL_RC_IN_ALPHA__SIZE							0x00000008
+#define   NV34TCL_RC_IN_ALPHA_D_INPUT_SHIFT						0
+#define   NV34TCL_RC_IN_ALPHA_D_INPUT_MASK						0x0000000f
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR0					0x00000001
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_CONSTANT_COLOR1					0x00000002
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_FOG						0x00000003
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_PRIMARY_COLOR					0x00000004
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_SECONDARY_COLOR					0x00000005
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_TEXTURE0						0x00000008
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_TEXTURE1						0x00000009
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_SPARE0						0x0000000c
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_SPARE1						0x0000000d
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_E_TIMES_F					0x0000000f
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_TEXTURE2						0x0000000a
+#define    NV34TCL_RC_IN_ALPHA_D_INPUT_TEXTURE3						0x0000000b
+#define   NV34TCL_RC_IN_ALPHA_D_COMPONENT_USAGE						(1 <<  4)
+#define    NV34TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV34TCL_RC_IN_ALPHA_D_COMPONENT_USAGE_ALPHA					0x00000010
+#define   NV34TCL_RC_IN_ALPHA_D_MAPPING_SHIFT						5
+#define   NV34TCL_RC_IN_ALPHA_D_MAPPING_MASK						0x000000e0
+#define    NV34TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_IN_ALPHA_D_MAPPING_UNSIGNED_INVERT				0x00000020
+#define    NV34TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NORMAL					0x00000040
+#define    NV34TCL_RC_IN_ALPHA_D_MAPPING_EXPAND_NEGATE					0x00000060
+#define    NV34TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NORMAL				0x00000080
+#define    NV34TCL_RC_IN_ALPHA_D_MAPPING_HALF_BIAS_NEGATE				0x000000a0
+#define    NV34TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_IDENTITY				0x000000c0
+#define    NV34TCL_RC_IN_ALPHA_D_MAPPING_SIGNED_NEGATE					0x000000e0
+#define   NV34TCL_RC_IN_ALPHA_C_INPUT_SHIFT						8
+#define   NV34TCL_RC_IN_ALPHA_C_INPUT_MASK						0x00000f00
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_FOG						0x00000300
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_TEXTURE0						0x00000800
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_TEXTURE1						0x00000900
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_SPARE0						0x00000c00
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_SPARE1						0x00000d00
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_E_TIMES_F					0x00000f00
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_TEXTURE2						0x00000a00
+#define    NV34TCL_RC_IN_ALPHA_C_INPUT_TEXTURE3						0x00000b00
+#define   NV34TCL_RC_IN_ALPHA_C_COMPONENT_USAGE						(1 << 12)
+#define    NV34TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV34TCL_RC_IN_ALPHA_C_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV34TCL_RC_IN_ALPHA_C_MAPPING_SHIFT						13
+#define   NV34TCL_RC_IN_ALPHA_C_MAPPING_MASK						0x0000e000
+#define    NV34TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_IN_ALPHA_C_MAPPING_UNSIGNED_INVERT				0x00002000
+#define    NV34TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV34TCL_RC_IN_ALPHA_C_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV34TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NORMAL				0x00008000
+#define    NV34TCL_RC_IN_ALPHA_C_MAPPING_HALF_BIAS_NEGATE				0x0000a000
+#define    NV34TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_IDENTITY				0x0000c000
+#define    NV34TCL_RC_IN_ALPHA_C_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV34TCL_RC_IN_ALPHA_B_INPUT_SHIFT						16
+#define   NV34TCL_RC_IN_ALPHA_B_INPUT_MASK						0x000f0000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_FOG						0x00030000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_TEXTURE0						0x00080000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_TEXTURE1						0x00090000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_SPARE0						0x000c0000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_SPARE1						0x000d0000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_E_TIMES_F					0x000f0000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_TEXTURE2						0x000a0000
+#define    NV34TCL_RC_IN_ALPHA_B_INPUT_TEXTURE3						0x000b0000
+#define   NV34TCL_RC_IN_ALPHA_B_COMPONENT_USAGE						(1 << 20)
+#define    NV34TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV34TCL_RC_IN_ALPHA_B_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV34TCL_RC_IN_ALPHA_B_MAPPING_SHIFT						21
+#define   NV34TCL_RC_IN_ALPHA_B_MAPPING_MASK						0x00e00000
+#define    NV34TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_IN_ALPHA_B_MAPPING_UNSIGNED_INVERT				0x00200000
+#define    NV34TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV34TCL_RC_IN_ALPHA_B_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV34TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NORMAL				0x00800000
+#define    NV34TCL_RC_IN_ALPHA_B_MAPPING_HALF_BIAS_NEGATE				0x00a00000
+#define    NV34TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_IDENTITY				0x00c00000
+#define    NV34TCL_RC_IN_ALPHA_B_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV34TCL_RC_IN_ALPHA_A_INPUT_SHIFT						24
+#define   NV34TCL_RC_IN_ALPHA_A_INPUT_MASK						0x0f000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_FOG						0x03000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_TEXTURE0						0x08000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_TEXTURE1						0x09000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_SPARE0						0x0c000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_SPARE1						0x0d000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_E_TIMES_F					0x0f000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_TEXTURE2						0x0a000000
+#define    NV34TCL_RC_IN_ALPHA_A_INPUT_TEXTURE3						0x0b000000
+#define   NV34TCL_RC_IN_ALPHA_A_COMPONENT_USAGE						(1 << 28)
+#define    NV34TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_BLUE					0x00000000
+#define    NV34TCL_RC_IN_ALPHA_A_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV34TCL_RC_IN_ALPHA_A_MAPPING_SHIFT						29
+#define   NV34TCL_RC_IN_ALPHA_A_MAPPING_MASK						0xe0000000
+#define    NV34TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_IN_ALPHA_A_MAPPING_UNSIGNED_INVERT				0x20000000
+#define    NV34TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV34TCL_RC_IN_ALPHA_A_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV34TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NORMAL				0x80000000
+#define    NV34TCL_RC_IN_ALPHA_A_MAPPING_HALF_BIAS_NEGATE				0xa0000000
+#define    NV34TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_IDENTITY				0xc0000000
+#define    NV34TCL_RC_IN_ALPHA_A_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV34TCL_RC_IN_RGB(x)								(0x00000904+((x)*32))
+#define  NV34TCL_RC_IN_RGB__SIZE							0x00000008
+#define   NV34TCL_RC_IN_RGB_D_INPUT_SHIFT						0
+#define   NV34TCL_RC_IN_RGB_D_INPUT_MASK						0x0000000f
+#define    NV34TCL_RC_IN_RGB_D_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR0					0x00000001
+#define    NV34TCL_RC_IN_RGB_D_INPUT_CONSTANT_COLOR1					0x00000002
+#define    NV34TCL_RC_IN_RGB_D_INPUT_FOG						0x00000003
+#define    NV34TCL_RC_IN_RGB_D_INPUT_PRIMARY_COLOR					0x00000004
+#define    NV34TCL_RC_IN_RGB_D_INPUT_SECONDARY_COLOR					0x00000005
+#define    NV34TCL_RC_IN_RGB_D_INPUT_TEXTURE0						0x00000008
+#define    NV34TCL_RC_IN_RGB_D_INPUT_TEXTURE1						0x00000009
+#define    NV34TCL_RC_IN_RGB_D_INPUT_SPARE0						0x0000000c
+#define    NV34TCL_RC_IN_RGB_D_INPUT_SPARE1						0x0000000d
+#define    NV34TCL_RC_IN_RGB_D_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV34TCL_RC_IN_RGB_D_INPUT_E_TIMES_F						0x0000000f
+#define    NV34TCL_RC_IN_RGB_D_INPUT_TEXTURE2						0x0000000a
+#define    NV34TCL_RC_IN_RGB_D_INPUT_TEXTURE3						0x0000000b
+#define   NV34TCL_RC_IN_RGB_D_COMPONENT_USAGE						(1 <<  4)
+#define    NV34TCL_RC_IN_RGB_D_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_IN_RGB_D_COMPONENT_USAGE_ALPHA					0x00000010
+#define   NV34TCL_RC_IN_RGB_D_MAPPING_SHIFT						5
+#define   NV34TCL_RC_IN_RGB_D_MAPPING_MASK						0x000000e0
+#define    NV34TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_IN_RGB_D_MAPPING_UNSIGNED_INVERT					0x00000020
+#define    NV34TCL_RC_IN_RGB_D_MAPPING_EXPAND_NORMAL					0x00000040
+#define    NV34TCL_RC_IN_RGB_D_MAPPING_EXPAND_NEGATE					0x00000060
+#define    NV34TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NORMAL					0x00000080
+#define    NV34TCL_RC_IN_RGB_D_MAPPING_HALF_BIAS_NEGATE					0x000000a0
+#define    NV34TCL_RC_IN_RGB_D_MAPPING_SIGNED_IDENTITY					0x000000c0
+#define    NV34TCL_RC_IN_RGB_D_MAPPING_SIGNED_NEGATE					0x000000e0
+#define   NV34TCL_RC_IN_RGB_C_INPUT_SHIFT						8
+#define   NV34TCL_RC_IN_RGB_C_INPUT_MASK						0x00000f00
+#define    NV34TCL_RC_IN_RGB_C_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR0					0x00000100
+#define    NV34TCL_RC_IN_RGB_C_INPUT_CONSTANT_COLOR1					0x00000200
+#define    NV34TCL_RC_IN_RGB_C_INPUT_FOG						0x00000300
+#define    NV34TCL_RC_IN_RGB_C_INPUT_PRIMARY_COLOR					0x00000400
+#define    NV34TCL_RC_IN_RGB_C_INPUT_SECONDARY_COLOR					0x00000500
+#define    NV34TCL_RC_IN_RGB_C_INPUT_TEXTURE0						0x00000800
+#define    NV34TCL_RC_IN_RGB_C_INPUT_TEXTURE1						0x00000900
+#define    NV34TCL_RC_IN_RGB_C_INPUT_SPARE0						0x00000c00
+#define    NV34TCL_RC_IN_RGB_C_INPUT_SPARE1						0x00000d00
+#define    NV34TCL_RC_IN_RGB_C_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV34TCL_RC_IN_RGB_C_INPUT_E_TIMES_F						0x00000f00
+#define    NV34TCL_RC_IN_RGB_C_INPUT_TEXTURE2						0x00000a00
+#define    NV34TCL_RC_IN_RGB_C_INPUT_TEXTURE3						0x00000b00
+#define   NV34TCL_RC_IN_RGB_C_COMPONENT_USAGE						(1 << 12)
+#define    NV34TCL_RC_IN_RGB_C_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_IN_RGB_C_COMPONENT_USAGE_ALPHA					0x00001000
+#define   NV34TCL_RC_IN_RGB_C_MAPPING_SHIFT						13
+#define   NV34TCL_RC_IN_RGB_C_MAPPING_MASK						0x0000e000
+#define    NV34TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_IN_RGB_C_MAPPING_UNSIGNED_INVERT					0x00002000
+#define    NV34TCL_RC_IN_RGB_C_MAPPING_EXPAND_NORMAL					0x00004000
+#define    NV34TCL_RC_IN_RGB_C_MAPPING_EXPAND_NEGATE					0x00006000
+#define    NV34TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NORMAL					0x00008000
+#define    NV34TCL_RC_IN_RGB_C_MAPPING_HALF_BIAS_NEGATE					0x0000a000
+#define    NV34TCL_RC_IN_RGB_C_MAPPING_SIGNED_IDENTITY					0x0000c000
+#define    NV34TCL_RC_IN_RGB_C_MAPPING_SIGNED_NEGATE					0x0000e000
+#define   NV34TCL_RC_IN_RGB_B_INPUT_SHIFT						16
+#define   NV34TCL_RC_IN_RGB_B_INPUT_MASK						0x000f0000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR0					0x00010000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_CONSTANT_COLOR1					0x00020000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_FOG						0x00030000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_PRIMARY_COLOR					0x00040000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_SECONDARY_COLOR					0x00050000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_TEXTURE0						0x00080000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_TEXTURE1						0x00090000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_SPARE0						0x000c0000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_SPARE1						0x000d0000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000e0000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_E_TIMES_F						0x000f0000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_TEXTURE2						0x000a0000
+#define    NV34TCL_RC_IN_RGB_B_INPUT_TEXTURE3						0x000b0000
+#define   NV34TCL_RC_IN_RGB_B_COMPONENT_USAGE						(1 << 20)
+#define    NV34TCL_RC_IN_RGB_B_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_IN_RGB_B_COMPONENT_USAGE_ALPHA					0x00100000
+#define   NV34TCL_RC_IN_RGB_B_MAPPING_SHIFT						21
+#define   NV34TCL_RC_IN_RGB_B_MAPPING_MASK						0x00e00000
+#define    NV34TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_IN_RGB_B_MAPPING_UNSIGNED_INVERT					0x00200000
+#define    NV34TCL_RC_IN_RGB_B_MAPPING_EXPAND_NORMAL					0x00400000
+#define    NV34TCL_RC_IN_RGB_B_MAPPING_EXPAND_NEGATE					0x00600000
+#define    NV34TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NORMAL					0x00800000
+#define    NV34TCL_RC_IN_RGB_B_MAPPING_HALF_BIAS_NEGATE					0x00a00000
+#define    NV34TCL_RC_IN_RGB_B_MAPPING_SIGNED_IDENTITY					0x00c00000
+#define    NV34TCL_RC_IN_RGB_B_MAPPING_SIGNED_NEGATE					0x00e00000
+#define   NV34TCL_RC_IN_RGB_A_INPUT_SHIFT						24
+#define   NV34TCL_RC_IN_RGB_A_INPUT_MASK						0x0f000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_ZERO						0x00000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR0					0x01000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_CONSTANT_COLOR1					0x02000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_FOG						0x03000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_PRIMARY_COLOR					0x04000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_SECONDARY_COLOR					0x05000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_TEXTURE0						0x08000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_TEXTURE1						0x09000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_SPARE0						0x0c000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_SPARE1						0x0d000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0e000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_E_TIMES_F						0x0f000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_TEXTURE2						0x0a000000
+#define    NV34TCL_RC_IN_RGB_A_INPUT_TEXTURE3						0x0b000000
+#define   NV34TCL_RC_IN_RGB_A_COMPONENT_USAGE						(1 << 28)
+#define    NV34TCL_RC_IN_RGB_A_COMPONENT_USAGE_RGB					0x00000000
+#define    NV34TCL_RC_IN_RGB_A_COMPONENT_USAGE_ALPHA					0x10000000
+#define   NV34TCL_RC_IN_RGB_A_MAPPING_SHIFT						29
+#define   NV34TCL_RC_IN_RGB_A_MAPPING_MASK						0xe0000000
+#define    NV34TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_IDENTITY				0x00000000
+#define    NV34TCL_RC_IN_RGB_A_MAPPING_UNSIGNED_INVERT					0x20000000
+#define    NV34TCL_RC_IN_RGB_A_MAPPING_EXPAND_NORMAL					0x40000000
+#define    NV34TCL_RC_IN_RGB_A_MAPPING_EXPAND_NEGATE					0x60000000
+#define    NV34TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NORMAL					0x80000000
+#define    NV34TCL_RC_IN_RGB_A_MAPPING_HALF_BIAS_NEGATE					0xa0000000
+#define    NV34TCL_RC_IN_RGB_A_MAPPING_SIGNED_IDENTITY					0xc0000000
+#define    NV34TCL_RC_IN_RGB_A_MAPPING_SIGNED_NEGATE					0xe0000000
+#define  NV34TCL_RC_CONSTANT_COLOR0(x)							(0x00000908+((x)*32))
+#define  NV34TCL_RC_CONSTANT_COLOR0__SIZE						0x00000008
+#define   NV34TCL_RC_CONSTANT_COLOR0_B_SHIFT						0
+#define   NV34TCL_RC_CONSTANT_COLOR0_B_MASK						0x000000ff
+#define   NV34TCL_RC_CONSTANT_COLOR0_G_SHIFT						8
+#define   NV34TCL_RC_CONSTANT_COLOR0_G_MASK						0x0000ff00
+#define   NV34TCL_RC_CONSTANT_COLOR0_R_SHIFT						16
+#define   NV34TCL_RC_CONSTANT_COLOR0_R_MASK						0x00ff0000
+#define   NV34TCL_RC_CONSTANT_COLOR0_A_SHIFT						24
+#define   NV34TCL_RC_CONSTANT_COLOR0_A_MASK						0xff000000
+#define  NV34TCL_RC_CONSTANT_COLOR1(x)							(0x0000090c+((x)*32))
+#define  NV34TCL_RC_CONSTANT_COLOR1__SIZE						0x00000008
+#define   NV34TCL_RC_CONSTANT_COLOR1_B_SHIFT						0
+#define   NV34TCL_RC_CONSTANT_COLOR1_B_MASK						0x000000ff
+#define   NV34TCL_RC_CONSTANT_COLOR1_G_SHIFT						8
+#define   NV34TCL_RC_CONSTANT_COLOR1_G_MASK						0x0000ff00
+#define   NV34TCL_RC_CONSTANT_COLOR1_R_SHIFT						16
+#define   NV34TCL_RC_CONSTANT_COLOR1_R_MASK						0x00ff0000
+#define   NV34TCL_RC_CONSTANT_COLOR1_A_SHIFT						24
+#define   NV34TCL_RC_CONSTANT_COLOR1_A_MASK						0xff000000
+#define  NV34TCL_RC_OUT_ALPHA(x)							(0x00000910+((x)*32))
+#define  NV34TCL_RC_OUT_ALPHA__SIZE							0x00000008
+#define   NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_SHIFT						0
+#define   NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_MASK						0x0000000f
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_ZERO						0x00000000
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR0				0x00000001
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_CONSTANT_COLOR1				0x00000002
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_FOG						0x00000003
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_PRIMARY_COLOR					0x00000004
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_SECONDARY_COLOR				0x00000005
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE0					0x00000008
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE1					0x00000009
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0					0x0000000c
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE1					0x0000000d
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_E_TIMES_F					0x0000000f
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE2					0x0000000a
+#define    NV34TCL_RC_OUT_ALPHA_CD_OUTPUT_TEXTURE3					0x0000000b
+#define   NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_SHIFT						4
+#define   NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_MASK						0x000000f0
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_ZERO						0x00000000
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR0				0x00000010
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_CONSTANT_COLOR1				0x00000020
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_FOG						0x00000030
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_PRIMARY_COLOR					0x00000040
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_SECONDARY_COLOR				0x00000050
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE0					0x00000080
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE1					0x00000090
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0					0x000000c0
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE1					0x000000d0
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000000e0
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_E_TIMES_F					0x000000f0
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE2					0x000000a0
+#define    NV34TCL_RC_OUT_ALPHA_AB_OUTPUT_TEXTURE3					0x000000b0
+#define   NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_SHIFT						8
+#define   NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_MASK						0x00000f00
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_ZERO						0x00000000
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR0				0x00000100
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_CONSTANT_COLOR1				0x00000200
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_FOG						0x00000300
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_PRIMARY_COLOR				0x00000400
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_SECONDARY_COLOR				0x00000500
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE0					0x00000800
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE1					0x00000900
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0					0x00000c00
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE1					0x00000d00
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_E_TIMES_F					0x00000f00
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE2					0x00000a00
+#define    NV34TCL_RC_OUT_ALPHA_SUM_OUTPUT_TEXTURE3					0x00000b00
+#define   NV34TCL_RC_OUT_ALPHA_CD_DOT_PRODUCT						(1 << 12)
+#define   NV34TCL_RC_OUT_ALPHA_AB_DOT_PRODUCT						(1 << 13)
+#define   NV34TCL_RC_OUT_ALPHA_MUX_SUM							(1 << 14)
+#define   NV34TCL_RC_OUT_ALPHA_BIAS							(1 << 15)
+#define    NV34TCL_RC_OUT_ALPHA_BIAS_NONE						0x00000000
+#define    NV34TCL_RC_OUT_ALPHA_BIAS_BIAS_BY_NEGATIVE_ONE_HALF				0x00008000
+#define   NV34TCL_RC_OUT_ALPHA_SCALE_SHIFT						17
+#define   NV34TCL_RC_OUT_ALPHA_SCALE_MASK						0x00000000
+#define    NV34TCL_RC_OUT_ALPHA_SCALE_NONE						0x00000000
+#define    NV34TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_TWO					0x00020000
+#define    NV34TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_FOUR					0x00040000
+#define    NV34TCL_RC_OUT_ALPHA_SCALE_SCALE_BY_ONE_HALF					0x00060000
+#define  NV34TCL_RC_OUT_RGB(x)								(0x00000914+((x)*32))
+#define  NV34TCL_RC_OUT_RGB__SIZE							0x00000008
+#define   NV34TCL_RC_OUT_RGB_CD_OUTPUT_SHIFT						0
+#define   NV34TCL_RC_OUT_RGB_CD_OUTPUT_MASK						0x0000000f
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_ZERO						0x00000000
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR0					0x00000001
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_CONSTANT_COLOR1					0x00000002
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_FOG						0x00000003
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_PRIMARY_COLOR					0x00000004
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_SECONDARY_COLOR					0x00000005
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE0					0x00000008
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE1					0x00000009
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0						0x0000000c
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_SPARE1						0x0000000d
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x0000000e
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_E_TIMES_F					0x0000000f
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE2					0x0000000a
+#define    NV34TCL_RC_OUT_RGB_CD_OUTPUT_TEXTURE3					0x0000000b
+#define   NV34TCL_RC_OUT_RGB_AB_OUTPUT_SHIFT						4
+#define   NV34TCL_RC_OUT_RGB_AB_OUTPUT_MASK						0x000000f0
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_ZERO						0x00000000
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR0					0x00000010
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_CONSTANT_COLOR1					0x00000020
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_FOG						0x00000030
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_PRIMARY_COLOR					0x00000040
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_SECONDARY_COLOR					0x00000050
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE0					0x00000080
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE1					0x00000090
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0						0x000000c0
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_SPARE1						0x000000d0
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x000000e0
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_E_TIMES_F					0x000000f0
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE2					0x000000a0
+#define    NV34TCL_RC_OUT_RGB_AB_OUTPUT_TEXTURE3					0x000000b0
+#define   NV34TCL_RC_OUT_RGB_SUM_OUTPUT_SHIFT						8
+#define   NV34TCL_RC_OUT_RGB_SUM_OUTPUT_MASK						0x00000f00
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_ZERO						0x00000000
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR0				0x00000100
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_CONSTANT_COLOR1				0x00000200
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_FOG						0x00000300
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_PRIMARY_COLOR					0x00000400
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_SECONDARY_COLOR				0x00000500
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE0					0x00000800
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE1					0x00000900
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0						0x00000c00
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE1						0x00000d00
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_SPARE0_PLUS_SECONDARY_COLOR			0x00000e00
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_E_TIMES_F					0x00000f00
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE2					0x00000a00
+#define    NV34TCL_RC_OUT_RGB_SUM_OUTPUT_TEXTURE3					0x00000b00
+#define   NV34TCL_RC_OUT_RGB_CD_DOT_PRODUCT						(1 << 12)
+#define   NV34TCL_RC_OUT_RGB_AB_DOT_PRODUCT						(1 << 13)
+#define   NV34TCL_RC_OUT_RGB_MUX_SUM							(1 << 14)
+#define   NV34TCL_RC_OUT_RGB_BIAS							(1 << 15)
+#define    NV34TCL_RC_OUT_RGB_BIAS_NONE							0x00000000
+#define    NV34TCL_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF				0x00008000
+#define   NV34TCL_RC_OUT_RGB_SCALE_SHIFT						17
+#define   NV34TCL_RC_OUT_RGB_SCALE_MASK							0x00000000
+#define    NV34TCL_RC_OUT_RGB_SCALE_NONE						0x00000000
+#define    NV34TCL_RC_OUT_RGB_SCALE_SCALE_BY_TWO					0x00020000
+#define    NV34TCL_RC_OUT_RGB_SCALE_SCALE_BY_FOUR					0x00040000
+#define    NV34TCL_RC_OUT_RGB_SCALE_SCALE_BY_ONE_HALF					0x00060000
+#define  NV34TCL_VIEWPORT_HORIZ								0x00000a00
+#define   NV34TCL_VIEWPORT_HORIZ_X_SHIFT						0
+#define   NV34TCL_VIEWPORT_HORIZ_X_MASK							0x0000ffff
+#define   NV34TCL_VIEWPORT_HORIZ_W_SHIFT						16
+#define   NV34TCL_VIEWPORT_HORIZ_W_MASK							0xffff0000
+#define  NV34TCL_VIEWPORT_VERT								0x00000a04
+#define   NV34TCL_VIEWPORT_VERT_Y_SHIFT							0
+#define   NV34TCL_VIEWPORT_VERT_Y_MASK							0x0000ffff
+#define   NV34TCL_VIEWPORT_VERT_H_SHIFT							16
+#define   NV34TCL_VIEWPORT_VERT_H_MASK							0xffff0000
+#define  NV34TCL_LIGHT_MODEL_FRONT_SIDE_PRODUCT_AMBIENT_PLUS_EMISSION_R			0x00000a10
+#define  NV34TCL_LIGHT_MODEL_FRONT_SIDE_PRODUCT_AMBIENT_PLUS_EMISSION_G			0x00000a14
+#define  NV34TCL_LIGHT_MODEL_FRONT_SIDE_PRODUCT_AMBIENT_PLUS_EMISSION_B			0x00000a18
+#define  NV34TCL_VIEWPORT_TRANSLATE_X							0x00000a20
+#define  NV34TCL_VIEWPORT_TRANSLATE_Y							0x00000a24
+#define  NV34TCL_VIEWPORT_TRANSLATE_Z							0x00000a28
+#define  NV34TCL_VIEWPORT_TRANSLATE_W							0x00000a2c
+#define  NV34TCL_VIEWPORT_SCALE_X							0x00000a30
+#define  NV34TCL_VIEWPORT_SCALE_Y							0x00000a34
+#define  NV34TCL_VIEWPORT_SCALE_Z							0x00000a38
+#define  NV34TCL_VIEWPORT_SCALE_W							0x00000a3c
+#define  NV34TCL_POLYGON_OFFSET_POINT_ENABLE						0x00000a60
+#define  NV34TCL_POLYGON_OFFSET_LINE_ENABLE						0x00000a64
+#define  NV34TCL_POLYGON_OFFSET_FILL_ENABLE						0x00000a68
+#define  NV34TCL_DEPTH_FUNC								0x00000a6c
+#define   NV34TCL_DEPTH_FUNC_NEVER							0x00000200
+#define   NV34TCL_DEPTH_FUNC_LESS							0x00000201
+#define   NV34TCL_DEPTH_FUNC_EQUAL							0x00000202
+#define   NV34TCL_DEPTH_FUNC_LEQUAL							0x00000203
+#define   NV34TCL_DEPTH_FUNC_GREATER							0x00000204
+#define   NV34TCL_DEPTH_FUNC_NOTEQUAL							0x00000205
+#define   NV34TCL_DEPTH_FUNC_GEQUAL							0x00000206
+#define   NV34TCL_DEPTH_FUNC_ALWAYS							0x00000207
+#define  NV34TCL_DEPTH_WRITE_ENABLE							0x00000a70
+#define  NV34TCL_DEPTH_TEST_ENABLE							0x00000a74
+#define  NV34TCL_POLYGON_OFFSET_FACTOR							0x00000a78
+#define  NV34TCL_POLYGON_OFFSET_UNITS							0x00000a7c
+#define  NV34TCL_VTX_ATTR_3I_XY(x)							(0x00000a80+((x)*8))
+#define  NV34TCL_VTX_ATTR_3I_XY__SIZE							0x00000010
+#define   NV34TCL_VTX_ATTR_3I_XY_X_SHIFT						0
+#define   NV34TCL_VTX_ATTR_3I_XY_X_MASK							0x0000ffff
+#define   NV34TCL_VTX_ATTR_3I_XY_Y_SHIFT						16
+#define   NV34TCL_VTX_ATTR_3I_XY_Y_MASK							0xffff0000
+#define  NV34TCL_VTX_ATTR_3I_Z(x)							(0x00000a84+((x)*8))
+#define  NV34TCL_VTX_ATTR_3I_Z__SIZE							0x00000010
+#define   NV34TCL_VTX_ATTR_3I_Z_Z_SHIFT							0
+#define   NV34TCL_VTX_ATTR_3I_Z_Z_MASK							0x0000ffff
+#define  NV34TCL_VP_UPLOAD_INST(x)							(0x00000b80+((x)*4))
+#define  NV34TCL_VP_UPLOAD_INST__SIZE							0x00000004
+#define  NV34TCL_TX0_CLIP_PLANE_A(x)							(0x00000e00+((x)*16))
+#define  NV34TCL_TX0_CLIP_PLANE_A__SIZE							0x00000004
+#define  NV34TCL_TX0_CLIP_PLANE_B(x)							(0x00000e04+((x)*16))
+#define  NV34TCL_TX0_CLIP_PLANE_B__SIZE							0x00000004
+#define  NV34TCL_TX0_CLIP_PLANE_C(x)							(0x00000e08+((x)*16))
+#define  NV34TCL_TX0_CLIP_PLANE_C__SIZE							0x00000004
+#define  NV34TCL_TX0_CLIP_PLANE_D(x)							(0x00000e0c+((x)*16))
+#define  NV34TCL_TX0_CLIP_PLANE_D__SIZE							0x00000004
+#define  NV34TCL_TX1_CLIP_PLANE_A(x)							(0x00000e40+((x)*16))
+#define  NV34TCL_TX1_CLIP_PLANE_A__SIZE							0x00000004
+#define  NV34TCL_TX1_CLIP_PLANE_B(x)							(0x00000e44+((x)*16))
+#define  NV34TCL_TX1_CLIP_PLANE_B__SIZE							0x00000004
+#define  NV34TCL_TX1_CLIP_PLANE_C(x)							(0x00000e48+((x)*16))
+#define  NV34TCL_TX1_CLIP_PLANE_C__SIZE							0x00000004
+#define  NV34TCL_TX1_CLIP_PLANE_D(x)							(0x00000e4c+((x)*16))
+#define  NV34TCL_TX1_CLIP_PLANE_D__SIZE							0x00000004
+#define  NV34TCL_TX2_CLIP_PLANE_A(x)							(0x00000e80+((x)*16))
+#define  NV34TCL_TX2_CLIP_PLANE_A__SIZE							0x00000004
+#define  NV34TCL_TX2_CLIP_PLANE_B(x)							(0x00000e84+((x)*16))
+#define  NV34TCL_TX2_CLIP_PLANE_B__SIZE							0x00000004
+#define  NV34TCL_TX2_CLIP_PLANE_C(x)							(0x00000e88+((x)*16))
+#define  NV34TCL_TX2_CLIP_PLANE_C__SIZE							0x00000004
+#define  NV34TCL_TX2_CLIP_PLANE_D(x)							(0x00000e8c+((x)*16))
+#define  NV34TCL_TX2_CLIP_PLANE_D__SIZE							0x00000004
+#define  NV34TCL_TX3_CLIP_PLANE_A(x)							(0x00000ec0+((x)*16))
+#define  NV34TCL_TX3_CLIP_PLANE_A__SIZE							0x00000004
+#define  NV34TCL_TX3_CLIP_PLANE_B(x)							(0x00000ec4+((x)*16))
+#define  NV34TCL_TX3_CLIP_PLANE_B__SIZE							0x00000004
+#define  NV34TCL_TX3_CLIP_PLANE_C(x)							(0x00000ec8+((x)*16))
+#define  NV34TCL_TX3_CLIP_PLANE_C__SIZE							0x00000004
+#define  NV34TCL_TX3_CLIP_PLANE_D(x)							(0x00000ecc+((x)*16))
+#define  NV34TCL_TX3_CLIP_PLANE_D__SIZE							0x00000004
+#define  NV34TCL_TX4_CLIP_PLANE_A(x)							(0x00000f00+((x)*16))
+#define  NV34TCL_TX4_CLIP_PLANE_A__SIZE							0x00000004
+#define  NV34TCL_TX4_CLIP_PLANE_B(x)							(0x00000f04+((x)*16))
+#define  NV34TCL_TX4_CLIP_PLANE_B__SIZE							0x00000004
+#define  NV34TCL_TX4_CLIP_PLANE_C(x)							(0x00000f08+((x)*16))
+#define  NV34TCL_TX4_CLIP_PLANE_C__SIZE							0x00000004
+#define  NV34TCL_TX4_CLIP_PLANE_D(x)							(0x00000f0c+((x)*16))
+#define  NV34TCL_TX4_CLIP_PLANE_D__SIZE							0x00000004
+#define  NV34TCL_TX5_CLIP_PLANE_A(x)							(0x00000f40+((x)*16))
+#define  NV34TCL_TX5_CLIP_PLANE_A__SIZE							0x00000004
+#define  NV34TCL_TX5_CLIP_PLANE_B(x)							(0x00000f44+((x)*16))
+#define  NV34TCL_TX5_CLIP_PLANE_B__SIZE							0x00000004
+#define  NV34TCL_TX5_CLIP_PLANE_C(x)							(0x00000f48+((x)*16))
+#define  NV34TCL_TX5_CLIP_PLANE_C__SIZE							0x00000004
+#define  NV34TCL_TX5_CLIP_PLANE_D(x)							(0x00000f4c+((x)*16))
+#define  NV34TCL_TX5_CLIP_PLANE_D__SIZE							0x00000004
+#define  NV34TCL_TX6_CLIP_PLANE_A(x)							(0x00000f80+((x)*16))
+#define  NV34TCL_TX6_CLIP_PLANE_A__SIZE							0x00000004
+#define  NV34TCL_TX6_CLIP_PLANE_B(x)							(0x00000f84+((x)*16))
+#define  NV34TCL_TX6_CLIP_PLANE_B__SIZE							0x00000004
+#define  NV34TCL_TX6_CLIP_PLANE_C(x)							(0x00000f88+((x)*16))
+#define  NV34TCL_TX6_CLIP_PLANE_C__SIZE							0x00000004
+#define  NV34TCL_TX6_CLIP_PLANE_D(x)							(0x00000f8c+((x)*16))
+#define  NV34TCL_TX6_CLIP_PLANE_D__SIZE							0x00000004
+#define  NV34TCL_TX7_CLIP_PLANE_A(x)							(0x00000fc0+((x)*16))
+#define  NV34TCL_TX7_CLIP_PLANE_A__SIZE							0x00000004
+#define  NV34TCL_TX7_CLIP_PLANE_B(x)							(0x00000fc4+((x)*16))
+#define  NV34TCL_TX7_CLIP_PLANE_B__SIZE							0x00000004
+#define  NV34TCL_TX7_CLIP_PLANE_C(x)							(0x00000fc8+((x)*16))
+#define  NV34TCL_TX7_CLIP_PLANE_C__SIZE							0x00000004
+#define  NV34TCL_TX7_CLIP_PLANE_D(x)							(0x00000fcc+((x)*16))
+#define  NV34TCL_TX7_CLIP_PLANE_D__SIZE							0x00000004
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_AMBIENT_R(x)					(0x00001000+((x)*64))
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_AMBIENT_R__SIZE				0x00000008
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_AMBIENT_G(x)					(0x00001004+((x)*64))
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_AMBIENT_G__SIZE				0x00000008
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_AMBIENT_B(x)					(0x00001008+((x)*64))
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_AMBIENT_B__SIZE				0x00000008
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_DIFFUSE_R(x)					(0x0000100c+((x)*64))
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_DIFFUSE_R__SIZE				0x00000008
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_DIFFUSE_G(x)					(0x00001010+((x)*64))
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_DIFFUSE_G__SIZE				0x00000008
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_DIFFUSE_B(x)					(0x00001014+((x)*64))
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_DIFFUSE_B__SIZE				0x00000008
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_SPECULAR_R(x)					(0x00001018+((x)*64))
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_SPECULAR_R__SIZE				0x00000008
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_SPECULAR_G(x)					(0x0000101c+((x)*64))
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_SPECULAR_G__SIZE				0x00000008
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_SPECULAR_B(x)					(0x00001020+((x)*64))
+#define  NV34TCL_LIGHT_FRONT_SIDE_PRODUCT_SPECULAR_B__SIZE				0x00000008
+#define  NV34TCL_LIGHT_HALF_VECTOR_X(x)							(0x00001028+((x)*64))
+#define  NV34TCL_LIGHT_HALF_VECTOR_X__SIZE						0x00000008
+#define  NV34TCL_LIGHT_HALF_VECTOR_Y(x)							(0x0000102c+((x)*64))
+#define  NV34TCL_LIGHT_HALF_VECTOR_Y__SIZE						0x00000008
+#define  NV34TCL_LIGHT_HALF_VECTOR_Z(x)							(0x00001030+((x)*64))
+#define  NV34TCL_LIGHT_HALF_VECTOR_Z__SIZE						0x00000008
+#define  NV34TCL_LIGHT_DIRECTION_X(x)							(0x00001034+((x)*64))
+#define  NV34TCL_LIGHT_DIRECTION_X__SIZE						0x00000008
+#define  NV34TCL_LIGHT_DIRECTION_Y(x)							(0x00001038+((x)*64))
+#define  NV34TCL_LIGHT_DIRECTION_Y__SIZE						0x00000008
+#define  NV34TCL_LIGHT_DIRECTION_Z(x)							(0x0000103c+((x)*64))
+#define  NV34TCL_LIGHT_DIRECTION_Z__SIZE						0x00000008
+#define  NV34TCL_LIGHT_SPOT_CUTOFF_A(x)							(0x00001200+((x)*64))
+#define  NV34TCL_LIGHT_SPOT_CUTOFF_A__SIZE						0x00000008
+#define  NV34TCL_LIGHT_SPOT_CUTOFF_B(x)							(0x00001204+((x)*64))
+#define  NV34TCL_LIGHT_SPOT_CUTOFF_B__SIZE						0x00000008
+#define  NV34TCL_LIGHT_SPOT_CUTOFF_C(x)							(0x00001208+((x)*64))
+#define  NV34TCL_LIGHT_SPOT_CUTOFF_C__SIZE						0x00000008
+#define  NV34TCL_LIGHT_SPOT_DIR_X(x)							(0x0000120c+((x)*64))
+#define  NV34TCL_LIGHT_SPOT_DIR_X__SIZE							0x00000008
+#define  NV34TCL_LIGHT_SPOT_DIR_Y(x)							(0x00001210+((x)*64))
+#define  NV34TCL_LIGHT_SPOT_DIR_Y__SIZE							0x00000008
+#define  NV34TCL_LIGHT_SPOT_DIR_Z(x)							(0x00001214+((x)*64))
+#define  NV34TCL_LIGHT_SPOT_DIR_Z__SIZE							0x00000008
+#define  NV34TCL_LIGHT_SPOT_CUTOFF_D(x)							(0x00001218+((x)*64))
+#define  NV34TCL_LIGHT_SPOT_CUTOFF_D__SIZE						0x00000008
+#define  NV34TCL_LIGHT_POSITION_X(x)							(0x0000121c+((x)*64))
+#define  NV34TCL_LIGHT_POSITION_X__SIZE							0x00000008
+#define  NV34TCL_LIGHT_POSITION_Y(x)							(0x00001220+((x)*64))
+#define  NV34TCL_LIGHT_POSITION_Y__SIZE							0x00000008
+#define  NV34TCL_LIGHT_POSITION_Z(x)							(0x00001224+((x)*64))
+#define  NV34TCL_LIGHT_POSITION_Z__SIZE							0x00000008
+#define  NV34TCL_LIGHT_ATTENUATION_CONSTANT(x)						(0x00001228+((x)*64))
+#define  NV34TCL_LIGHT_ATTENUATION_CONSTANT__SIZE					0x00000008
+#define  NV34TCL_LIGHT_ATTENUATION_LINEAR(x)						(0x0000122c+((x)*64))
+#define  NV34TCL_LIGHT_ATTENUATION_LINEAR__SIZE						0x00000008
+#define  NV34TCL_LIGHT_ATTENUATION_QUADRATIC(x)						(0x00001230+((x)*64))
+#define  NV34TCL_LIGHT_ATTENUATION_QUADRATIC__SIZE					0x00000008
+#define  NV34TCL_FRONT_MATERIAL_SHININESS(x)						(0x00001400+((x)*4))
+#define  NV34TCL_FRONT_MATERIAL_SHININESS__SIZE						0x00000006
+#define  NV34TCL_ENABLED_LIGHTS								0x00001420
+#define  NV34TCL_VERTEX_TWO_SIDE_ENABLE							0x0000142c
+#define  NV34TCL_FP_REG_CONTROL								0x00001450
+#define   NV34TCL_FP_REG_CONTROL_UNK1_SHIFT						16
+#define   NV34TCL_FP_REG_CONTROL_UNK1_MASK						0xffff0000
+#define   NV34TCL_FP_REG_CONTROL_UNK0_SHIFT						0
+#define   NV34TCL_FP_REG_CONTROL_UNK0_MASK						0x0000ffff
+#define  NV34TCL_VP_CLIP_PLANES_ENABLE							0x00001478
+#define   NV34TCL_VP_CLIP_PLANES_ENABLE_PLANE0						(1 <<  1)
+#define   NV34TCL_VP_CLIP_PLANES_ENABLE_PLANE1						(1 <<  5)
+#define   NV34TCL_VP_CLIP_PLANES_ENABLE_PLANE2						(1 <<  9)
+#define   NV34TCL_VP_CLIP_PLANES_ENABLE_PLANE3						(1 << 13)
+#define   NV34TCL_VP_CLIP_PLANES_ENABLE_PLANE4						(1 << 17)
+#define   NV34TCL_VP_CLIP_PLANES_ENABLE_PLANE5						(1 << 21)
+#define  NV34TCL_POLYGON_STIPPLE_ENABLE							0x0000147c
+#define  NV34TCL_POLYGON_STIPPLE_PATTERN(x)						(0x00001480+((x)*4))
+#define  NV34TCL_POLYGON_STIPPLE_PATTERN__SIZE						0x00000020
+#define  NV34TCL_VTX_ATTR_3F_X(x)							(0x00001500+((x)*16))
+#define  NV34TCL_VTX_ATTR_3F_X__SIZE							0x00000010
+#define  NV34TCL_VTX_ATTR_3F_Y(x)							(0x00001504+((x)*16))
+#define  NV34TCL_VTX_ATTR_3F_Y__SIZE							0x00000010
+#define  NV34TCL_VTX_ATTR_3F_Z(x)							(0x00001508+((x)*16))
+#define  NV34TCL_VTX_ATTR_3F_Z__SIZE							0x00000010
+#define  NV34TCL_VP_CLIP_PLANE_A(x)							(0x00001600+((x)*16))
+#define  NV34TCL_VP_CLIP_PLANE_A__SIZE							0x00000006
+#define  NV34TCL_VP_CLIP_PLANE_B(x)							(0x00001604+((x)*16))
+#define  NV34TCL_VP_CLIP_PLANE_B__SIZE							0x00000006
+#define  NV34TCL_VP_CLIP_PLANE_C(x)							(0x00001608+((x)*16))
+#define  NV34TCL_VP_CLIP_PLANE_C__SIZE							0x00000006
+#define  NV34TCL_VP_CLIP_PLANE_D(x)							(0x0000160c+((x)*16))
+#define  NV34TCL_VP_CLIP_PLANE_D__SIZE							0x00000006
+#define  NV34TCL_VTXBUF_ADDRESS(x)							(0x00001680+((x)*4))
+#define  NV34TCL_VTXBUF_ADDRESS__SIZE							0x00000010
+#define   NV34TCL_VTXBUF_ADDRESS_DMA1							(1 << 31)
+#define   NV34TCL_VTXBUF_ADDRESS_OFFSET_SHIFT						0
+#define   NV34TCL_VTXBUF_ADDRESS_OFFSET_MASK						0x0fffffff
+#define  NV34TCL_VTXFMT(x)								(0x00001740+((x)*4))
+#define  NV34TCL_VTXFMT__SIZE								0x00000010
+#define   NV34TCL_VTXFMT_TYPE_SHIFT							0
+#define   NV34TCL_VTXFMT_TYPE_MASK							0x0000000f
+#define    NV34TCL_VTXFMT_TYPE_FLOAT							0x00000002
+#define    NV34TCL_VTXFMT_TYPE_HALF							0x00000003
+#define    NV34TCL_VTXFMT_TYPE_UBYTE							0x00000004
+#define    NV34TCL_VTXFMT_TYPE_USHORT							0x00000005
+#define   NV34TCL_VTXFMT_SIZE_SHIFT							4
+#define   NV34TCL_VTXFMT_SIZE_MASK							0x000000f0
+#define   NV34TCL_VTXFMT_STRIDE_SHIFT							8
+#define   NV34TCL_VTXFMT_STRIDE_MASK							0x0000ff00
+#define  NV34TCL_LIGHT_MODEL_BACK_SIDE_PRODUCT_AMBIENT_PLUS_EMISSION_R			0x000017a0
+#define  NV34TCL_LIGHT_MODEL_BACK_SIDE_PRODUCT_AMBIENT_PLUS_EMISSION_G			0x000017a4
+#define  NV34TCL_LIGHT_MODEL_BACK_SIDE_PRODUCT_AMBIENT_PLUS_EMISSION_B			0x000017a8
+#define  NV34TCL_COLOR_MATERIAL_BACK_R							0x000017b0
+#define  NV34TCL_COLOR_MATERIAL_BACK_G							0x000017b4
+#define  NV34TCL_COLOR_MATERIAL_BACK_B							0x000017b8
+#define  NV34TCL_COLOR_MATERIAL_BACK_A							0x000017c0
+#define  NV34TCL_QUERY_RESET								0x000017c8
+#define  NV34TCL_QUERY_UNK17CC								0x000017cc
+#define  NV34TCL_QUERY_GET								0x00001800
+#define   NV34TCL_QUERY_GET_UNK24_SHIFT							24
+#define   NV34TCL_QUERY_GET_UNK24_MASK							0xff000000
+#define   NV34TCL_QUERY_GET_OFFSET_SHIFT						0
+#define   NV34TCL_QUERY_GET_OFFSET_MASK							0x00ffffff
+#define  NV34TCL_VERTEX_BEGIN_END							0x00001808
+#define   NV34TCL_VERTEX_BEGIN_END_STOP							0x00000000
+#define   NV34TCL_VERTEX_BEGIN_END_POINTS						0x00000001
+#define   NV34TCL_VERTEX_BEGIN_END_LINES						0x00000002
+#define   NV34TCL_VERTEX_BEGIN_END_LINE_LOOP						0x00000003
+#define   NV34TCL_VERTEX_BEGIN_END_LINE_STRIP						0x00000004
+#define   NV34TCL_VERTEX_BEGIN_END_TRIANGLES						0x00000005
+#define   NV34TCL_VERTEX_BEGIN_END_TRIANGLE_STRIP					0x00000006
+#define   NV34TCL_VERTEX_BEGIN_END_TRIANGLE_FAN						0x00000007
+#define   NV34TCL_VERTEX_BEGIN_END_QUADS						0x00000008
+#define   NV34TCL_VERTEX_BEGIN_END_QUAD_STRIP						0x00000009
+#define   NV34TCL_VERTEX_BEGIN_END_POLYGON						0x0000000a
+#define  NV34TCL_VB_ELEMENT_U16								0x0000180c
+#define   NV34TCL_VB_ELEMENT_U16_I0_SHIFT						0
+#define   NV34TCL_VB_ELEMENT_U16_I0_MASK						0x0000ffff
+#define   NV34TCL_VB_ELEMENT_U16_I1_SHIFT						16
+#define   NV34TCL_VB_ELEMENT_U16_I1_MASK						0xffff0000
+#define  NV34TCL_VB_ELEMENT_U32								0x00001810
+#define  NV34TCL_VB_VERTEX_BATCH							0x00001814
+#define   NV34TCL_VB_VERTEX_BATCH_OFFSET_SHIFT						0
+#define   NV34TCL_VB_VERTEX_BATCH_OFFSET_MASK						0x00ffffff
+#define   NV34TCL_VB_VERTEX_BATCH_COUNT_SHIFT						24
+#define   NV34TCL_VB_VERTEX_BATCH_COUNT_MASK						0xff000000
+#define  NV34TCL_VERTEX_DATA								0x00001818
+#define  NV34TCL_IDXBUF_ADDRESS								0x0000181c
+#define  NV34TCL_IDXBUF_FORMAT								0x00001820
+#define   NV34TCL_IDXBUF_FORMAT_TYPE_SHIFT						4
+#define   NV34TCL_IDXBUF_FORMAT_TYPE_MASK						0x000000f0
+#define    NV34TCL_IDXBUF_FORMAT_TYPE_U32						0x00000000
+#define    NV34TCL_IDXBUF_FORMAT_TYPE_U16						0x00000010
+#define   NV34TCL_IDXBUF_FORMAT_DMA1							(1 <<  0)
+#define  NV34TCL_VB_INDEX_BATCH								0x00001824
+#define   NV34TCL_VB_INDEX_BATCH_COUNT_SHIFT						24
+#define   NV34TCL_VB_INDEX_BATCH_COUNT_MASK						0xff000000
+#define   NV34TCL_VB_INDEX_BATCH_START_SHIFT						0
+#define   NV34TCL_VB_INDEX_BATCH_START_MASK						0x00ffffff
+#define  NV34TCL_POLYGON_MODE_FRONT							0x00001828
+#define   NV34TCL_POLYGON_MODE_FRONT_POINT						0x00001b00
+#define   NV34TCL_POLYGON_MODE_FRONT_LINE						0x00001b01
+#define   NV34TCL_POLYGON_MODE_FRONT_FILL						0x00001b02
+#define  NV34TCL_POLYGON_MODE_BACK							0x0000182c
+#define   NV34TCL_POLYGON_MODE_BACK_POINT						0x00001b00
+#define   NV34TCL_POLYGON_MODE_BACK_LINE						0x00001b01
+#define   NV34TCL_POLYGON_MODE_BACK_FILL						0x00001b02
+#define  NV34TCL_CULL_FACE								0x00001830
+#define   NV34TCL_CULL_FACE_FRONT							0x00000404
+#define   NV34TCL_CULL_FACE_BACK							0x00000405
+#define   NV34TCL_CULL_FACE_FRONT_AND_BACK						0x00000408
+#define  NV34TCL_FRONT_FACE								0x00001834
+#define   NV34TCL_FRONT_FACE_CW								0x00000900
+#define   NV34TCL_FRONT_FACE_CCW							0x00000901
+#define  NV34TCL_POLYGON_SMOOTH_ENABLE							0x00001838
+#define  NV34TCL_CULL_FACE_ENABLE							0x0000183c
+#define  NV34TCL_TX_PALETTE_OFFSET(x)							(0x00001840+((x)*4))
+#define  NV34TCL_TX_PALETTE_OFFSET__SIZE						0x00000008
+#define  NV34TCL_VTX_ATTR_2F_X(x)							(0x00001880+((x)*8))
+#define  NV34TCL_VTX_ATTR_2F_X__SIZE							0x00000010
+#define  NV34TCL_VTX_ATTR_2F_Y(x)							(0x00001884+((x)*8))
+#define  NV34TCL_VTX_ATTR_2F_Y__SIZE							0x00000010
+#define  NV34TCL_VTX_ATTR_2I(x)								(0x00001900+((x)*4))
+#define  NV34TCL_VTX_ATTR_2I__SIZE							0x00000010
+#define   NV34TCL_VTX_ATTR_2I_X_SHIFT							0
+#define   NV34TCL_VTX_ATTR_2I_X_MASK							0x0000ffff
+#define   NV34TCL_VTX_ATTR_2I_Y_SHIFT							16
+#define   NV34TCL_VTX_ATTR_2I_Y_MASK							0xffff0000
+#define  NV34TCL_VTX_ATTR_4UB(x)							(0x00001940+((x)*4))
+#define  NV34TCL_VTX_ATTR_4UB__SIZE							0x00000010
+#define   NV34TCL_VTX_ATTR_4UB_X_SHIFT							0
+#define   NV34TCL_VTX_ATTR_4UB_X_MASK							0x000000ff
+#define   NV34TCL_VTX_ATTR_4UB_Y_SHIFT							8
+#define   NV34TCL_VTX_ATTR_4UB_Y_MASK							0x0000ff00
+#define   NV34TCL_VTX_ATTR_4UB_Z_SHIFT							16
+#define   NV34TCL_VTX_ATTR_4UB_Z_MASK							0x00ff0000
+#define   NV34TCL_VTX_ATTR_4UB_W_SHIFT							24
+#define   NV34TCL_VTX_ATTR_4UB_W_MASK							0xff000000
+#define  NV34TCL_VTX_ATTR_4I_XY(x)							(0x00001980+((x)*8))
+#define  NV34TCL_VTX_ATTR_4I_XY__SIZE							0x00000010
+#define   NV34TCL_VTX_ATTR_4I_XY_X_SHIFT						0
+#define   NV34TCL_VTX_ATTR_4I_XY_X_MASK							0x0000ffff
+#define   NV34TCL_VTX_ATTR_4I_XY_Y_SHIFT						16
+#define   NV34TCL_VTX_ATTR_4I_XY_Y_MASK							0xffff0000
+#define  NV34TCL_VTX_ATTR_4I_ZW(x)							(0x00001984+((x)*8))
+#define  NV34TCL_VTX_ATTR_4I_ZW__SIZE							0x00000010
+#define   NV34TCL_VTX_ATTR_4I_ZW_Z_SHIFT						0
+#define   NV34TCL_VTX_ATTR_4I_ZW_Z_MASK							0x0000ffff
+#define   NV34TCL_VTX_ATTR_4I_ZW_W_SHIFT						16
+#define   NV34TCL_VTX_ATTR_4I_ZW_W_MASK							0xffff0000
+#define  NV34TCL_TX_OFFSET(x)								(0x00001a00+((x)*32))
+#define  NV34TCL_TX_OFFSET__SIZE							0x00000008
+#define  NV34TCL_TX_FORMAT(x)								(0x00001a04+((x)*32))
+#define  NV34TCL_TX_FORMAT__SIZE							0x00000008
+#define   NV34TCL_TX_FORMAT_DMA0							(1 <<  0)
+#define   NV34TCL_TX_FORMAT_DMA1							(1 <<  1)
+#define   NV34TCL_TX_FORMAT_CUBIC							(1 <<  2)
+#define   NV34TCL_TX_FORMAT_NO_BORDER							(1 <<  3)
+#define   NV34TCL_TX_FORMAT_DIMS_SHIFT							4
+#define   NV34TCL_TX_FORMAT_DIMS_MASK							0x000000f0
+#define    NV34TCL_TX_FORMAT_DIMS_1D							0x00000010
+#define    NV34TCL_TX_FORMAT_DIMS_2D							0x00000020
+#define    NV34TCL_TX_FORMAT_DIMS_3D							0x00000030
+#define   NV34TCL_TX_FORMAT_FORMAT_SHIFT						8
+#define   NV34TCL_TX_FORMAT_FORMAT_MASK							0x0000ff00
+#define    NV34TCL_TX_FORMAT_FORMAT_L8							0x00000000
+#define    NV34TCL_TX_FORMAT_FORMAT_A8							0x00000100
+#define    NV34TCL_TX_FORMAT_FORMAT_A1R5G5B5						0x00000200
+#define    NV34TCL_TX_FORMAT_FORMAT_A4R4G4B4						0x00000400
+#define    NV34TCL_TX_FORMAT_FORMAT_R5G6B5						0x00000500
+#define    NV34TCL_TX_FORMAT_FORMAT_A8R8G8B8						0x00000600
+#define    NV34TCL_TX_FORMAT_FORMAT_X8R8G8B8						0x00000700
+#define    NV34TCL_TX_FORMAT_FORMAT_INDEX8						0x00000b00
+#define    NV34TCL_TX_FORMAT_FORMAT_DXT1						0x00000c00
+#define    NV34TCL_TX_FORMAT_FORMAT_DXT3						0x00000e00
+#define    NV34TCL_TX_FORMAT_FORMAT_DXT5						0x00000f00
+#define    NV34TCL_TX_FORMAT_FORMAT_A1R5G5B5_RECT					0x00001000
+#define    NV34TCL_TX_FORMAT_FORMAT_R5G6B5_RECT						0x00001100
+#define    NV34TCL_TX_FORMAT_FORMAT_A8R8G8B8_RECT					0x00001200
+#define    NV34TCL_TX_FORMAT_FORMAT_L8_RECT						0x00001300
+#define    NV34TCL_TX_FORMAT_FORMAT_DSDT8_RECT						0x00001700
+#define    NV34TCL_TX_FORMAT_FORMAT_A8L8						0x00001a00
+#define    NV34TCL_TX_FORMAT_FORMAT_A8_RECT						0x00001b00
+#define    NV34TCL_TX_FORMAT_FORMAT_A4R4G4B4_RECT					0x00001d00
+#define    NV34TCL_TX_FORMAT_FORMAT_R8G8B8_RECT						0x00001e00
+#define    NV34TCL_TX_FORMAT_FORMAT_A8L8_RECT						0x00002000
+#define    NV34TCL_TX_FORMAT_FORMAT_DSDT8						0x00002800
+#define    NV34TCL_TX_FORMAT_FORMAT_HILO16						0x00003300
+#define    NV34TCL_TX_FORMAT_FORMAT_HILO16_RECT						0x00003600
+#define    NV34TCL_TX_FORMAT_FORMAT_HILO8						0x00004400
+#define    NV34TCL_TX_FORMAT_FORMAT_SIGNED_HILO8					0x00004500
+#define    NV34TCL_TX_FORMAT_FORMAT_HILO8_RECT						0x00004600
+#define    NV34TCL_TX_FORMAT_FORMAT_SIGNED_HILO8_RECT					0x00004700
+#define    NV34TCL_TX_FORMAT_FORMAT_A16							0x00003200
+#define    NV34TCL_TX_FORMAT_FORMAT_A16_RECT						0x00003500
+#define    NV34TCL_TX_FORMAT_FORMAT_FLOAT_RGBA16_NV					0x00004a00
+#define    NV34TCL_TX_FORMAT_FORMAT_FLOAT_RGBA32_NV					0x00004b00
+#define    NV34TCL_TX_FORMAT_FORMAT_FLOAT_R32_NV					0x00004c00
+#define   NV34TCL_TX_FORMAT_MIPMAP							(1 << 19)
+#define   NV34TCL_TX_FORMAT_BASE_SIZE_U_SHIFT						20
+#define   NV34TCL_TX_FORMAT_BASE_SIZE_U_MASK						0x00f00000
+#define   NV34TCL_TX_FORMAT_BASE_SIZE_V_SHIFT						24
+#define   NV34TCL_TX_FORMAT_BASE_SIZE_V_MASK						0x0f000000
+#define   NV34TCL_TX_FORMAT_BASE_SIZE_W_SHIFT						28
+#define   NV34TCL_TX_FORMAT_BASE_SIZE_W_MASK						0xf0000000
+#define  NV34TCL_TX_WRAP(x)								(0x00001a08+((x)*32))
+#define  NV34TCL_TX_WRAP__SIZE								0x00000008
+#define   NV34TCL_TX_WRAP_S_SHIFT							0
+#define   NV34TCL_TX_WRAP_S_MASK							0x000000ff
+#define    NV34TCL_TX_WRAP_S_REPEAT							0x00000001
+#define    NV34TCL_TX_WRAP_S_MIRRORED_REPEAT						0x00000002
+#define    NV34TCL_TX_WRAP_S_CLAMP_TO_EDGE						0x00000003
+#define    NV34TCL_TX_WRAP_S_CLAMP_TO_BORDER						0x00000004
+#define    NV34TCL_TX_WRAP_S_CLAMP							0x00000005
+#define   NV34TCL_TX_WRAP_T_SHIFT							8
+#define   NV34TCL_TX_WRAP_T_MASK							0x00000f00
+#define    NV34TCL_TX_WRAP_T_REPEAT							0x00000100
+#define    NV34TCL_TX_WRAP_T_MIRRORED_REPEAT						0x00000200
+#define    NV34TCL_TX_WRAP_T_CLAMP_TO_EDGE						0x00000300
+#define    NV34TCL_TX_WRAP_T_CLAMP_TO_BORDER						0x00000400
+#define    NV34TCL_TX_WRAP_T_CLAMP							0x00000500
+#define   NV34TCL_TX_WRAP_EXPAND_NORMAL_SHIFT						12
+#define   NV34TCL_TX_WRAP_EXPAND_NORMAL_MASK						0x0000f000
+#define   NV34TCL_TX_WRAP_R_SHIFT							16
+#define   NV34TCL_TX_WRAP_R_MASK							0x000f0000
+#define    NV34TCL_TX_WRAP_R_REPEAT							0x00010000
+#define    NV34TCL_TX_WRAP_R_MIRRORED_REPEAT						0x00020000
+#define    NV34TCL_TX_WRAP_R_CLAMP_TO_EDGE						0x00030000
+#define    NV34TCL_TX_WRAP_R_CLAMP_TO_BORDER						0x00040000
+#define    NV34TCL_TX_WRAP_R_CLAMP							0x00050000
+#define   NV34TCL_TX_WRAP_RCOMP_SHIFT							28
+#define   NV34TCL_TX_WRAP_RCOMP_MASK							0xf0000000
+#define    NV34TCL_TX_WRAP_RCOMP_NEVER							0x00000000
+#define    NV34TCL_TX_WRAP_RCOMP_GREATER						0x10000000
+#define    NV34TCL_TX_WRAP_RCOMP_EQUAL							0x20000000
+#define    NV34TCL_TX_WRAP_RCOMP_GEQUAL							0x30000000
+#define    NV34TCL_TX_WRAP_RCOMP_LESS							0x40000000
+#define    NV34TCL_TX_WRAP_RCOMP_NOTEQUAL						0x50000000
+#define    NV34TCL_TX_WRAP_RCOMP_LEQUAL							0x60000000
+#define    NV34TCL_TX_WRAP_RCOMP_ALWAYS							0x70000000
+#define  NV34TCL_TX_ENABLE(x)								(0x00001a0c+((x)*32))
+#define  NV34TCL_TX_ENABLE__SIZE							0x00000008
+#define   NV34TCL_TX_ENABLE_ANISO_SHIFT							4
+#define   NV34TCL_TX_ENABLE_ANISO_MASK							0x00000030
+#define    NV34TCL_TX_ENABLE_ANISO_NONE							0x00000000
+#define    NV34TCL_TX_ENABLE_ANISO_2X							0x00000010
+#define    NV34TCL_TX_ENABLE_ANISO_4X							0x00000020
+#define    NV34TCL_TX_ENABLE_ANISO_8X							0x00000030
+#define   NV34TCL_TX_ENABLE_MIPMAP_MAX_LOD_SHIFT					14
+#define   NV34TCL_TX_ENABLE_MIPMAP_MAX_LOD_MASK						0x0003c000
+#define   NV34TCL_TX_ENABLE_MIPMAP_MIN_LOD_SHIFT					26
+#define   NV34TCL_TX_ENABLE_MIPMAP_MIN_LOD_MASK						0x3c000000
+#define   NV34TCL_TX_ENABLE_ENABLE							(1 << 30)
+#define  NV34TCL_TX_SWIZZLE(x)								(0x00001a10+((x)*32))
+#define  NV34TCL_TX_SWIZZLE__SIZE							0x00000008
+#define   NV34TCL_TX_SWIZZLE_S0_X_SHIFT							14
+#define   NV34TCL_TX_SWIZZLE_S0_X_MASK							0x0000c000
+#define    NV34TCL_TX_SWIZZLE_S0_X_ZERO							0x00000000
+#define    NV34TCL_TX_SWIZZLE_S0_X_ONE							0x00004000
+#define    NV34TCL_TX_SWIZZLE_S0_X_S1							0x00008000
+#define   NV34TCL_TX_SWIZZLE_S0_Y_SHIFT							12
+#define   NV34TCL_TX_SWIZZLE_S0_Y_MASK							0x00003000
+#define    NV34TCL_TX_SWIZZLE_S0_Y_ZERO							0x00000000
+#define    NV34TCL_TX_SWIZZLE_S0_Y_ONE							0x00001000
+#define    NV34TCL_TX_SWIZZLE_S0_Y_S1							0x00002000
+#define   NV34TCL_TX_SWIZZLE_S0_Z_SHIFT							10
+#define   NV34TCL_TX_SWIZZLE_S0_Z_MASK							0x00000c00
+#define    NV34TCL_TX_SWIZZLE_S0_Z_ZERO							0x00000000
+#define    NV34TCL_TX_SWIZZLE_S0_Z_ONE							0x00000400
+#define    NV34TCL_TX_SWIZZLE_S0_Z_S1							0x00000800
+#define   NV34TCL_TX_SWIZZLE_S0_W_SHIFT							8
+#define   NV34TCL_TX_SWIZZLE_S0_W_MASK							0x00000300
+#define    NV34TCL_TX_SWIZZLE_S0_W_ZERO							0x00000000
+#define    NV34TCL_TX_SWIZZLE_S0_W_ONE							0x00000100
+#define    NV34TCL_TX_SWIZZLE_S0_W_S1							0x00000200
+#define   NV34TCL_TX_SWIZZLE_S1_X_SHIFT							6
+#define   NV34TCL_TX_SWIZZLE_S1_X_MASK							0x000000c0
+#define    NV34TCL_TX_SWIZZLE_S1_X_W							0x00000000
+#define    NV34TCL_TX_SWIZZLE_S1_X_Z							0x00000040
+#define    NV34TCL_TX_SWIZZLE_S1_X_Y							0x00000080
+#define    NV34TCL_TX_SWIZZLE_S1_X_X							0x000000c0
+#define   NV34TCL_TX_SWIZZLE_S1_Y_SHIFT							4
+#define   NV34TCL_TX_SWIZZLE_S1_Y_MASK							0x00000030
+#define    NV34TCL_TX_SWIZZLE_S1_Y_W							0x00000000
+#define    NV34TCL_TX_SWIZZLE_S1_Y_Z							0x00000010
+#define    NV34TCL_TX_SWIZZLE_S1_Y_Y							0x00000020
+#define    NV34TCL_TX_SWIZZLE_S1_Y_X							0x00000030
+#define   NV34TCL_TX_SWIZZLE_S1_Z_SHIFT							2
+#define   NV34TCL_TX_SWIZZLE_S1_Z_MASK							0x0000000c
+#define    NV34TCL_TX_SWIZZLE_S1_Z_W							0x00000000
+#define    NV34TCL_TX_SWIZZLE_S1_Z_Z							0x00000004
+#define    NV34TCL_TX_SWIZZLE_S1_Z_Y							0x00000008
+#define    NV34TCL_TX_SWIZZLE_S1_Z_X							0x0000000c
+#define   NV34TCL_TX_SWIZZLE_S1_W_SHIFT							0
+#define   NV34TCL_TX_SWIZZLE_S1_W_MASK							0x00000003
+#define    NV34TCL_TX_SWIZZLE_S1_W_W							0x00000000
+#define    NV34TCL_TX_SWIZZLE_S1_W_Z							0x00000001
+#define    NV34TCL_TX_SWIZZLE_S1_W_Y							0x00000002
+#define    NV34TCL_TX_SWIZZLE_S1_W_X							0x00000003
+#define   NV34TCL_TX_SWIZZLE_RECT_PITCH_SHIFT						16
+#define   NV34TCL_TX_SWIZZLE_RECT_PITCH_MASK						0xffff0000
+#define  NV34TCL_TX_FILTER(x)								(0x00001a14+((x)*32))
+#define  NV34TCL_TX_FILTER__SIZE							0x00000008
+#define   NV34TCL_TX_FILTER_LOD_BIAS_SHIFT						8
+#define   NV34TCL_TX_FILTER_LOD_BIAS_MASK						0x00000f00
+#define   NV34TCL_TX_FILTER_MINIFY_SHIFT						16
+#define   NV34TCL_TX_FILTER_MINIFY_MASK							0x000f0000
+#define    NV34TCL_TX_FILTER_MINIFY_NEAREST						0x00010000
+#define    NV34TCL_TX_FILTER_MINIFY_LINEAR						0x00020000
+#define    NV34TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_NEAREST				0x00030000
+#define    NV34TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_NEAREST				0x00040000
+#define    NV34TCL_TX_FILTER_MINIFY_NEAREST_MIPMAP_LINEAR				0x00050000
+#define    NV34TCL_TX_FILTER_MINIFY_LINEAR_MIPMAP_LINEAR				0x00060000
+#define   NV34TCL_TX_FILTER_MAGNIFY_SHIFT						24
+#define   NV34TCL_TX_FILTER_MAGNIFY_MASK						0x0f000000
+#define    NV34TCL_TX_FILTER_MAGNIFY_NEAREST						0x01000000
+#define    NV34TCL_TX_FILTER_MAGNIFY_LINEAR						0x02000000
+#define   NV34TCL_TX_FILTER_SIGNED_BLUE							(1 << 28)
+#define   NV34TCL_TX_FILTER_SIGNED_GREEN						(1 << 29)
+#define   NV34TCL_TX_FILTER_SIGNED_RED							(1 << 30)
+#define   NV34TCL_TX_FILTER_SIGNED_ALPHA						(1 << 31)
+#define  NV34TCL_TX_NPOT_SIZE(x)							(0x00001a18+((x)*32))
+#define  NV34TCL_TX_NPOT_SIZE__SIZE							0x00000008
+#define   NV34TCL_TX_NPOT_SIZE_H_SHIFT							0
+#define   NV34TCL_TX_NPOT_SIZE_H_MASK							0x0000ffff
+#define   NV34TCL_TX_NPOT_SIZE_W_SHIFT							16
+#define   NV34TCL_TX_NPOT_SIZE_W_MASK							0xffff0000
+#define  NV34TCL_TX_BORDER_COLOR(x)							(0x00001a1c+((x)*32))
+#define  NV34TCL_TX_BORDER_COLOR__SIZE							0x00000008
+#define   NV34TCL_TX_BORDER_COLOR_B_SHIFT						0
+#define   NV34TCL_TX_BORDER_COLOR_B_MASK						0x000000ff
+#define   NV34TCL_TX_BORDER_COLOR_G_SHIFT						8
+#define   NV34TCL_TX_BORDER_COLOR_G_MASK						0x0000ff00
+#define   NV34TCL_TX_BORDER_COLOR_R_SHIFT						16
+#define   NV34TCL_TX_BORDER_COLOR_R_MASK						0x00ff0000
+#define   NV34TCL_TX_BORDER_COLOR_A_SHIFT						24
+#define   NV34TCL_TX_BORDER_COLOR_A_MASK						0xff000000
+#define  NV34TCL_VTX_ATTR_4F_X(x)							(0x00001c00+((x)*16))
+#define  NV34TCL_VTX_ATTR_4F_X__SIZE							0x00000010
+#define  NV34TCL_VTX_ATTR_4F_Y(x)							(0x00001c04+((x)*16))
+#define  NV34TCL_VTX_ATTR_4F_Y__SIZE							0x00000010
+#define  NV34TCL_VTX_ATTR_4F_Z(x)							(0x00001c08+((x)*16))
+#define  NV34TCL_VTX_ATTR_4F_Z__SIZE							0x00000010
+#define  NV34TCL_VTX_ATTR_4F_W(x)							(0x00001c0c+((x)*16))
+#define  NV34TCL_VTX_ATTR_4F_W__SIZE							0x00000010
+#define  NV34TCL_FP_CONTROL								0x00001d60
+#define   NV34TCL_FP_CONTROL_USES_KIL							(1 <<  7)
+#define   NV34TCL_FP_CONTROL_USED_REGS_MINUS1_DIV2_SHIFT				0
+#define   NV34TCL_FP_CONTROL_USED_REGS_MINUS1_DIV2_MASK					0x0000000f
+#define  NV34TCL_DEPTH_UNK17D8								0x00001d78
+#define   NV34TCL_DEPTH_UNK17D8_CLAMP_SHIFT						4
+#define   NV34TCL_DEPTH_UNK17D8_CLAMP_MASK						0x000000f0
+#define  NV34TCL_MULTISAMPLE_CONTROL							0x00001d7c
+#define   NV34TCL_MULTISAMPLE_CONTROL_ENABLE						(1 <<  0)
+#define   NV34TCL_MULTISAMPLE_CONTROL_SAMPLE_ALPHA_TO_COVERAGE				(1 <<  4)
+#define   NV34TCL_MULTISAMPLE_CONTROL_SAMPLE_ALPHA_TO_ONE				(1 <<  8)
+#define   NV34TCL_MULTISAMPLE_CONTROL_SAMPLE_COVERAGE_SHIFT				16
+#define   NV34TCL_MULTISAMPLE_CONTROL_SAMPLE_COVERAGE_MASK				0xffff0000
+#define  NV34TCL_CLEAR_DEPTH_VALUE							0x00001d8c
+#define  NV34TCL_CLEAR_COLOR_VALUE							0x00001d90
+#define   NV34TCL_CLEAR_COLOR_VALUE_B_SHIFT						0
+#define   NV34TCL_CLEAR_COLOR_VALUE_B_MASK						0x000000ff
+#define   NV34TCL_CLEAR_COLOR_VALUE_G_SHIFT						8
+#define   NV34TCL_CLEAR_COLOR_VALUE_G_MASK						0x0000ff00
+#define   NV34TCL_CLEAR_COLOR_VALUE_R_SHIFT						16
+#define   NV34TCL_CLEAR_COLOR_VALUE_R_MASK						0x00ff0000
+#define   NV34TCL_CLEAR_COLOR_VALUE_A_SHIFT						24
+#define   NV34TCL_CLEAR_COLOR_VALUE_A_MASK						0xff000000
+#define  NV34TCL_CLEAR_BUFFERS								0x00001d94
+#define   NV34TCL_CLEAR_BUFFERS_COLOR_A							(1 <<  7)
+#define   NV34TCL_CLEAR_BUFFERS_COLOR_B							(1 <<  6)
+#define   NV34TCL_CLEAR_BUFFERS_COLOR_G							(1 <<  5)
+#define   NV34TCL_CLEAR_BUFFERS_COLOR_R							(1 <<  4)
+#define   NV34TCL_CLEAR_BUFFERS_STENCIL							(1 <<  1)
+#define   NV34TCL_CLEAR_BUFFERS_DEPTH							(1 <<  0)
+#define  NV34TCL_DO_VERTICES								0x00001dac
+#define  NV34TCL_LINE_STIPPLE_ENABLE							0x00001db4
+#define  NV34TCL_LINE_STIPPLE_PATTERN							0x00001db8
+#define   NV34TCL_LINE_STIPPLE_PATTERN_FACTOR_SHIFT					0
+#define   NV34TCL_LINE_STIPPLE_PATTERN_FACTOR_MASK					0x0000ffff
+#define   NV34TCL_LINE_STIPPLE_PATTERN_PATTERN_SHIFT					16
+#define   NV34TCL_LINE_STIPPLE_PATTERN_PATTERN_MASK					0xffff0000
+#define  NV34TCL_BACK_MATERIAL_SHININESS(x)						(0x00001e20+((x)*4))
+#define  NV34TCL_BACK_MATERIAL_SHININESS__SIZE						0x00000006
+#define  NV34TCL_VTX_ATTR_1F(x)								(0x00001e40+((x)*4))
+#define  NV34TCL_VTX_ATTR_1F__SIZE							0x00000010
+#define  NV34TCL_ENGINE									0x00001e94
+#define   NV34TCL_ENGINE_FP								(1 <<  0)
+#define   NV34TCL_ENGINE_VP								(1 <<  1)
+#define   NV34TCL_ENGINE_FIXED								(1 <<  2)
+#define  NV34TCL_VP_UPLOAD_FROM_ID							0x00001e9c
+#define  NV34TCL_VP_START_FROM_ID							0x00001ea0
+#define  NV34TCL_POINT_PARAMETERS(x)							(0x00001ec0+((x)*4))
+#define  NV34TCL_POINT_PARAMETERS__SIZE							0x00000008
+#define  NV34TCL_POINT_SIZE								0x00001ee0
+#define  NV34TCL_POINT_PARAMETERS_ENABLE						0x00001ee4
+#define  NV34TCL_POINT_SPRITE								0x00001ee8
+#define   NV34TCL_POINT_SPRITE_ENABLE							(1 <<  0)
+#define   NV34TCL_POINT_SPRITE_R_MODE_SHIFT						1
+#define   NV34TCL_POINT_SPRITE_R_MODE_MASK						0x00000006
+#define    NV34TCL_POINT_SPRITE_R_MODE_ZERO						0x00000000
+#define    NV34TCL_POINT_SPRITE_R_MODE_R						0x00000002
+#define    NV34TCL_POINT_SPRITE_R_MODE_S						0x00000004
+#define   NV34TCL_POINT_SPRITE_COORD_REPLACE_0						(1 <<  8)
+#define   NV34TCL_POINT_SPRITE_COORD_REPLACE_1						(1 <<  9)
+#define   NV34TCL_POINT_SPRITE_COORD_REPLACE_2						(1 << 10)
+#define   NV34TCL_POINT_SPRITE_COORD_REPLACE_3						(1 << 11)
+#define   NV34TCL_POINT_SPRITE_COORD_REPLACE_4						(1 << 12)
+#define   NV34TCL_POINT_SPRITE_COORD_REPLACE_5						(1 << 13)
+#define   NV34TCL_POINT_SPRITE_COORD_REPLACE_6						(1 << 14)
+#define   NV34TCL_POINT_SPRITE_COORD_REPLACE_7						(1 << 15)
+#define  NV34TCL_VP_UPLOAD_CONST_ID							0x00001efc
+#define  NV34TCL_VP_UPLOAD_CONST_X(x)							(0x00001f00+((x)*16))
+#define  NV34TCL_VP_UPLOAD_CONST_X__SIZE						0x00000004
+#define  NV34TCL_VP_UPLOAD_CONST_Y(x)							(0x00001f04+((x)*16))
+#define  NV34TCL_VP_UPLOAD_CONST_Y__SIZE						0x00000004
+#define  NV34TCL_VP_UPLOAD_CONST_Z(x)							(0x00001f08+((x)*16))
+#define  NV34TCL_VP_UPLOAD_CONST_Z__SIZE						0x00000004
+#define  NV34TCL_VP_UPLOAD_CONST_W(x)							(0x00001f0c+((x)*16))
+#define  NV34TCL_VP_UPLOAD_CONST_W__SIZE						0x00000004
+#define  NV34TCL_UNK1f80(x)								(0x00001f80+((x)*4))
+#define  NV34TCL_UNK1f80__SIZE								0x00000010
+
+
+#define NV40TCL										0x00004097
+
+#define  NV40TCL_REF_CNT								0x00000050
+#define  NV40TCL_NOP									0x00000100
+#define  NV40TCL_NOTIFY									0x00000104
+#define  NV40TCL_DMA_NOTIFY								0x00000180
+#define  NV40TCL_DMA_TEXTURE0								0x00000184
+#define  NV40TCL_DMA_TEXTURE1								0x00000188
+#define  NV40TCL_DMA_COLOR1								0x0000018c
+#define  NV40TCL_DMA_COLOR0								0x00000194
+#define  NV40TCL_DMA_ZETA								0x00000198
+#define  NV40TCL_DMA_VTXBUF0								0x0000019c
+#define  NV40TCL_DMA_VTXBUF1								0x000001a0
+#define  NV40TCL_DMA_FENCE								0x000001a4
+#define  NV40TCL_DMA_QUERY								0x000001a8
+#define  NV40TCL_DMA_UNK01AC								0x000001ac
+#define  NV40TCL_DMA_UNK01B0								0x000001b0
+#define  NV40TCL_DMA_COLOR2								0x000001b4
+#define  NV40TCL_DMA_COLOR3								0x000001b8
+#define  NV40TCL_RT_HORIZ								0x00000200
+#define   NV40TCL_RT_HORIZ_W_SHIFT							16
+#define   NV40TCL_RT_HORIZ_W_MASK							0xffff0000
+#define   NV40TCL_RT_HORIZ_X_SHIFT							0
+#define   NV40TCL_RT_HORIZ_X_MASK							0x0000ffff
+#define  NV40TCL_RT_VERT								0x00000204
+#define   NV40TCL_RT_VERT_H_SHIFT							16
+#define   NV40TCL_RT_VERT_H_MASK							0xffff0000
+#define   NV40TCL_RT_VERT_Y_SHIFT							0
+#define   NV40TCL_RT_VERT_Y_MASK							0x0000ffff
+#define  NV40TCL_RT_FORMAT								0x00000208
+#define   NV40TCL_RT_FORMAT_LOG2_HEIGHT_SHIFT						24
+#define   NV40TCL_RT_FORMAT_LOG2_HEIGHT_MASK						0xff000000
+#define   NV40TCL_RT_FORMAT_LOG2_WIDTH_SHIFT						16
+#define   NV40TCL_RT_FORMAT_LOG2_WIDTH_MASK						0x00ff0000
+#define   NV40TCL_RT_FORMAT_TYPE_SHIFT							8
+#define   NV40TCL_RT_FORMAT_TYPE_MASK							0x00000f00
+#define    NV40TCL_RT_FORMAT_TYPE_LINEAR						0x00000100
+#define    NV40TCL_RT_FORMAT_TYPE_SWIZZLED						0x00000200
+#define   NV40TCL_RT_FORMAT_ZETA_SHIFT							5
+#define   NV40TCL_RT_FORMAT_ZETA_MASK							0x000000e0
+#define    NV40TCL_RT_FORMAT_ZETA_Z16							0x00000020
+#define    NV40TCL_RT_FORMAT_ZETA_Z24S8							0x00000040
+#define   NV40TCL_RT_FORMAT_COLOR_SHIFT							0
+#define   NV40TCL_RT_FORMAT_COLOR_MASK							0x0000001f
+#define    NV40TCL_RT_FORMAT_COLOR_R5G6B5						0x00000003
+#define    NV40TCL_RT_FORMAT_COLOR_X8R8G8B8						0x00000005
+#define    NV40TCL_RT_FORMAT_COLOR_A8R8G8B8						0x00000008
+#define    NV40TCL_RT_FORMAT_COLOR_B8							0x00000009
+#define    NV40TCL_RT_FORMAT_COLOR_UNKNOWN						0x0000000d
+#define    NV40TCL_RT_FORMAT_COLOR_X8B8G8R8						0x0000000f
+#define    NV40TCL_RT_FORMAT_COLOR_A8B8G8R8						0x00000010
+#define  NV40TCL_COLOR0_PITCH								0x0000020c
+#define  NV40TCL_COLOR0_OFFSET								0x00000210
+#define  NV40TCL_ZETA_OFFSET								0x00000214
+#define  NV40TCL_COLOR1_OFFSET								0x00000218
+#define  NV40TCL_COLOR1_PITCH								0x0000021c
+#define  NV40TCL_RT_ENABLE								0x00000220
+#define   NV40TCL_RT_ENABLE_MRT								(1 <<  4)
+#define   NV40TCL_RT_ENABLE_COLOR3							(1 <<  3)
+#define   NV40TCL_RT_ENABLE_COLOR2							(1 <<  2)
+#define   NV40TCL_RT_ENABLE_COLOR1							(1 <<  1)
+#define   NV40TCL_RT_ENABLE_COLOR0							(1 <<  0)
+#define  NV40TCL_ZETA_PITCH								0x0000022c
+#define  NV40TCL_COLOR2_PITCH								0x00000280
+#define  NV40TCL_COLOR3_PITCH								0x00000284
+#define  NV40TCL_COLOR2_OFFSET								0x00000288
+#define  NV40TCL_COLOR3_OFFSET								0x0000028c
+#define  NV40TCL_VIEWPORT_CLIP_HORIZ(x)							(0x000002c0+((x)*8))
+#define  NV40TCL_VIEWPORT_CLIP_HORIZ__SIZE						0x00000008
+#define  NV40TCL_VIEWPORT_CLIP_VERT(x)							(0x000002c4+((x)*8))
+#define  NV40TCL_VIEWPORT_CLIP_VERT__SIZE						0x00000008
+#define  NV40TCL_DITHER_ENABLE								0x00000300
+#define  NV40TCL_ALPHA_TEST_ENABLE							0x00000304
+#define  NV40TCL_ALPHA_TEST_FUNC							0x00000308
+#define   NV40TCL_ALPHA_TEST_FUNC_NEVER							0x00000200
+#define   NV40TCL_ALPHA_TEST_FUNC_LESS							0x00000201
+#define   NV40TCL_ALPHA_TEST_FUNC_EQUAL							0x00000202
+#define   NV40TCL_ALPHA_TEST_FUNC_LEQUAL						0x00000203
+#define   NV40TCL_ALPHA_TEST_FUNC_GREATER						0x00000204
+#define   NV40TCL_ALPHA_TEST_FUNC_NOTEQUAL						0x00000205
+#define   NV40TCL_ALPHA_TEST_FUNC_GEQUAL						0x00000206
+#define   NV40TCL_ALPHA_TEST_FUNC_ALWAYS						0x00000207
+#define  NV40TCL_ALPHA_TEST_REF								0x0000030c
+#define  NV40TCL_BLEND_ENABLE								0x00000310
+#define  NV40TCL_BLEND_FUNC_SRC								0x00000314
+#define   NV40TCL_BLEND_FUNC_SRC_RGB_SHIFT						0
+#define   NV40TCL_BLEND_FUNC_SRC_RGB_MASK						0x0000ffff
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_ZERO						0x00000000
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_ONE						0x00000001
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_SRC_COLOR						0x00000300
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_SRC_COLOR				0x00000301
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_SRC_ALPHA						0x00000302
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_SRC_ALPHA				0x00000303
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_DST_ALPHA						0x00000304
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_DST_ALPHA				0x00000305
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_DST_COLOR						0x00000306
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_DST_COLOR				0x00000307
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_SRC_ALPHA_SATURATE				0x00000308
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_CONSTANT_COLOR					0x00008001
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_CONSTANT_ALPHA					0x00008003
+#define    NV40TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define   NV40TCL_BLEND_FUNC_SRC_ALPHA_SHIFT						16
+#define   NV40TCL_BLEND_FUNC_SRC_ALPHA_MASK						0xffff0000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_ZERO						0x00000000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_ONE						0x00010000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_SRC_COLOR					0x03000000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_SRC_COLOR				0x03010000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_SRC_ALPHA					0x03020000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_SRC_ALPHA				0x03030000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_DST_ALPHA					0x03040000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_DST_ALPHA				0x03050000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_DST_COLOR					0x03060000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_DST_COLOR				0x03070000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_SRC_ALPHA_SATURATE				0x03080000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_CONSTANT_COLOR					0x80010000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_CONSTANT_COLOR			0x80020000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_CONSTANT_ALPHA					0x80030000
+#define    NV40TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_CONSTANT_ALPHA			0x80040000
+#define  NV40TCL_BLEND_FUNC_DST								0x00000318
+#define   NV40TCL_BLEND_FUNC_DST_RGB_SHIFT						0
+#define   NV40TCL_BLEND_FUNC_DST_RGB_MASK						0x0000ffff
+#define    NV40TCL_BLEND_FUNC_DST_RGB_ZERO						0x00000000
+#define    NV40TCL_BLEND_FUNC_DST_RGB_ONE						0x00000001
+#define    NV40TCL_BLEND_FUNC_DST_RGB_SRC_COLOR						0x00000300
+#define    NV40TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_SRC_COLOR				0x00000301
+#define    NV40TCL_BLEND_FUNC_DST_RGB_SRC_ALPHA						0x00000302
+#define    NV40TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_SRC_ALPHA				0x00000303
+#define    NV40TCL_BLEND_FUNC_DST_RGB_DST_ALPHA						0x00000304
+#define    NV40TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_DST_ALPHA				0x00000305
+#define    NV40TCL_BLEND_FUNC_DST_RGB_DST_COLOR						0x00000306
+#define    NV40TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_DST_COLOR				0x00000307
+#define    NV40TCL_BLEND_FUNC_DST_RGB_SRC_ALPHA_SATURATE				0x00000308
+#define    NV40TCL_BLEND_FUNC_DST_RGB_CONSTANT_COLOR					0x00008001
+#define    NV40TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define    NV40TCL_BLEND_FUNC_DST_RGB_CONSTANT_ALPHA					0x00008003
+#define    NV40TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define   NV40TCL_BLEND_FUNC_DST_ALPHA_SHIFT						16
+#define   NV40TCL_BLEND_FUNC_DST_ALPHA_MASK						0xffff0000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_ZERO						0x00000000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_ONE						0x00010000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_SRC_COLOR					0x03000000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_SRC_COLOR				0x03010000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_SRC_ALPHA					0x03020000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_SRC_ALPHA				0x03030000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_DST_ALPHA					0x03040000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_DST_ALPHA				0x03050000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_DST_COLOR					0x03060000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_DST_COLOR				0x03070000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_SRC_ALPHA_SATURATE				0x03080000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_CONSTANT_COLOR					0x80010000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_CONSTANT_COLOR			0x80020000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_CONSTANT_ALPHA					0x80030000
+#define    NV40TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_CONSTANT_ALPHA			0x80040000
+#define  NV40TCL_BLEND_COLOR								0x0000031c
+#define   NV40TCL_BLEND_COLOR_B_SHIFT							0
+#define   NV40TCL_BLEND_COLOR_B_MASK							0x000000ff
+#define   NV40TCL_BLEND_COLOR_G_SHIFT							8
+#define   NV40TCL_BLEND_COLOR_G_MASK							0x0000ff00
+#define   NV40TCL_BLEND_COLOR_R_SHIFT							16
+#define   NV40TCL_BLEND_COLOR_R_MASK							0x00ff0000
+#define   NV40TCL_BLEND_COLOR_A_SHIFT							24
+#define   NV40TCL_BLEND_COLOR_A_MASK							0xff000000
+#define  NV40TCL_BLEND_EQUATION								0x00000320
+#define   NV40TCL_BLEND_EQUATION_RGB_SHIFT						0
+#define   NV40TCL_BLEND_EQUATION_RGB_MASK						0x0000ffff
+#define    NV40TCL_BLEND_EQUATION_RGB_FUNC_ADD						0x00008006
+#define    NV40TCL_BLEND_EQUATION_RGB_MIN						0x00008007
+#define    NV40TCL_BLEND_EQUATION_RGB_MAX						0x00008008
+#define    NV40TCL_BLEND_EQUATION_RGB_FUNC_SUBTRACT					0x0000800a
+#define    NV40TCL_BLEND_EQUATION_RGB_FUNC_REVERSE_SUBTRACT				0x0000800b
+#define   NV40TCL_BLEND_EQUATION_ALPHA_SHIFT						16
+#define   NV40TCL_BLEND_EQUATION_ALPHA_MASK						0xffff0000
+#define    NV40TCL_BLEND_EQUATION_ALPHA_FUNC_ADD					0x80060000
+#define    NV40TCL_BLEND_EQUATION_ALPHA_MIN						0x80070000
+#define    NV40TCL_BLEND_EQUATION_ALPHA_MAX						0x80080000
+#define    NV40TCL_BLEND_EQUATION_ALPHA_FUNC_SUBTRACT					0x800a0000
+#define    NV40TCL_BLEND_EQUATION_ALPHA_FUNC_REVERSE_SUBTRACT				0x800b0000
+#define  NV40TCL_COLOR_MASK								0x00000324
+#define   NV40TCL_COLOR_MASK_BUFFER0_B_SHIFT						0
+#define   NV40TCL_COLOR_MASK_BUFFER0_B_MASK						0x000000ff
+#define   NV40TCL_COLOR_MASK_BUFFER0_G_SHIFT						8
+#define   NV40TCL_COLOR_MASK_BUFFER0_G_MASK						0x0000ff00
+#define   NV40TCL_COLOR_MASK_BUFFER0_R_SHIFT						16
+#define   NV40TCL_COLOR_MASK_BUFFER0_R_MASK						0x00ff0000
+#define   NV40TCL_COLOR_MASK_BUFFER0_A_SHIFT						24
+#define   NV40TCL_COLOR_MASK_BUFFER0_A_MASK						0xff000000
+#define  NV40TCL_STENCIL_FRONT_ENABLE							0x00000328
+#define  NV40TCL_STENCIL_FRONT_MASK							0x0000032c
+#define  NV40TCL_STENCIL_FRONT_FUNC_FUNC						0x00000330
+#define   NV40TCL_STENCIL_FRONT_FUNC_FUNC_NEVER						0x00000200
+#define   NV40TCL_STENCIL_FRONT_FUNC_FUNC_LESS						0x00000201
+#define   NV40TCL_STENCIL_FRONT_FUNC_FUNC_EQUAL						0x00000202
+#define   NV40TCL_STENCIL_FRONT_FUNC_FUNC_LEQUAL					0x00000203
+#define   NV40TCL_STENCIL_FRONT_FUNC_FUNC_GREATER					0x00000204
+#define   NV40TCL_STENCIL_FRONT_FUNC_FUNC_NOTEQUAL					0x00000205
+#define   NV40TCL_STENCIL_FRONT_FUNC_FUNC_GEQUAL					0x00000206
+#define   NV40TCL_STENCIL_FRONT_FUNC_FUNC_ALWAYS					0x00000207
+#define  NV40TCL_STENCIL_FRONT_FUNC_REF							0x00000334
+#define  NV40TCL_STENCIL_FRONT_FUNC_MASK						0x00000338
+#define  NV40TCL_STENCIL_FRONT_OP_FAIL							0x0000033c
+#define   NV40TCL_STENCIL_FRONT_OP_FAIL_ZERO						0x00000000
+#define   NV40TCL_STENCIL_FRONT_OP_FAIL_INVERT						0x0000150a
+#define   NV40TCL_STENCIL_FRONT_OP_FAIL_KEEP						0x00001e00
+#define   NV40TCL_STENCIL_FRONT_OP_FAIL_REPLACE						0x00001e01
+#define   NV40TCL_STENCIL_FRONT_OP_FAIL_INCR						0x00001e02
+#define   NV40TCL_STENCIL_FRONT_OP_FAIL_DECR						0x00001e03
+#define   NV40TCL_STENCIL_FRONT_OP_FAIL_INCR_WRAP					0x00008507
+#define   NV40TCL_STENCIL_FRONT_OP_FAIL_DECR_WRAP					0x00008508
+#define  NV40TCL_STENCIL_FRONT_OP_ZFAIL							0x00000340
+#define   NV40TCL_STENCIL_FRONT_OP_ZFAIL_ZERO						0x00000000
+#define   NV40TCL_STENCIL_FRONT_OP_ZFAIL_INVERT						0x0000150a
+#define   NV40TCL_STENCIL_FRONT_OP_ZFAIL_KEEP						0x00001e00
+#define   NV40TCL_STENCIL_FRONT_OP_ZFAIL_REPLACE					0x00001e01
+#define   NV40TCL_STENCIL_FRONT_OP_ZFAIL_INCR						0x00001e02
+#define   NV40TCL_STENCIL_FRONT_OP_ZFAIL_DECR						0x00001e03
+#define   NV40TCL_STENCIL_FRONT_OP_ZFAIL_INCR_WRAP					0x00008507
+#define   NV40TCL_STENCIL_FRONT_OP_ZFAIL_DECR_WRAP					0x00008508
+#define  NV40TCL_STENCIL_FRONT_OP_ZPASS							0x00000344
+#define   NV40TCL_STENCIL_FRONT_OP_ZPASS_ZERO						0x00000000
+#define   NV40TCL_STENCIL_FRONT_OP_ZPASS_INVERT						0x0000150a
+#define   NV40TCL_STENCIL_FRONT_OP_ZPASS_KEEP						0x00001e00
+#define   NV40TCL_STENCIL_FRONT_OP_ZPASS_REPLACE					0x00001e01
+#define   NV40TCL_STENCIL_FRONT_OP_ZPASS_INCR						0x00001e02
+#define   NV40TCL_STENCIL_FRONT_OP_ZPASS_DECR						0x00001e03
+#define   NV40TCL_STENCIL_FRONT_OP_ZPASS_INCR_WRAP					0x00008507
+#define   NV40TCL_STENCIL_FRONT_OP_ZPASS_DECR_WRAP					0x00008508
+#define  NV40TCL_STENCIL_BACK_ENABLE							0x00000348
+#define  NV40TCL_STENCIL_BACK_MASK							0x0000034c
+#define  NV40TCL_STENCIL_BACK_FUNC_FUNC							0x00000350
+#define   NV40TCL_STENCIL_BACK_FUNC_FUNC_NEVER						0x00000200
+#define   NV40TCL_STENCIL_BACK_FUNC_FUNC_LESS						0x00000201
+#define   NV40TCL_STENCIL_BACK_FUNC_FUNC_EQUAL						0x00000202
+#define   NV40TCL_STENCIL_BACK_FUNC_FUNC_LEQUAL						0x00000203
+#define   NV40TCL_STENCIL_BACK_FUNC_FUNC_GREATER					0x00000204
+#define   NV40TCL_STENCIL_BACK_FUNC_FUNC_NOTEQUAL					0x00000205
+#define   NV40TCL_STENCIL_BACK_FUNC_FUNC_GEQUAL						0x00000206
+#define   NV40TCL_STENCIL_BACK_FUNC_FUNC_ALWAYS						0x00000207
+#define  NV40TCL_STENCIL_BACK_FUNC_REF							0x00000354
+#define  NV40TCL_STENCIL_BACK_FUNC_MASK							0x00000358
+#define  NV40TCL_STENCIL_BACK_OP_FAIL							0x0000035c
+#define   NV40TCL_STENCIL_BACK_OP_FAIL_ZERO						0x00000000
+#define   NV40TCL_STENCIL_BACK_OP_FAIL_INVERT						0x0000150a
+#define   NV40TCL_STENCIL_BACK_OP_FAIL_KEEP						0x00001e00
+#define   NV40TCL_STENCIL_BACK_OP_FAIL_REPLACE						0x00001e01
+#define   NV40TCL_STENCIL_BACK_OP_FAIL_INCR						0x00001e02
+#define   NV40TCL_STENCIL_BACK_OP_FAIL_DECR						0x00001e03
+#define   NV40TCL_STENCIL_BACK_OP_FAIL_INCR_WRAP					0x00008507
+#define   NV40TCL_STENCIL_BACK_OP_FAIL_DECR_WRAP					0x00008508
+#define  NV40TCL_STENCIL_BACK_OP_ZFAIL							0x00000360
+#define   NV40TCL_STENCIL_BACK_OP_ZFAIL_ZERO						0x00000000
+#define   NV40TCL_STENCIL_BACK_OP_ZFAIL_INVERT						0x0000150a
+#define   NV40TCL_STENCIL_BACK_OP_ZFAIL_KEEP						0x00001e00
+#define   NV40TCL_STENCIL_BACK_OP_ZFAIL_REPLACE						0x00001e01
+#define   NV40TCL_STENCIL_BACK_OP_ZFAIL_INCR						0x00001e02
+#define   NV40TCL_STENCIL_BACK_OP_ZFAIL_DECR						0x00001e03
+#define   NV40TCL_STENCIL_BACK_OP_ZFAIL_INCR_WRAP					0x00008507
+#define   NV40TCL_STENCIL_BACK_OP_ZFAIL_DECR_WRAP					0x00008508
+#define  NV40TCL_STENCIL_BACK_OP_ZPASS							0x00000364
+#define   NV40TCL_STENCIL_BACK_OP_ZPASS_ZERO						0x00000000
+#define   NV40TCL_STENCIL_BACK_OP_ZPASS_INVERT						0x0000150a
+#define   NV40TCL_STENCIL_BACK_OP_ZPASS_KEEP						0x00001e00
+#define   NV40TCL_STENCIL_BACK_OP_ZPASS_REPLACE						0x00001e01
+#define   NV40TCL_STENCIL_BACK_OP_ZPASS_INCR						0x00001e02
+#define   NV40TCL_STENCIL_BACK_OP_ZPASS_DECR						0x00001e03
+#define   NV40TCL_STENCIL_BACK_OP_ZPASS_INCR_WRAP					0x00008507
+#define   NV40TCL_STENCIL_BACK_OP_ZPASS_DECR_WRAP					0x00008508
+#define  NV40TCL_SHADE_MODEL								0x00000368
+#define   NV40TCL_SHADE_MODEL_FLAT							0x00001d00
+#define   NV40TCL_SHADE_MODEL_SMOOTH							0x00001d01
+#define  NV40TCL_MRT_COLOR_MASK								0x00000370
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER1_A						(1 <<  4)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER1_R						(1 <<  5)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER1_G						(1 <<  6)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER1_B						(1 <<  7)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER2_A						(1 <<  8)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER2_R						(1 <<  9)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER2_G						(1 << 10)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER2_B						(1 << 11)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER3_A						(1 << 12)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER3_R						(1 << 13)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER3_G						(1 << 14)
+#define   NV40TCL_MRT_COLOR_MASK_BUFFER3_B						(1 << 15)
+#define  NV40TCL_COLOR_LOGIC_OP_ENABLE							0x00000374
+#define  NV40TCL_COLOR_LOGIC_OP								0x00000378
+#define   NV40TCL_COLOR_LOGIC_OP_CLEAR							0x00001500
+#define   NV40TCL_COLOR_LOGIC_OP_AND							0x00001501
+#define   NV40TCL_COLOR_LOGIC_OP_AND_REVERSE						0x00001502
+#define   NV40TCL_COLOR_LOGIC_OP_COPY							0x00001503
+#define   NV40TCL_COLOR_LOGIC_OP_AND_INVERTED						0x00001504
+#define   NV40TCL_COLOR_LOGIC_OP_NOOP							0x00001505
+#define   NV40TCL_COLOR_LOGIC_OP_XOR							0x00001506
+#define   NV40TCL_COLOR_LOGIC_OP_OR							0x00001507
+#define   NV40TCL_COLOR_LOGIC_OP_NOR							0x00001508
+#define   NV40TCL_COLOR_LOGIC_OP_EQUIV							0x00001509
+#define   NV40TCL_COLOR_LOGIC_OP_INVERT							0x0000150a
+#define   NV40TCL_COLOR_LOGIC_OP_OR_REVERSE						0x0000150b
+#define   NV40TCL_COLOR_LOGIC_OP_COPY_INVERTED						0x0000150c
+#define   NV40TCL_COLOR_LOGIC_OP_OR_INVERTED						0x0000150d
+#define   NV40TCL_COLOR_LOGIC_OP_NAND							0x0000150e
+#define   NV40TCL_COLOR_LOGIC_OP_SET							0x0000150f
+#define  NV40TCL_DEPTH_RANGE_NEAR							0x00000394
+#define  NV40TCL_DEPTH_RANGE_FAR							0x00000398
+#define  NV40TCL_LINE_WIDTH								0x000003b8
+#define  NV40TCL_LINE_SMOOTH_ENABLE							0x000003bc
+#define  NV40TCL_UNK03C0(x)								(0x000003c0+((x)*4))
+#define  NV40TCL_UNK03C0__SIZE								0x00000010
+#define  NV40TCL_UNK0400(x)								(0x00000400+((x)*4))
+#define  NV40TCL_UNK0400__SIZE								0x00000010
+#define  NV40TCL_UNK0440(x)								(0x00000440+((x)*4))
+#define  NV40TCL_UNK0440__SIZE								0x00000020
+#define  NV40TCL_SCISSOR_HORIZ								0x000008c0
+#define   NV40TCL_SCISSOR_HORIZ_X_SHIFT							0
+#define   NV40TCL_SCISSOR_HORIZ_X_MASK							0x0000ffff
+#define   NV40TCL_SCISSOR_HORIZ_W_SHIFT							16
+#define   NV40TCL_SCISSOR_HORIZ_W_MASK							0xffff0000
+#define  NV40TCL_SCISSOR_VERT								0x000008c4
+#define   NV40TCL_SCISSOR_VERT_Y_SHIFT							0
+#define   NV40TCL_SCISSOR_VERT_Y_MASK							0x0000ffff
+#define   NV40TCL_SCISSOR_VERT_H_SHIFT							16
+#define   NV40TCL_SCISSOR_VERT_H_MASK							0xffff0000
+#define  NV40TCL_FOG_MODE								0x000008cc
+#define  NV40TCL_FOG_EQUATION_CONSTANT							0x000008d0
+#define  NV40TCL_FOG_EQUATION_LINEAR							0x000008d4
+#define  NV40TCL_FOG_EQUATION_QUADRATIC							0x000008d8
+#define  NV40TCL_FP_ADDRESS								0x000008e4
+#define   NV40TCL_FP_ADDRESS_OFFSET_SHIFT						8
+#define   NV40TCL_FP_ADDRESS_OFFSET_MASK						0xffffff00
+#define   NV40TCL_FP_ADDRESS_DMA1							(1 <<  1)
+#define   NV40TCL_FP_ADDRESS_DMA0							(1 <<  0)
+#define  NV40TCL_VIEWPORT_HORIZ								0x00000a00
+#define   NV40TCL_VIEWPORT_HORIZ_W_SHIFT						16
+#define   NV40TCL_VIEWPORT_HORIZ_W_MASK							0xffff0000
+#define   NV40TCL_VIEWPORT_HORIZ_X_SHIFT						0
+#define   NV40TCL_VIEWPORT_HORIZ_X_MASK							0x0000ffff
+#define  NV40TCL_VIEWPORT_VERT								0x00000a04
+#define   NV40TCL_VIEWPORT_VERT_H_SHIFT							16
+#define   NV40TCL_VIEWPORT_VERT_H_MASK							0xffff0000
+#define   NV40TCL_VIEWPORT_VERT_Y_SHIFT							0
+#define   NV40TCL_VIEWPORT_VERT_Y_MASK							0x0000ffff
+#define  NV40TCL_VIEWPORT_TRANSLATE_X							0x00000a20
+#define  NV40TCL_VIEWPORT_TRANSLATE_Y							0x00000a24
+#define  NV40TCL_VIEWPORT_TRANSLATE_Z							0x00000a28
+#define  NV40TCL_VIEWPORT_TRANSLATE_W							0x00000a2c
+#define  NV40TCL_VIEWPORT_SCALE_X							0x00000a30
+#define  NV40TCL_VIEWPORT_SCALE_Y							0x00000a34
+#define  NV40TCL_VIEWPORT_SCALE_Z							0x00000a38
+#define  NV40TCL_VIEWPORT_SCALE_W							0x00000a3c
+#define  NV40TCL_POLYGON_OFFSET_POINT_ENABLE						0x00000a60
+#define  NV40TCL_POLYGON_OFFSET_LINE_ENABLE						0x00000a64
+#define  NV40TCL_POLYGON_OFFSET_FILL_ENABLE						0x00000a68
+#define  NV40TCL_DEPTH_FUNC								0x00000a6c
+#define   NV40TCL_DEPTH_FUNC_NEVER							0x00000200
+#define   NV40TCL_DEPTH_FUNC_LESS							0x00000201
+#define   NV40TCL_DEPTH_FUNC_EQUAL							0x00000202
+#define   NV40TCL_DEPTH_FUNC_LEQUAL							0x00000203
+#define   NV40TCL_DEPTH_FUNC_GREATER							0x00000204
+#define   NV40TCL_DEPTH_FUNC_NOTEQUAL							0x00000205
+#define   NV40TCL_DEPTH_FUNC_GEQUAL							0x00000206
+#define   NV40TCL_DEPTH_FUNC_ALWAYS							0x00000207
+#define  NV40TCL_DEPTH_WRITE_ENABLE							0x00000a70
+#define  NV40TCL_DEPTH_TEST_ENABLE							0x00000a74
+#define  NV40TCL_POLYGON_OFFSET_FACTOR							0x00000a78
+#define  NV40TCL_POLYGON_OFFSET_UNITS							0x00000a7c
+#define  NV40TCL_VTX_ATTR_3I_XY(x)							(0x00000a80+((x)*8))
+#define  NV40TCL_VTX_ATTR_3I_XY__SIZE							0x00000010
+#define   NV40TCL_VTX_ATTR_3I_XY_X_SHIFT						0
+#define   NV40TCL_VTX_ATTR_3I_XY_X_MASK							0x0000ffff
+#define   NV40TCL_VTX_ATTR_3I_XY_Y_SHIFT						16
+#define   NV40TCL_VTX_ATTR_3I_XY_Y_MASK							0xffff0000
+#define  NV40TCL_VTX_ATTR_3I_Z(x)							(0x00000a84+((x)*8))
+#define  NV40TCL_VTX_ATTR_3I_Z__SIZE							0x00000010
+#define   NV40TCL_VTX_ATTR_3I_Z_Z_SHIFT							0
+#define   NV40TCL_VTX_ATTR_3I_Z_Z_MASK							0x0000ffff
+#define  NV40TCL_TEX_FILTER_OPTIMIZATION						0x00000b00
+#define   NV40TCL_TEX_FILTER_OPTIMIZATION_TRILINEAR_SHIFT				0
+#define   NV40TCL_TEX_FILTER_OPTIMIZATION_TRILINEAR_MASK				0x0000001f
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_TRILINEAR_OFF				0x00000000
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_TRILINEAR_HIGH_QUALITY			0x00000004
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_TRILINEAR_QUALITY				0x00000006
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_TRILINEAR_PERFORMANCE			0x00000008
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_TRILINEAR_HIGH_PERFORMANCE			0x00000018
+#define   NV40TCL_TEX_FILTER_OPTIMIZATION_ANISO_SAMPLE_SHIFT				6
+#define   NV40TCL_TEX_FILTER_OPTIMIZATION_ANISO_SAMPLE_MASK				0x000001c0
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_ANISO_SAMPLE_OFF				0x00000000
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_ANISO_SAMPLE_HIGH_QUALITY			0x000000c0
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_ANISO_SAMPLE_QUALITY				0x000001c0
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_ANISO_SAMPLE_PERFORMANCE			0x00000140
+#define   NV40TCL_TEX_FILTER_OPTIMIZATION_UNKNOWN_SHIFT					10
+#define   NV40TCL_TEX_FILTER_OPTIMIZATION_UNKNOWN_MASK					0x00007c00
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_UNKNOWN_OFF					0x00000000
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_UNKNOWN_PARTIAL				0x00002c00
+#define    NV40TCL_TEX_FILTER_OPTIMIZATION_UNKNOWN_FULL					0x00007c00
+#define  NV40TCL_UNK0B40(x)								(0x00000b40+((x)*4))
+#define  NV40TCL_UNK0B40__SIZE								0x00000008
+#define  NV40TCL_VP_UPLOAD_INST(x)							(0x00000b80+((x)*4))
+#define  NV40TCL_VP_UPLOAD_INST__SIZE							0x00000004
+#define  NV40TCL_VERTEX_TWO_SIDE_ENABLE							0x0000142c
+#define  NV40TCL_CLIP_PLANE_ENABLE							0x00001478
+#define   NV40TCL_CLIP_PLANE_ENABLE_PLANE0						(1 <<  1)
+#define   NV40TCL_CLIP_PLANE_ENABLE_PLANE1						(1 <<  5)
+#define   NV40TCL_CLIP_PLANE_ENABLE_PLANE2						(1 <<  9)
+#define   NV40TCL_CLIP_PLANE_ENABLE_PLANE3						(1 << 13)
+#define   NV40TCL_CLIP_PLANE_ENABLE_PLANE4						(1 << 17)
+#define   NV40TCL_CLIP_PLANE_ENABLE_PLANE5						(1 << 21)
+#define  NV40TCL_POLYGON_STIPPLE_ENABLE							0x0000147c
+#define  NV40TCL_POLYGON_STIPPLE_PATTERN(x)						(0x00001480+((x)*4))
+#define  NV40TCL_POLYGON_STIPPLE_PATTERN__SIZE						0x00000020
+#define  NV40TCL_VTX_ATTR_3F_X(x)							(0x00001500+((x)*16))
+#define  NV40TCL_VTX_ATTR_3F_X__SIZE							0x00000010
+#define  NV40TCL_VTX_ATTR_3F_Y(x)							(0x00001504+((x)*16))
+#define  NV40TCL_VTX_ATTR_3F_Y__SIZE							0x00000010
+#define  NV40TCL_VTX_ATTR_3F_Z(x)							(0x00001508+((x)*16))
+#define  NV40TCL_VTX_ATTR_3F_Z__SIZE							0x00000010
+#define  NV40TCL_VTXBUF_ADDRESS(x)							(0x00001680+((x)*4))
+#define  NV40TCL_VTXBUF_ADDRESS__SIZE							0x00000010
+#define   NV40TCL_VTXBUF_ADDRESS_DMA1							(1 << 31)
+#define   NV40TCL_VTXBUF_ADDRESS_OFFSET_SHIFT						0
+#define   NV40TCL_VTXBUF_ADDRESS_OFFSET_MASK						0x0fffffff
+#define  NV40TCL_VTX_CACHE_INVALIDATE							0x00001714
+#define  NV40TCL_VTXFMT(x)								(0x00001740+((x)*4))
+#define  NV40TCL_VTXFMT__SIZE								0x00000010
+#define   NV40TCL_VTXFMT_TYPE_SHIFT							0
+#define   NV40TCL_VTXFMT_TYPE_MASK							0x0000000f
+#define    NV40TCL_VTXFMT_TYPE_FLOAT							0x00000002
+#define    NV40TCL_VTXFMT_TYPE_UBYTE							0x00000004
+#define    NV40TCL_VTXFMT_TYPE_USHORT							0x00000005
+#define   NV40TCL_VTXFMT_SIZE_SHIFT							4
+#define   NV40TCL_VTXFMT_SIZE_MASK							0x000000f0
+#define   NV40TCL_VTXFMT_STRIDE_SHIFT							8
+#define   NV40TCL_VTXFMT_STRIDE_MASK							0x0000ff00
+#define  NV40TCL_QUERY_RESET								0x000017c8
+#define  NV40TCL_QUERY_UNK17CC								0x000017cc
+#define  NV40TCL_QUERY_GET								0x00001800
+#define   NV40TCL_QUERY_GET_UNK24_SHIFT							24
+#define   NV40TCL_QUERY_GET_UNK24_MASK							0xff000000
+#define   NV40TCL_QUERY_GET_OFFSET_SHIFT						0
+#define   NV40TCL_QUERY_GET_OFFSET_MASK							0x00ffffff
+#define  NV40TCL_BEGIN_END								0x00001808
+#define   NV40TCL_BEGIN_END_STOP							0x00000000
+#define   NV40TCL_BEGIN_END_POINTS							0x00000001
+#define   NV40TCL_BEGIN_END_LINES							0x00000002
+#define   NV40TCL_BEGIN_END_LINE_LOOP							0x00000003
+#define   NV40TCL_BEGIN_END_LINE_STRIP							0x00000004
+#define   NV40TCL_BEGIN_END_TRIANGLES							0x00000005
+#define   NV40TCL_BEGIN_END_TRIANGLE_STRIP						0x00000006
+#define   NV40TCL_BEGIN_END_TRIANGLE_FAN						0x00000007
+#define   NV40TCL_BEGIN_END_QUADS							0x00000008
+#define   NV40TCL_BEGIN_END_QUAD_STRIP							0x00000009
+#define   NV40TCL_BEGIN_END_POLYGON							0x0000000a
+#define  NV40TCL_VB_ELEMENT_U16								0x0000180c
+#define   NV40TCL_VB_ELEMENT_U16_1_SHIFT						16
+#define   NV40TCL_VB_ELEMENT_U16_1_MASK							0xffff0000
+#define   NV40TCL_VB_ELEMENT_U16_0_SHIFT						0
+#define   NV40TCL_VB_ELEMENT_U16_0_MASK							0x0000ffff
+#define  NV40TCL_VB_ELEMENT_U32								0x00001810
+#define  NV40TCL_VB_VERTEX_BATCH							0x00001814
+#define   NV40TCL_VB_VERTEX_BATCH_COUNT_SHIFT						24
+#define   NV40TCL_VB_VERTEX_BATCH_COUNT_MASK						0xff000000
+#define   NV40TCL_VB_VERTEX_BATCH_START_SHIFT						0
+#define   NV40TCL_VB_VERTEX_BATCH_START_MASK						0x00ffffff
+#define  NV40TCL_VERTEX_DATA								0x00001818
+#define  NV40TCL_IDXBUF_ADDRESS								0x0000181c
+#define  NV40TCL_IDXBUF_FORMAT								0x00001820
+#define   NV40TCL_IDXBUF_FORMAT_TYPE_SHIFT						4
+#define   NV40TCL_IDXBUF_FORMAT_TYPE_MASK						0x000000f0
+#define    NV40TCL_IDXBUF_FORMAT_TYPE_U32						0x00000000
+#define    NV40TCL_IDXBUF_FORMAT_TYPE_U16						0x00000010
+#define   NV40TCL_IDXBUF_FORMAT_DMA1							(1 <<  0)
+#define  NV40TCL_VB_INDEX_BATCH								0x00001824
+#define   NV40TCL_VB_INDEX_BATCH_COUNT_SHIFT						24
+#define   NV40TCL_VB_INDEX_BATCH_COUNT_MASK						0xff000000
+#define   NV40TCL_VB_INDEX_BATCH_START_SHIFT						0
+#define   NV40TCL_VB_INDEX_BATCH_START_MASK						0x00ffffff
+#define  NV40TCL_POLYGON_MODE_FRONT							0x00001828
+#define   NV40TCL_POLYGON_MODE_FRONT_POINT						0x00001b00
+#define   NV40TCL_POLYGON_MODE_FRONT_LINE						0x00001b01
+#define   NV40TCL_POLYGON_MODE_FRONT_FILL						0x00001b02
+#define  NV40TCL_POLYGON_MODE_BACK							0x0000182c
+#define   NV40TCL_POLYGON_MODE_BACK_POINT						0x00001b00
+#define   NV40TCL_POLYGON_MODE_BACK_LINE						0x00001b01
+#define   NV40TCL_POLYGON_MODE_BACK_FILL						0x00001b02
+#define  NV40TCL_CULL_FACE								0x00001830
+#define   NV40TCL_CULL_FACE_FRONT							0x00000404
+#define   NV40TCL_CULL_FACE_BACK							0x00000405
+#define   NV40TCL_CULL_FACE_FRONT_AND_BACK						0x00000408
+#define  NV40TCL_FRONT_FACE								0x00001834
+#define   NV40TCL_FRONT_FACE_CW								0x00000900
+#define   NV40TCL_FRONT_FACE_CCW							0x00000901
+#define  NV40TCL_POLYGON_SMOOTH_ENABLE							0x00001838
+#define  NV40TCL_CULL_FACE_ENABLE							0x0000183c
+#define  NV40TCL_TEX_SIZE1(x)								(0x00001840+((x)*4))
+#define  NV40TCL_TEX_SIZE1__SIZE							0x00000008
+#define   NV40TCL_TEX_SIZE1_DEPTH_SHIFT							20
+#define   NV40TCL_TEX_SIZE1_DEPTH_MASK							0xfff00000
+#define   NV40TCL_TEX_SIZE1_PITCH_SHIFT							0
+#define   NV40TCL_TEX_SIZE1_PITCH_MASK							0x0000ffff
+#define  NV40TCL_VTX_ATTR_2F_X(x)							(0x00001880+((x)*8))
+#define  NV40TCL_VTX_ATTR_2F_X__SIZE							0x00000010
+#define  NV40TCL_VTX_ATTR_2F_Y(x)							(0x00001884+((x)*8))
+#define  NV40TCL_VTX_ATTR_2F_Y__SIZE							0x00000010
+#define  NV40TCL_VTX_ATTR_2I(x)								(0x00001900+((x)*4))
+#define  NV40TCL_VTX_ATTR_2I__SIZE							0x00000010
+#define   NV40TCL_VTX_ATTR_2I_X_SHIFT							0
+#define   NV40TCL_VTX_ATTR_2I_X_MASK							0x0000ffff
+#define   NV40TCL_VTX_ATTR_2I_Y_SHIFT							16
+#define   NV40TCL_VTX_ATTR_2I_Y_MASK							0xffff0000
+#define  NV40TCL_VTX_ATTR_4UB(x)							(0x00001940+((x)*4))
+#define  NV40TCL_VTX_ATTR_4UB__SIZE							0x00000010
+#define   NV40TCL_VTX_ATTR_4UB_X_SHIFT							0
+#define   NV40TCL_VTX_ATTR_4UB_X_MASK							0x000000ff
+#define   NV40TCL_VTX_ATTR_4UB_Y_SHIFT							8
+#define   NV40TCL_VTX_ATTR_4UB_Y_MASK							0x0000ff00
+#define   NV40TCL_VTX_ATTR_4UB_Z_SHIFT							16
+#define   NV40TCL_VTX_ATTR_4UB_Z_MASK							0x00ff0000
+#define   NV40TCL_VTX_ATTR_4UB_W_SHIFT							24
+#define   NV40TCL_VTX_ATTR_4UB_W_MASK							0xff000000
+#define  NV40TCL_VTX_ATTR_4I_XY(x)							(0x00001980+((x)*8))
+#define  NV40TCL_VTX_ATTR_4I_XY__SIZE							0x00000010
+#define   NV40TCL_VTX_ATTR_4I_XY_X_SHIFT						0
+#define   NV40TCL_VTX_ATTR_4I_XY_X_MASK							0x0000ffff
+#define   NV40TCL_VTX_ATTR_4I_XY_Y_SHIFT						16
+#define   NV40TCL_VTX_ATTR_4I_XY_Y_MASK							0xffff0000
+#define  NV40TCL_VTX_ATTR_4I_ZW(x)							(0x00001984+((x)*8))
+#define  NV40TCL_VTX_ATTR_4I_ZW__SIZE							0x00000010
+#define   NV40TCL_VTX_ATTR_4I_ZW_Z_SHIFT						0
+#define   NV40TCL_VTX_ATTR_4I_ZW_Z_MASK							0x0000ffff
+#define   NV40TCL_VTX_ATTR_4I_ZW_W_SHIFT						16
+#define   NV40TCL_VTX_ATTR_4I_ZW_W_MASK							0xffff0000
+#define  NV40TCL_TEX_OFFSET(x)								(0x00001a00+((x)*32))
+#define  NV40TCL_TEX_OFFSET__SIZE							0x00000010
+#define  NV40TCL_TEX_FORMAT(x)								(0x00001a04+((x)*32))
+#define  NV40TCL_TEX_FORMAT__SIZE							0x00000010
+#define   NV40TCL_TEX_FORMAT_MIPMAP_COUNT_SHIFT						16
+#define   NV40TCL_TEX_FORMAT_MIPMAP_COUNT_MASK						0x000f0000
+#define   NV40TCL_TEX_FORMAT_RECT							(1 << 14)
+#define   NV40TCL_TEX_FORMAT_LINEAR							(1 << 13)
+#define   NV40TCL_TEX_FORMAT_FORMAT_SHIFT						8
+#define   NV40TCL_TEX_FORMAT_FORMAT_MASK						0x00001f00
+#define    NV40TCL_TEX_FORMAT_FORMAT_L8							0x00000100
+#define    NV40TCL_TEX_FORMAT_FORMAT_A1R5G5B5						0x00000200
+#define    NV40TCL_TEX_FORMAT_FORMAT_A4R4G4B4						0x00000300
+#define    NV40TCL_TEX_FORMAT_FORMAT_R5G6B5						0x00000400
+#define    NV40TCL_TEX_FORMAT_FORMAT_A8R8G8B8						0x00000500
+#define    NV40TCL_TEX_FORMAT_FORMAT_DXT1						0x00000600
+#define    NV40TCL_TEX_FORMAT_FORMAT_DXT3						0x00000700
+#define    NV40TCL_TEX_FORMAT_FORMAT_DXT5						0x00000800
+#define    NV40TCL_TEX_FORMAT_FORMAT_A8L8						0x00000b00
+#define    NV40TCL_TEX_FORMAT_FORMAT_Z24						0x00001000
+#define    NV40TCL_TEX_FORMAT_FORMAT_Z16						0x00001200
+#define    NV40TCL_TEX_FORMAT_FORMAT_A16						0x00001400
+#define    NV40TCL_TEX_FORMAT_FORMAT_A16L16						0x00001500
+#define    NV40TCL_TEX_FORMAT_FORMAT_HILO8						0x00001800
+#define    NV40TCL_TEX_FORMAT_FORMAT_RGBA16F						0x00001a00
+#define    NV40TCL_TEX_FORMAT_FORMAT_RGBA32F						0x00001b00
+#define   NV40TCL_TEX_FORMAT_DIMS_SHIFT							4
+#define   NV40TCL_TEX_FORMAT_DIMS_MASK							0x000000f0
+#define    NV40TCL_TEX_FORMAT_DIMS_1D							0x00000010
+#define    NV40TCL_TEX_FORMAT_DIMS_2D							0x00000020
+#define    NV40TCL_TEX_FORMAT_DIMS_3D							0x00000030
+#define   NV40TCL_TEX_FORMAT_NO_BORDER							(1 <<  3)
+#define   NV40TCL_TEX_FORMAT_CUBIC							(1 <<  2)
+#define   NV40TCL_TEX_FORMAT_DMA1							(1 <<  1)
+#define   NV40TCL_TEX_FORMAT_DMA0							(1 <<  0)
+#define  NV40TCL_TEX_WRAP(x)								(0x00001a08+((x)*32))
+#define  NV40TCL_TEX_WRAP__SIZE								0x00000010
+#define   NV40TCL_TEX_WRAP_S_SHIFT							0
+#define   NV40TCL_TEX_WRAP_S_MASK							0x0000000f
+#define    NV40TCL_TEX_WRAP_S_REPEAT							0x00000001
+#define    NV40TCL_TEX_WRAP_S_MIRRORED_REPEAT						0x00000002
+#define    NV40TCL_TEX_WRAP_S_CLAMP_TO_EDGE						0x00000003
+#define    NV40TCL_TEX_WRAP_S_CLAMP_TO_BORDER						0x00000004
+#define    NV40TCL_TEX_WRAP_S_CLAMP							0x00000005
+#define    NV40TCL_TEX_WRAP_S_MIRROR_CLAMP_TO_EDGE					0x00000006
+#define    NV40TCL_TEX_WRAP_S_MIRROR_CLAMP_TO_BORDER					0x00000007
+#define    NV40TCL_TEX_WRAP_S_MIRROR_CLAMP						0x00000008
+#define   NV40TCL_TEX_WRAP_ANISO_MIP_FILTER_OPTIMIZATION_SHIFT				4
+#define   NV40TCL_TEX_WRAP_ANISO_MIP_FILTER_OPTIMIZATION_MASK				0x00000070
+#define    NV40TCL_TEX_WRAP_ANISO_MIP_FILTER_OPTIMIZATION_OFF				0x00000000
+#define    NV40TCL_TEX_WRAP_ANISO_MIP_FILTER_OPTIMIZATION_QUALITY			0x00000020
+#define    NV40TCL_TEX_WRAP_ANISO_MIP_FILTER_OPTIMIZATION_PERFORMANCE			0x00000030
+#define    NV40TCL_TEX_WRAP_ANISO_MIP_FILTER_OPTIMIZATION_HIGH_PERFORMANCE		0x00000070
+#define   NV40TCL_TEX_WRAP_T_SHIFT							8
+#define   NV40TCL_TEX_WRAP_T_MASK							0x00000f00
+#define    NV40TCL_TEX_WRAP_T_REPEAT							0x00000100
+#define    NV40TCL_TEX_WRAP_T_MIRRORED_REPEAT						0x00000200
+#define    NV40TCL_TEX_WRAP_T_CLAMP_TO_EDGE						0x00000300
+#define    NV40TCL_TEX_WRAP_T_CLAMP_TO_BORDER						0x00000400
+#define    NV40TCL_TEX_WRAP_T_CLAMP							0x00000500
+#define    NV40TCL_TEX_WRAP_T_MIRROR_CLAMP_TO_EDGE					0x00000600
+#define    NV40TCL_TEX_WRAP_T_MIRROR_CLAMP_TO_BORDER					0x00000700
+#define    NV40TCL_TEX_WRAP_T_MIRROR_CLAMP						0x00000800
+#define   NV40TCL_TEX_WRAP_EXPAND_NORMAL_SHIFT						12
+#define   NV40TCL_TEX_WRAP_EXPAND_NORMAL_MASK						0x0000f000
+#define   NV40TCL_TEX_WRAP_R_SHIFT							16
+#define   NV40TCL_TEX_WRAP_R_MASK							0x000f0000
+#define    NV40TCL_TEX_WRAP_R_REPEAT							0x00010000
+#define    NV40TCL_TEX_WRAP_R_MIRRORED_REPEAT						0x00020000
+#define    NV40TCL_TEX_WRAP_R_CLAMP_TO_EDGE						0x00030000
+#define    NV40TCL_TEX_WRAP_R_CLAMP_TO_BORDER						0x00040000
+#define    NV40TCL_TEX_WRAP_R_CLAMP							0x00050000
+#define    NV40TCL_TEX_WRAP_R_MIRROR_CLAMP_TO_EDGE					0x00060000
+#define    NV40TCL_TEX_WRAP_R_MIRROR_CLAMP_TO_BORDER					0x00070000
+#define    NV40TCL_TEX_WRAP_R_MIRROR_CLAMP						0x00080000
+#define   NV40TCL_TEX_WRAP_GAMMA_DECREASE_FILTER_SHIFT					20
+#define   NV40TCL_TEX_WRAP_GAMMA_DECREASE_FILTER_MASK					0x00f00000
+#define    NV40TCL_TEX_WRAP_GAMMA_DECREASE_FILTER_NONE					0x00000000
+#define    NV40TCL_TEX_WRAP_GAMMA_DECREASE_FILTER_RED					0x00100000
+#define    NV40TCL_TEX_WRAP_GAMMA_DECREASE_FILTER_GREEN					0x00200000
+#define    NV40TCL_TEX_WRAP_GAMMA_DECREASE_FILTER_BLUE					0x00400000
+#define    NV40TCL_TEX_WRAP_GAMMA_DECREASE_FILTER_ALL					0x00f00000
+#define   NV40TCL_TEX_WRAP_RCOMP_SHIFT							28
+#define   NV40TCL_TEX_WRAP_RCOMP_MASK							0xf0000000
+#define    NV40TCL_TEX_WRAP_RCOMP_NEVER							0x00000000
+#define    NV40TCL_TEX_WRAP_RCOMP_GREATER						0x10000000
+#define    NV40TCL_TEX_WRAP_RCOMP_EQUAL							0x20000000
+#define    NV40TCL_TEX_WRAP_RCOMP_GEQUAL						0x30000000
+#define    NV40TCL_TEX_WRAP_RCOMP_LESS							0x40000000
+#define    NV40TCL_TEX_WRAP_RCOMP_NOTEQUAL						0x50000000
+#define    NV40TCL_TEX_WRAP_RCOMP_LEQUAL						0x60000000
+#define    NV40TCL_TEX_WRAP_RCOMP_ALWAYS						0x70000000
+#define  NV40TCL_TEX_ENABLE(x)								(0x00001a0c+((x)*32))
+#define  NV40TCL_TEX_ENABLE__SIZE							0x00000010
+#define   NV40TCL_TEX_ENABLE_ENABLE							(1 << 31)
+#define   NV40TCL_TEX_ENABLE_MIPMAP_MIN_LOD_SHIFT					27
+#define   NV40TCL_TEX_ENABLE_MIPMAP_MIN_LOD_MASK					0x38000000
+#define   NV40TCL_TEX_ENABLE_MIPMAP_MAX_LOD_SHIFT					15
+#define   NV40TCL_TEX_ENABLE_MIPMAP_MAX_LOD_MASK					0x00038000
+#define   NV40TCL_TEX_ENABLE_ANISO_SHIFT						4
+#define   NV40TCL_TEX_ENABLE_ANISO_MASK							0x000000f0
+#define    NV40TCL_TEX_ENABLE_ANISO_NONE						0x00000000
+#define    NV40TCL_TEX_ENABLE_ANISO_2X							0x00000010
+#define    NV40TCL_TEX_ENABLE_ANISO_4X							0x00000020
+#define    NV40TCL_TEX_ENABLE_ANISO_6X							0x00000030
+#define    NV40TCL_TEX_ENABLE_ANISO_8X							0x00000040
+#define    NV40TCL_TEX_ENABLE_ANISO_10X							0x00000050
+#define    NV40TCL_TEX_ENABLE_ANISO_12X							0x00000060
+#define    NV40TCL_TEX_ENABLE_ANISO_16X							0x00000070
+#define  NV40TCL_TEX_SWIZZLE(x)								(0x00001a10+((x)*32))
+#define  NV40TCL_TEX_SWIZZLE__SIZE							0x00000010
+#define   NV40TCL_TEX_SWIZZLE_S0_X_SHIFT						14
+#define   NV40TCL_TEX_SWIZZLE_S0_X_MASK							0x0000c000
+#define    NV40TCL_TEX_SWIZZLE_S0_X_ZERO						0x00000000
+#define    NV40TCL_TEX_SWIZZLE_S0_X_ONE							0x00004000
+#define    NV40TCL_TEX_SWIZZLE_S0_X_S1							0x00008000
+#define   NV40TCL_TEX_SWIZZLE_S0_Y_SHIFT						12
+#define   NV40TCL_TEX_SWIZZLE_S0_Y_MASK							0x00003000
+#define    NV40TCL_TEX_SWIZZLE_S0_Y_ZERO						0x00000000
+#define    NV40TCL_TEX_SWIZZLE_S0_Y_ONE							0x00001000
+#define    NV40TCL_TEX_SWIZZLE_S0_Y_S1							0x00002000
+#define   NV40TCL_TEX_SWIZZLE_S0_Z_SHIFT						10
+#define   NV40TCL_TEX_SWIZZLE_S0_Z_MASK							0x00000c00
+#define    NV40TCL_TEX_SWIZZLE_S0_Z_ZERO						0x00000000
+#define    NV40TCL_TEX_SWIZZLE_S0_Z_ONE							0x00000400
+#define    NV40TCL_TEX_SWIZZLE_S0_Z_S1							0x00000800
+#define   NV40TCL_TEX_SWIZZLE_S0_W_SHIFT						8
+#define   NV40TCL_TEX_SWIZZLE_S0_W_MASK							0x00000300
+#define    NV40TCL_TEX_SWIZZLE_S0_W_ZERO						0x00000000
+#define    NV40TCL_TEX_SWIZZLE_S0_W_ONE							0x00000100
+#define    NV40TCL_TEX_SWIZZLE_S0_W_S1							0x00000200
+#define   NV40TCL_TEX_SWIZZLE_S1_X_SHIFT						6
+#define   NV40TCL_TEX_SWIZZLE_S1_X_MASK							0x000000c0
+#define    NV40TCL_TEX_SWIZZLE_S1_X_W							0x00000000
+#define    NV40TCL_TEX_SWIZZLE_S1_X_Z							0x00000040
+#define    NV40TCL_TEX_SWIZZLE_S1_X_Y							0x00000080
+#define    NV40TCL_TEX_SWIZZLE_S1_X_X							0x000000c0
+#define   NV40TCL_TEX_SWIZZLE_S1_Y_SHIFT						4
+#define   NV40TCL_TEX_SWIZZLE_S1_Y_MASK							0x00000030
+#define    NV40TCL_TEX_SWIZZLE_S1_Y_W							0x00000000
+#define    NV40TCL_TEX_SWIZZLE_S1_Y_Z							0x00000010
+#define    NV40TCL_TEX_SWIZZLE_S1_Y_Y							0x00000020
+#define    NV40TCL_TEX_SWIZZLE_S1_Y_X							0x00000030
+#define   NV40TCL_TEX_SWIZZLE_S1_Z_SHIFT						2
+#define   NV40TCL_TEX_SWIZZLE_S1_Z_MASK							0x0000000c
+#define    NV40TCL_TEX_SWIZZLE_S1_Z_W							0x00000000
+#define    NV40TCL_TEX_SWIZZLE_S1_Z_Z							0x00000004
+#define    NV40TCL_TEX_SWIZZLE_S1_Z_Y							0x00000008
+#define    NV40TCL_TEX_SWIZZLE_S1_Z_X							0x0000000c
+#define   NV40TCL_TEX_SWIZZLE_S1_W_SHIFT						0
+#define   NV40TCL_TEX_SWIZZLE_S1_W_MASK							0x00000003
+#define    NV40TCL_TEX_SWIZZLE_S1_W_W							0x00000000
+#define    NV40TCL_TEX_SWIZZLE_S1_W_Z							0x00000001
+#define    NV40TCL_TEX_SWIZZLE_S1_W_Y							0x00000002
+#define    NV40TCL_TEX_SWIZZLE_S1_W_X							0x00000003
+#define  NV40TCL_TEX_FILTER(x)								(0x00001a14+((x)*32))
+#define  NV40TCL_TEX_FILTER__SIZE							0x00000010
+#define   NV40TCL_TEX_FILTER_SIGNED_ALPHA						(1 << 31)
+#define   NV40TCL_TEX_FILTER_SIGNED_RED							(1 << 30)
+#define   NV40TCL_TEX_FILTER_SIGNED_GREEN						(1 << 29)
+#define   NV40TCL_TEX_FILTER_SIGNED_BLUE						(1 << 28)
+#define   NV40TCL_TEX_FILTER_MIN_SHIFT							16
+#define   NV40TCL_TEX_FILTER_MIN_MASK							0x000f0000
+#define    NV40TCL_TEX_FILTER_MIN_NEAREST						0x00010000
+#define    NV40TCL_TEX_FILTER_MIN_LINEAR						0x00020000
+#define    NV40TCL_TEX_FILTER_MIN_NEAREST_MIPMAP_NEAREST				0x00030000
+#define    NV40TCL_TEX_FILTER_MIN_LINEAR_MIPMAP_NEAREST					0x00040000
+#define    NV40TCL_TEX_FILTER_MIN_NEAREST_MIPMAP_LINEAR					0x00050000
+#define    NV40TCL_TEX_FILTER_MIN_LINEAR_MIPMAP_LINEAR					0x00060000
+#define   NV40TCL_TEX_FILTER_MAG_SHIFT							24
+#define   NV40TCL_TEX_FILTER_MAG_MASK							0x0f000000
+#define    NV40TCL_TEX_FILTER_MAG_NEAREST						0x01000000
+#define    NV40TCL_TEX_FILTER_MAG_LINEAR						0x02000000
+#define  NV40TCL_TEX_SIZE0(x)								(0x00001a18+((x)*32))
+#define  NV40TCL_TEX_SIZE0__SIZE							0x00000010
+#define   NV40TCL_TEX_SIZE0_H_SHIFT							0
+#define   NV40TCL_TEX_SIZE0_H_MASK							0x0000ffff
+#define   NV40TCL_TEX_SIZE0_W_SHIFT							16
+#define   NV40TCL_TEX_SIZE0_W_MASK							0xffff0000
+#define  NV40TCL_TEX_BORDER_COLOR(x)							(0x00001a1c+((x)*32))
+#define  NV40TCL_TEX_BORDER_COLOR__SIZE							0x00000010
+#define   NV40TCL_TEX_BORDER_COLOR_B_SHIFT						0
+#define   NV40TCL_TEX_BORDER_COLOR_B_MASK						0x000000ff
+#define   NV40TCL_TEX_BORDER_COLOR_G_SHIFT						8
+#define   NV40TCL_TEX_BORDER_COLOR_G_MASK						0x0000ff00
+#define   NV40TCL_TEX_BORDER_COLOR_R_SHIFT						16
+#define   NV40TCL_TEX_BORDER_COLOR_R_MASK						0x00ff0000
+#define   NV40TCL_TEX_BORDER_COLOR_A_SHIFT						24
+#define   NV40TCL_TEX_BORDER_COLOR_A_MASK						0xff000000
+#define  NV40TCL_VTX_ATTR_4F_X(x)							(0x00001c00+((x)*16))
+#define  NV40TCL_VTX_ATTR_4F_X__SIZE							0x00000010
+#define  NV40TCL_VTX_ATTR_4F_Y(x)							(0x00001c04+((x)*16))
+#define  NV40TCL_VTX_ATTR_4F_Y__SIZE							0x00000010
+#define  NV40TCL_VTX_ATTR_4F_Z(x)							(0x00001c08+((x)*16))
+#define  NV40TCL_VTX_ATTR_4F_Z__SIZE							0x00000010
+#define  NV40TCL_VTX_ATTR_4F_W(x)							(0x00001c0c+((x)*16))
+#define  NV40TCL_VTX_ATTR_4F_W__SIZE							0x00000010
+#define  NV40TCL_FP_CONTROL								0x00001d60
+#define   NV40TCL_FP_CONTROL_TEMP_COUNT_SHIFT						24
+#define   NV40TCL_FP_CONTROL_TEMP_COUNT_MASK						0xff000000
+#define   NV40TCL_FP_CONTROL_KIL							(1 <<  7)
+#define  NV40TCL_MULTISAMPLE_CONTROL							0x00001d7c
+#define  NV40TCL_CLEAR_VALUE_DEPTH							0x00001d8c
+#define  NV40TCL_CLEAR_VALUE_COLOR							0x00001d90
+#define   NV40TCL_CLEAR_VALUE_COLOR_B_SHIFT						0
+#define   NV40TCL_CLEAR_VALUE_COLOR_B_MASK						0x000000ff
+#define   NV40TCL_CLEAR_VALUE_COLOR_G_SHIFT						8
+#define   NV40TCL_CLEAR_VALUE_COLOR_G_MASK						0x0000ff00
+#define   NV40TCL_CLEAR_VALUE_COLOR_R_SHIFT						16
+#define   NV40TCL_CLEAR_VALUE_COLOR_R_MASK						0x00ff0000
+#define   NV40TCL_CLEAR_VALUE_COLOR_A_SHIFT						24
+#define   NV40TCL_CLEAR_VALUE_COLOR_A_MASK						0xff000000
+#define  NV40TCL_CLEAR_BUFFERS								0x00001d94
+#define   NV40TCL_CLEAR_BUFFERS_COLOR_A							(1 <<  7)
+#define   NV40TCL_CLEAR_BUFFERS_COLOR_B							(1 <<  6)
+#define   NV40TCL_CLEAR_BUFFERS_COLOR_G							(1 <<  5)
+#define   NV40TCL_CLEAR_BUFFERS_COLOR_R							(1 <<  4)
+#define   NV40TCL_CLEAR_BUFFERS_STENCIL							(1 <<  1)
+#define   NV40TCL_CLEAR_BUFFERS_DEPTH							(1 <<  0)
+#define  NV40TCL_LINE_STIPPLE_ENABLE							0x00001db4
+#define  NV40TCL_LINE_STIPPLE_PATTERN							0x00001db8
+#define   NV40TCL_LINE_STIPPLE_PATTERN_FACTOR_SHIFT					0
+#define   NV40TCL_LINE_STIPPLE_PATTERN_FACTOR_MASK					0x0000ffff
+#define   NV40TCL_LINE_STIPPLE_PATTERN_PATTERN_SHIFT					16
+#define   NV40TCL_LINE_STIPPLE_PATTERN_PATTERN_MASK					0xffff0000
+#define  NV40TCL_VTX_ATTR_1F(x)								(0x00001e40+((x)*4))
+#define  NV40TCL_VTX_ATTR_1F__SIZE							0x00000010
+#define  NV40TCL_VP_UPLOAD_FROM_ID							0x00001e9c
+#define  NV40TCL_VP_START_FROM_ID							0x00001ea0
+#define  NV40TCL_POINT_SIZE								0x00001ee0
+#define  NV40TCL_POINT_SPRITE								0x00001ee8
+#define   NV40TCL_POINT_SPRITE_ENABLE							(1 <<  0)
+#define   NV40TCL_POINT_SPRITE_R_MODE_SHIFT						1
+#define   NV40TCL_POINT_SPRITE_R_MODE_MASK						0x00000006
+#define    NV40TCL_POINT_SPRITE_R_MODE_ZERO						0x00000000
+#define    NV40TCL_POINT_SPRITE_R_MODE_R						0x00000002
+#define    NV40TCL_POINT_SPRITE_R_MODE_S						0x00000004
+#define   NV40TCL_POINT_SPRITE_COORD_REPLACE_0						(1 <<  8)
+#define   NV40TCL_POINT_SPRITE_COORD_REPLACE_1						(1 <<  9)
+#define   NV40TCL_POINT_SPRITE_COORD_REPLACE_2						(1 << 10)
+#define   NV40TCL_POINT_SPRITE_COORD_REPLACE_3						(1 << 11)
+#define   NV40TCL_POINT_SPRITE_COORD_REPLACE_4						(1 << 12)
+#define   NV40TCL_POINT_SPRITE_COORD_REPLACE_5						(1 << 13)
+#define   NV40TCL_POINT_SPRITE_COORD_REPLACE_6						(1 << 14)
+#define   NV40TCL_POINT_SPRITE_COORD_REPLACE_7						(1 << 15)
+#define  NV40TCL_VP_UPLOAD_CONST_ID							0x00001efc
+#define  NV40TCL_VP_UPLOAD_CONST_X(x)							(0x00001f00+((x)*16))
+#define  NV40TCL_VP_UPLOAD_CONST_X__SIZE						0x00000004
+#define  NV40TCL_VP_UPLOAD_CONST_Y(x)							(0x00001f04+((x)*16))
+#define  NV40TCL_VP_UPLOAD_CONST_Y__SIZE						0x00000004
+#define  NV40TCL_VP_UPLOAD_CONST_Z(x)							(0x00001f08+((x)*16))
+#define  NV40TCL_VP_UPLOAD_CONST_Z__SIZE						0x00000004
+#define  NV40TCL_VP_UPLOAD_CONST_W(x)							(0x00001f0c+((x)*16))
+#define  NV40TCL_VP_UPLOAD_CONST_W__SIZE						0x00000004
+#define  NV40TCL_TEX_CACHE_CTL								0x00001fd8
+#define  NV40TCL_VP_ATTRIB_EN								0x00001ff0
+#define  NV40TCL_VP_RESULT_EN								0x00001ff4
+
+
+#define NV44TCL										0x00004497
+
+
+
+#define NV50_2D										0x0000502d
+
+#define  NV50_2D_NOP									0x00000100
+#define  NV50_2D_NOTIFY									0x00000104
+#define  NV50_2D_SERIALIZE								0x00000110
+#define  NV50_2D_DMA_NOTIFY								0x00000180
+#define  NV50_2D_DMA_DST								0x00000184
+#define  NV50_2D_DMA_SRC								0x00000188
+#define  NV50_2D_DMA_COND								0x0000018c
+#define  NV50_2D_DST_FORMAT								0x00000200
+#define   NV50_2D_DST_FORMAT_R32G32B32A32_FLOAT						0x000000c0
+#define   NV50_2D_DST_FORMAT_R32G32B32A32_SINT						0x000000c1
+#define   NV50_2D_DST_FORMAT_R32G32B32A32_UINT						0x000000c2
+#define   NV50_2D_DST_FORMAT_R32G32B32X32_FLOAT						0x000000c3
+#define   NV50_2D_DST_FORMAT_R16G16B16A16_UNORM						0x000000c6
+#define   NV50_2D_DST_FORMAT_R16G16B16A16_SNORM						0x000000c7
+#define   NV50_2D_DST_FORMAT_R16G16B16A16_SINT						0x000000c8
+#define   NV50_2D_DST_FORMAT_R16G16B16A16_UINT						0x000000c9
+#define   NV50_2D_DST_FORMAT_R16G16B16A16_FLOAT						0x000000ca
+#define   NV50_2D_DST_FORMAT_R32G32_FLOAT						0x000000cb
+#define   NV50_2D_DST_FORMAT_R32G32_SINT						0x000000cc
+#define   NV50_2D_DST_FORMAT_R32G32_UINT						0x000000cd
+#define   NV50_2D_DST_FORMAT_R16G16B16X16_FLOAT						0x000000ce
+#define   NV50_2D_DST_FORMAT_A8R8G8B8_UNORM						0x000000cf
+#define   NV50_2D_DST_FORMAT_A8R8G8B8_SRGB						0x000000d0
+#define   NV50_2D_DST_FORMAT_A2B10G10R10_UNORM						0x000000d1
+#define   NV50_2D_DST_FORMAT_A2B10G10R10_UINT						0x000000d2
+#define   NV50_2D_DST_FORMAT_A8B8G8R8_UNORM						0x000000d5
+#define   NV50_2D_DST_FORMAT_A8B8G8R8_SRGB						0x000000d6
+#define   NV50_2D_DST_FORMAT_A8B8G8R8_SNORM						0x000000d7
+#define   NV50_2D_DST_FORMAT_A8B8G8R8_SINT						0x000000d8
+#define   NV50_2D_DST_FORMAT_A8B8G8R8_UINT						0x000000d9
+#define   NV50_2D_DST_FORMAT_R16G16_UNORM						0x000000da
+#define   NV50_2D_DST_FORMAT_R16G16_SNORM						0x000000db
+#define   NV50_2D_DST_FORMAT_R16G16_SINT						0x000000dc
+#define   NV50_2D_DST_FORMAT_R16G16_UINT						0x000000dd
+#define   NV50_2D_DST_FORMAT_R16G16_FLOAT						0x000000de
+#define   NV50_2D_DST_FORMAT_A2R10G10B10_UNORM						0x000000df
+#define   NV50_2D_DST_FORMAT_B10G11R11_FLOAT						0x000000e0
+#define   NV50_2D_DST_FORMAT_R32_FLOAT							0x000000e5
+#define   NV50_2D_DST_FORMAT_X8R8G8B8_UNORM						0x000000e6
+#define   NV50_2D_DST_FORMAT_X8R8G8B8_SRGB						0x000000e7
+#define   NV50_2D_DST_FORMAT_R5G6B5_UNORM						0x000000e8
+#define   NV50_2D_DST_FORMAT_A1R5G5B5_UNORM						0x000000e9
+#define   NV50_2D_DST_FORMAT_R8G8_UNORM							0x000000ea
+#define   NV50_2D_DST_FORMAT_R8G8_SNORM							0x000000eb
+#define   NV50_2D_DST_FORMAT_R8G8_SINT							0x000000ec
+#define   NV50_2D_DST_FORMAT_R8G8_UINT							0x000000ed
+#define   NV50_2D_DST_FORMAT_R16_UNORM							0x000000ee
+#define   NV50_2D_DST_FORMAT_R16_SNORM							0x000000ef
+#define   NV50_2D_DST_FORMAT_R16_SINT							0x000000f0
+#define   NV50_2D_DST_FORMAT_R16_UINT							0x000000f1
+#define   NV50_2D_DST_FORMAT_R16_FLOAT							0x000000f2
+#define   NV50_2D_DST_FORMAT_R8_UNORM							0x000000f3
+#define   NV50_2D_DST_FORMAT_R8_SNORM							0x000000f4
+#define   NV50_2D_DST_FORMAT_R8_SINT							0x000000f5
+#define   NV50_2D_DST_FORMAT_R8_UINT							0x000000f6
+#define   NV50_2D_DST_FORMAT_A8_UNORM							0x000000f7
+#define   NV50_2D_DST_FORMAT_X1R5G5B5_UNORM						0x000000f8
+#define   NV50_2D_DST_FORMAT_X8B8G8R8_UNORM						0x000000f9
+#define   NV50_2D_DST_FORMAT_X8B8G8R8_SRGB						0x000000fa
+#define  NV50_2D_DST_LINEAR								0x00000204
+#define  NV50_2D_DST_TILE_MODE								0x00000208
+#define  NV50_2D_DST_DEPTH								0x0000020c
+#define  NV50_2D_DST_LAYER								0x00000210
+#define  NV50_2D_DST_PITCH								0x00000214
+#define  NV50_2D_DST_WIDTH								0x00000218
+#define  NV50_2D_DST_HEIGHT								0x0000021c
+#define  NV50_2D_DST_ADDRESS_HIGH							0x00000220
+#define  NV50_2D_DST_ADDRESS_LOW							0x00000224
+#define  NV50_2D_SRC_FORMAT								0x00000230
+#define   NV50_2D_SRC_FORMAT_R32G32B32A32_FLOAT						0x000000c0
+#define   NV50_2D_SRC_FORMAT_R32G32B32A32_SINT						0x000000c1
+#define   NV50_2D_SRC_FORMAT_R32G32B32A32_UINT						0x000000c2
+#define   NV50_2D_SRC_FORMAT_R32G32B32X32_FLOAT						0x000000c3
+#define   NV50_2D_SRC_FORMAT_R16G16B16A16_UNORM						0x000000c6
+#define   NV50_2D_SRC_FORMAT_R16G16B16A16_SNORM						0x000000c7
+#define   NV50_2D_SRC_FORMAT_R16G16B16A16_SINT						0x000000c8
+#define   NV50_2D_SRC_FORMAT_R16G16B16A16_UINT						0x000000c9
+#define   NV50_2D_SRC_FORMAT_R16G16B16A16_FLOAT						0x000000ca
+#define   NV50_2D_SRC_FORMAT_R32G32_FLOAT						0x000000cb
+#define   NV50_2D_SRC_FORMAT_R32G32_SINT						0x000000cc
+#define   NV50_2D_SRC_FORMAT_R32G32_UINT						0x000000cd
+#define   NV50_2D_SRC_FORMAT_R16G16B16X16_FLOAT						0x000000ce
+#define   NV50_2D_SRC_FORMAT_A8R8G8B8_UNORM						0x000000cf
+#define   NV50_2D_SRC_FORMAT_A8R8G8B8_SRGB						0x000000d0
+#define   NV50_2D_SRC_FORMAT_A2B10G10R10_UNORM						0x000000d1
+#define   NV50_2D_SRC_FORMAT_A2B10G10R10_UINT						0x000000d2
+#define   NV50_2D_SRC_FORMAT_A8B8G8R8_UNORM						0x000000d5
+#define   NV50_2D_SRC_FORMAT_A8B8G8R8_SRGB						0x000000d6
+#define   NV50_2D_SRC_FORMAT_A8B8G8R8_SNORM						0x000000d7
+#define   NV50_2D_SRC_FORMAT_A8B8G8R8_SINT						0x000000d8
+#define   NV50_2D_SRC_FORMAT_A8B8G8R8_UINT						0x000000d9
+#define   NV50_2D_SRC_FORMAT_R16G16_UNORM						0x000000da
+#define   NV50_2D_SRC_FORMAT_R16G16_SNORM						0x000000db
+#define   NV50_2D_SRC_FORMAT_R16G16_SINT						0x000000dc
+#define   NV50_2D_SRC_FORMAT_R16G16_UINT						0x000000dd
+#define   NV50_2D_SRC_FORMAT_R16G16_FLOAT						0x000000de
+#define   NV50_2D_SRC_FORMAT_A2R10G10B10_UNORM						0x000000df
+#define   NV50_2D_SRC_FORMAT_B10G11R11_FLOAT						0x000000e0
+#define   NV50_2D_SRC_FORMAT_R32_FLOAT							0x000000e5
+#define   NV50_2D_SRC_FORMAT_X8R8G8B8_UNORM						0x000000e6
+#define   NV50_2D_SRC_FORMAT_X8R8G8B8_SRGB						0x000000e7
+#define   NV50_2D_SRC_FORMAT_R5G6B5_UNORM						0x000000e8
+#define   NV50_2D_SRC_FORMAT_A1R5G5B5_UNORM						0x000000e9
+#define   NV50_2D_SRC_FORMAT_R8G8_UNORM							0x000000ea
+#define   NV50_2D_SRC_FORMAT_R8G8_SNORM							0x000000eb
+#define   NV50_2D_SRC_FORMAT_R8G8_SINT							0x000000ec
+#define   NV50_2D_SRC_FORMAT_R8G8_UINT							0x000000ed
+#define   NV50_2D_SRC_FORMAT_R16_UNORM							0x000000ee
+#define   NV50_2D_SRC_FORMAT_R16_SNORM							0x000000ef
+#define   NV50_2D_SRC_FORMAT_R16_SINT							0x000000f0
+#define   NV50_2D_SRC_FORMAT_R16_UINT							0x000000f1
+#define   NV50_2D_SRC_FORMAT_R16_FLOAT							0x000000f2
+#define   NV50_2D_SRC_FORMAT_R8_UNORM							0x000000f3
+#define   NV50_2D_SRC_FORMAT_R8_SNORM							0x000000f4
+#define   NV50_2D_SRC_FORMAT_R8_SINT							0x000000f5
+#define   NV50_2D_SRC_FORMAT_R8_UINT							0x000000f6
+#define   NV50_2D_SRC_FORMAT_A8_UNORM							0x000000f7
+#define   NV50_2D_SRC_FORMAT_X1R5G5B5_UNORM						0x000000f8
+#define   NV50_2D_SRC_FORMAT_X8B8G8R8_UNORM						0x000000f9
+#define   NV50_2D_SRC_FORMAT_X8B8G8R8_SRGB						0x000000fa
+#define  NV50_2D_SRC_LINEAR								0x00000234
+#define  NV50_2D_SRC_TILE_MODE								0x00000238
+#define  NV50_2D_SRC_DEPTH								0x0000023c
+#define  NV50_2D_SRC_LAYER								0x00000240
+#define  NV50_2D_SRC_PITCH								0x00000244
+#define  NV50_2D_SRC_WIDTH								0x00000248
+#define  NV50_2D_SRC_HEIGHT								0x0000024c
+#define  NV50_2D_SRC_ADDRESS_HIGH							0x00000250
+#define  NV50_2D_SRC_ADDRESS_LOW							0x00000254
+#define  NV50_2D_COND_ADDRESS_HIGH							0x00000264
+#define  NV50_2D_COND_ADDRESS_LOW							0x00000268
+#define  NV50_2D_COND_MODE								0x0000026c
+#define   NV50_2D_COND_MODE_NEVER							0x00000000
+#define   NV50_2D_COND_MODE_ALWAYS							0x00000001
+#define   NV50_2D_COND_MODE_RES								0x00000002
+#define   NV50_2D_COND_MODE_NOT_RES_AND_NOT_ID						0x00000003
+#define   NV50_2D_COND_MODE_RES_OR_ID							0x00000004
+#define  NV50_2D_CLIP_X									0x00000280
+#define  NV50_2D_CLIP_Y									0x00000284
+#define  NV50_2D_CLIP_W									0x00000288
+#define  NV50_2D_CLIP_H									0x0000028c
+#define  NV50_2D_CLIP_ENABLE								0x00000290
+#define  NV50_2D_COLOR_KEY_FORMAT							0x00000294
+#define   NV50_2D_COLOR_KEY_FORMAT_16BPP						0x00000000
+#define   NV50_2D_COLOR_KEY_FORMAT_15BPP						0x00000001
+#define   NV50_2D_COLOR_KEY_FORMAT_24BPP						0x00000002
+#define   NV50_2D_COLOR_KEY_FORMAT_30BPP						0x00000003
+#define   NV50_2D_COLOR_KEY_FORMAT_8BPP							0x00000004
+#define   NV50_2D_COLOR_KEY_FORMAT_16BPP2						0x00000005
+#define   NV50_2D_COLOR_KEY_FORMAT_32BPP						0x00000006
+#define  NV50_2D_COLOR_KEY								0x00000298
+#define  NV50_2D_COLOR_KEY_ENABLE							0x0000029c
+#define  NV50_2D_ROP									0x000002a0
+#define  NV50_2D_OPERATION								0x000002ac
+#define   NV50_2D_OPERATION_SRCCOPY_AND							0x00000000
+#define   NV50_2D_OPERATION_ROP_AND							0x00000001
+#define   NV50_2D_OPERATION_BLEND_AND							0x00000002
+#define   NV50_2D_OPERATION_SRCCOPY							0x00000003
+#define   NV50_2D_OPERATION_SRCCOPY_PREMULT						0x00000004
+#define   NV50_2D_OPERATION_BLEND_PREMULT						0x00000005
+#define  NV50_2D_PATTERN_FORMAT								0x000002e8
+#define   NV50_2D_PATTERN_FORMAT_16BPP							0x00000000
+#define   NV50_2D_PATTERN_FORMAT_15BPP							0x00000001
+#define   NV50_2D_PATTERN_FORMAT_32BPP							0x00000002
+#define   NV50_2D_PATTERN_FORMAT_8BPP							0x00000003
+#define  NV50_2D_PATTERN_COLOR(x)							(0x000002f0+((x)*4))
+#define  NV50_2D_PATTERN_COLOR__SIZE							0x00000002
+#define  NV50_2D_PATTERN_BITMAP(x)							(0x000002f8+((x)*4))
+#define  NV50_2D_PATTERN_BITMAP__SIZE							0x00000002
+#define  NV50_2D_DRAW_SHAPE								0x00000580
+#define   NV50_2D_DRAW_SHAPE_POINTS							0x00000000
+#define   NV50_2D_DRAW_SHAPE_LINES							0x00000001
+#define   NV50_2D_DRAW_SHAPE_LINE_STRIP							0x00000002
+#define   NV50_2D_DRAW_SHAPE_TRIANGLES							0x00000003
+#define   NV50_2D_DRAW_SHAPE_RECTANGLES							0x00000004
+#define  NV50_2D_DRAW_COLOR_FORMAT							0x00000584
+#define   NV50_2D_DRAW_COLOR_FORMAT_R32G32B32A32_FLOAT					0x000000c0
+#define   NV50_2D_DRAW_COLOR_FORMAT_R32G32B32A32_SINT					0x000000c1
+#define   NV50_2D_DRAW_COLOR_FORMAT_R32G32B32A32_UINT					0x000000c2
+#define   NV50_2D_DRAW_COLOR_FORMAT_R32G32B32X32_FLOAT					0x000000c3
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16B16A16_UNORM					0x000000c6
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16B16A16_SNORM					0x000000c7
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16B16A16_SINT					0x000000c8
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16B16A16_UINT					0x000000c9
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16B16A16_FLOAT					0x000000ca
+#define   NV50_2D_DRAW_COLOR_FORMAT_R32G32_FLOAT					0x000000cb
+#define   NV50_2D_DRAW_COLOR_FORMAT_R32G32_SINT						0x000000cc
+#define   NV50_2D_DRAW_COLOR_FORMAT_R32G32_UINT						0x000000cd
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16B16X16_FLOAT					0x000000ce
+#define   NV50_2D_DRAW_COLOR_FORMAT_A8R8G8B8_UNORM					0x000000cf
+#define   NV50_2D_DRAW_COLOR_FORMAT_A8R8G8B8_SRGB					0x000000d0
+#define   NV50_2D_DRAW_COLOR_FORMAT_A2B10G10R10_UNORM					0x000000d1
+#define   NV50_2D_DRAW_COLOR_FORMAT_A2B10G10R10_UINT					0x000000d2
+#define   NV50_2D_DRAW_COLOR_FORMAT_A8B8G8R8_UNORM					0x000000d5
+#define   NV50_2D_DRAW_COLOR_FORMAT_A8B8G8R8_SRGB					0x000000d6
+#define   NV50_2D_DRAW_COLOR_FORMAT_A8B8G8R8_SNORM					0x000000d7
+#define   NV50_2D_DRAW_COLOR_FORMAT_A8B8G8R8_SINT					0x000000d8
+#define   NV50_2D_DRAW_COLOR_FORMAT_A8B8G8R8_UINT					0x000000d9
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16_UNORM					0x000000da
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16_SNORM					0x000000db
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16_SINT						0x000000dc
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16_UINT						0x000000dd
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16G16_FLOAT					0x000000de
+#define   NV50_2D_DRAW_COLOR_FORMAT_A2R10G10B10_UNORM					0x000000df
+#define   NV50_2D_DRAW_COLOR_FORMAT_B10G11R11_FLOAT					0x000000e0
+#define   NV50_2D_DRAW_COLOR_FORMAT_R32_FLOAT						0x000000e5
+#define   NV50_2D_DRAW_COLOR_FORMAT_X8R8G8B8_UNORM					0x000000e6
+#define   NV50_2D_DRAW_COLOR_FORMAT_X8R8G8B8_SRGB					0x000000e7
+#define   NV50_2D_DRAW_COLOR_FORMAT_R5G6B5_UNORM					0x000000e8
+#define   NV50_2D_DRAW_COLOR_FORMAT_A1R5G5B5_UNORM					0x000000e9
+#define   NV50_2D_DRAW_COLOR_FORMAT_R8G8_UNORM						0x000000ea
+#define   NV50_2D_DRAW_COLOR_FORMAT_R8G8_SNORM						0x000000eb
+#define   NV50_2D_DRAW_COLOR_FORMAT_R8G8_SINT						0x000000ec
+#define   NV50_2D_DRAW_COLOR_FORMAT_R8G8_UINT						0x000000ed
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16_UNORM						0x000000ee
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16_SNORM						0x000000ef
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16_SINT						0x000000f0
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16_UINT						0x000000f1
+#define   NV50_2D_DRAW_COLOR_FORMAT_R16_FLOAT						0x000000f2
+#define   NV50_2D_DRAW_COLOR_FORMAT_R8_UNORM						0x000000f3
+#define   NV50_2D_DRAW_COLOR_FORMAT_R8_SNORM						0x000000f4
+#define   NV50_2D_DRAW_COLOR_FORMAT_R8_SINT						0x000000f5
+#define   NV50_2D_DRAW_COLOR_FORMAT_R8_UINT						0x000000f6
+#define   NV50_2D_DRAW_COLOR_FORMAT_A8_UNORM						0x000000f7
+#define   NV50_2D_DRAW_COLOR_FORMAT_X1R5G5B5_UNORM					0x000000f8
+#define   NV50_2D_DRAW_COLOR_FORMAT_X8B8G8R8_UNORM					0x000000f9
+#define   NV50_2D_DRAW_COLOR_FORMAT_X8B8G8R8_SRGB					0x000000fa
+#define  NV50_2D_DRAW_COLOR								0x00000588
+#define  NV50_2D_DRAW_POINT16								0x000005e0
+#define   NV50_2D_DRAW_POINT16_X_SHIFT							0
+#define   NV50_2D_DRAW_POINT16_X_MASK							0x0000ffff
+#define   NV50_2D_DRAW_POINT16_Y_SHIFT							16
+#define   NV50_2D_DRAW_POINT16_Y_MASK							0xffff0000
+#define  NV50_2D_DRAW_POINT32_X(x)							(0x00000600+((x)*8))
+#define  NV50_2D_DRAW_POINT32_X__SIZE							0x00000040
+#define  NV50_2D_DRAW_POINT32_Y(x)							(0x00000604+((x)*8))
+#define  NV50_2D_DRAW_POINT32_Y__SIZE							0x00000040
+#define  NV50_2D_SIFC_BITMAP_ENABLE							0x00000800
+#define  NV50_2D_SIFC_FORMAT								0x00000804
+#define   NV50_2D_SIFC_FORMAT_R32G32B32A32_FLOAT					0x000000c0
+#define   NV50_2D_SIFC_FORMAT_R32G32B32A32_SINT						0x000000c1
+#define   NV50_2D_SIFC_FORMAT_R32G32B32A32_UINT						0x000000c2
+#define   NV50_2D_SIFC_FORMAT_R32G32B32X32_FLOAT					0x000000c3
+#define   NV50_2D_SIFC_FORMAT_R16G16B16A16_UNORM					0x000000c6
+#define   NV50_2D_SIFC_FORMAT_R16G16B16A16_SNORM					0x000000c7
+#define   NV50_2D_SIFC_FORMAT_R16G16B16A16_SINT						0x000000c8
+#define   NV50_2D_SIFC_FORMAT_R16G16B16A16_UINT						0x000000c9
+#define   NV50_2D_SIFC_FORMAT_R16G16B16A16_FLOAT					0x000000ca
+#define   NV50_2D_SIFC_FORMAT_R32G32_FLOAT						0x000000cb
+#define   NV50_2D_SIFC_FORMAT_R32G32_SINT						0x000000cc
+#define   NV50_2D_SIFC_FORMAT_R32G32_UINT						0x000000cd
+#define   NV50_2D_SIFC_FORMAT_R16G16B16X16_FLOAT					0x000000ce
+#define   NV50_2D_SIFC_FORMAT_A8R8G8B8_UNORM						0x000000cf
+#define   NV50_2D_SIFC_FORMAT_A8R8G8B8_SRGB						0x000000d0
+#define   NV50_2D_SIFC_FORMAT_A2B10G10R10_UNORM						0x000000d1
+#define   NV50_2D_SIFC_FORMAT_A2B10G10R10_UINT						0x000000d2
+#define   NV50_2D_SIFC_FORMAT_A8B8G8R8_UNORM						0x000000d5
+#define   NV50_2D_SIFC_FORMAT_A8B8G8R8_SRGB						0x000000d6
+#define   NV50_2D_SIFC_FORMAT_A8B8G8R8_SNORM						0x000000d7
+#define   NV50_2D_SIFC_FORMAT_A8B8G8R8_SINT						0x000000d8
+#define   NV50_2D_SIFC_FORMAT_A8B8G8R8_UINT						0x000000d9
+#define   NV50_2D_SIFC_FORMAT_R16G16_UNORM						0x000000da
+#define   NV50_2D_SIFC_FORMAT_R16G16_SNORM						0x000000db
+#define   NV50_2D_SIFC_FORMAT_R16G16_SINT						0x000000dc
+#define   NV50_2D_SIFC_FORMAT_R16G16_UINT						0x000000dd
+#define   NV50_2D_SIFC_FORMAT_R16G16_FLOAT						0x000000de
+#define   NV50_2D_SIFC_FORMAT_A2R10G10B10_UNORM						0x000000df
+#define   NV50_2D_SIFC_FORMAT_B10G11R11_FLOAT						0x000000e0
+#define   NV50_2D_SIFC_FORMAT_R32_FLOAT							0x000000e5
+#define   NV50_2D_SIFC_FORMAT_X8R8G8B8_UNORM						0x000000e6
+#define   NV50_2D_SIFC_FORMAT_X8R8G8B8_SRGB						0x000000e7
+#define   NV50_2D_SIFC_FORMAT_R5G6B5_UNORM						0x000000e8
+#define   NV50_2D_SIFC_FORMAT_A1R5G5B5_UNORM						0x000000e9
+#define   NV50_2D_SIFC_FORMAT_R8G8_UNORM						0x000000ea
+#define   NV50_2D_SIFC_FORMAT_R8G8_SNORM						0x000000eb
+#define   NV50_2D_SIFC_FORMAT_R8G8_SINT							0x000000ec
+#define   NV50_2D_SIFC_FORMAT_R8G8_UINT							0x000000ed
+#define   NV50_2D_SIFC_FORMAT_R16_UNORM							0x000000ee
+#define   NV50_2D_SIFC_FORMAT_R16_SNORM							0x000000ef
+#define   NV50_2D_SIFC_FORMAT_R16_SINT							0x000000f0
+#define   NV50_2D_SIFC_FORMAT_R16_UINT							0x000000f1
+#define   NV50_2D_SIFC_FORMAT_R16_FLOAT							0x000000f2
+#define   NV50_2D_SIFC_FORMAT_R8_UNORM							0x000000f3
+#define   NV50_2D_SIFC_FORMAT_R8_SNORM							0x000000f4
+#define   NV50_2D_SIFC_FORMAT_R8_SINT							0x000000f5
+#define   NV50_2D_SIFC_FORMAT_R8_UINT							0x000000f6
+#define   NV50_2D_SIFC_FORMAT_A8_UNORM							0x000000f7
+#define   NV50_2D_SIFC_FORMAT_X1R5G5B5_UNORM						0x000000f8
+#define   NV50_2D_SIFC_FORMAT_X8B8G8R8_UNORM						0x000000f9
+#define   NV50_2D_SIFC_FORMAT_X8B8G8R8_SRGB						0x000000fa
+#define  NV50_2D_SIFC_BITMAP_UNK808							0x00000808
+#define  NV50_2D_SIFC_BITMAP_LSB_FIRST							0x0000080c
+#define  NV50_2D_SIFC_BITMAP_LINE_PACK_MODE						0x00000810
+#define   NV50_2D_SIFC_BITMAP_LINE_PACK_MODE_PACKED					0x00000000
+#define   NV50_2D_SIFC_BITMAP_LINE_PACK_MODE_ALIGN_BYTE					0x00000001
+#define   NV50_2D_SIFC_BITMAP_LINE_PACK_MODE_ALIGN_WORD					0x00000002
+#define  NV50_2D_SIFC_BITMAP_COLOR_BIT0							0x00000814
+#define  NV50_2D_SIFC_BITMAP_COLOR_BIT1							0x00000818
+#define  NV50_2D_SIFC_BITMAP_WRITE_BIT0_ENABLE						0x0000081c
+#define  NV50_2D_SIFC_WIDTH								0x00000838
+#define  NV50_2D_SIFC_HEIGHT								0x0000083c
+#define  NV50_2D_SIFC_DX_DU_FRACT							0x00000840
+#define  NV50_2D_SIFC_DX_DU_INT								0x00000844
+#define  NV50_2D_SIFC_DY_DV_FRACT							0x00000848
+#define  NV50_2D_SIFC_DY_DV_INT								0x0000084c
+#define  NV50_2D_SIFC_DST_X_FRACT							0x00000850
+#define  NV50_2D_SIFC_DST_X_INT								0x00000854
+#define  NV50_2D_SIFC_DST_Y_FRACT							0x00000858
+#define  NV50_2D_SIFC_DST_Y_INT								0x0000085c
+#define  NV50_2D_SIFC_DATA								0x00000860
+#define  NV50_2D_BLIT_DST_X								0x000008b0
+#define  NV50_2D_BLIT_DST_Y								0x000008b4
+#define  NV50_2D_BLIT_DST_W								0x000008b8
+#define  NV50_2D_BLIT_DST_H								0x000008bc
+#define  NV50_2D_BLIT_DU_DX_FRACT							0x000008c0
+#define  NV50_2D_BLIT_DU_DX_INT								0x000008c4
+#define  NV50_2D_BLIT_DV_DY_FRACT							0x000008c8
+#define  NV50_2D_BLIT_DV_DY_INT								0x000008cc
+#define  NV50_2D_BLIT_SRC_X_FRACT							0x000008d0
+#define  NV50_2D_BLIT_SRC_X_INT								0x000008d4
+#define  NV50_2D_BLIT_SRC_Y_FRACT							0x000008d8
+#define  NV50_2D_BLIT_SRC_Y_INT								0x000008dc
+
+
+#define NV50TCL										0x00005097
+
+#define  NV50TCL_NOP									0x00000100
+#define  NV50TCL_NOTIFY									0x00000104
+#define  NV50TCL_SERIALIZE								0x00000110
+#define  NV50TCL_DMA_NOTIFY								0x00000180
+#define  NV50TCL_DMA_ZETA								0x00000184
+#define  NV50TCL_DMA_QUERY								0x00000188
+#define  NV50TCL_DMA_VTXBUF0								0x0000018c
+#define  NV50TCL_DMA_LOCAL								0x00000190
+#define  NV50TCL_DMA_STACK								0x00000194
+#define  NV50TCL_DMA_CODE_CB								0x00000198
+#define  NV50TCL_DMA_TSC								0x0000019c
+#define  NV50TCL_DMA_TIC								0x000001a0
+#define  NV50TCL_DMA_TEXTURE								0x000001a4
+#define  NV50TCL_DMA_STRMOUT								0x000001a8
+#define  NV50TCL_DMA_UNK01AC								0x000001ac
+#define  NV50TCL_DMA_COLOR(x)								(0x000001c0+((x)*4))
+#define  NV50TCL_DMA_COLOR__SIZE							0x00000008
+#define  NV50TCL_RT_ADDRESS_HIGH(x)							(0x00000200+((x)*32))
+#define  NV50TCL_RT_ADDRESS_HIGH__SIZE							0x00000008
+#define  NV50TCL_RT_ADDRESS_LOW(x)							(0x00000204+((x)*32))
+#define  NV50TCL_RT_ADDRESS_LOW__SIZE							0x00000008
+#define  NV50TCL_RT_FORMAT(x)								(0x00000208+((x)*32))
+#define  NV50TCL_RT_FORMAT__SIZE							0x00000008
+#define   NV50TCL_RT_FORMAT_R32G32B32A32_FLOAT						0x000000c0
+#define   NV50TCL_RT_FORMAT_R32G32B32A32_SINT						0x000000c1
+#define   NV50TCL_RT_FORMAT_R32G32B32A32_UINT						0x000000c2
+#define   NV50TCL_RT_FORMAT_R32G32B32X32_FLOAT						0x000000c3
+#define   NV50TCL_RT_FORMAT_R16G16B16A16_UNORM						0x000000c6
+#define   NV50TCL_RT_FORMAT_R16G16B16A16_SNORM						0x000000c7
+#define   NV50TCL_RT_FORMAT_R16G16B16A16_SINT						0x000000c8
+#define   NV50TCL_RT_FORMAT_R16G16B16A16_UINT						0x000000c9
+#define   NV50TCL_RT_FORMAT_R16G16B16A16_FLOAT						0x000000ca
+#define   NV50TCL_RT_FORMAT_R32G32_FLOAT						0x000000cb
+#define   NV50TCL_RT_FORMAT_R32G32_SINT							0x000000cc
+#define   NV50TCL_RT_FORMAT_R32G32_UINT							0x000000cd
+#define   NV50TCL_RT_FORMAT_R16G16B16X16_FLOAT						0x000000ce
+#define   NV50TCL_RT_FORMAT_A8R8G8B8_UNORM						0x000000cf
+#define   NV50TCL_RT_FORMAT_A8R8G8B8_SRGB						0x000000d0
+#define   NV50TCL_RT_FORMAT_A2B10G10R10_UNORM						0x000000d1
+#define   NV50TCL_RT_FORMAT_A2B10G10R10_UINT						0x000000d2
+#define   NV50TCL_RT_FORMAT_A8B8G8R8_UNORM						0x000000d5
+#define   NV50TCL_RT_FORMAT_A8B8G8R8_SRGB						0x000000d6
+#define   NV50TCL_RT_FORMAT_A8B8G8R8_SNORM						0x000000d7
+#define   NV50TCL_RT_FORMAT_A8B8G8R8_SINT						0x000000d8
+#define   NV50TCL_RT_FORMAT_A8B8G8R8_UINT						0x000000d9
+#define   NV50TCL_RT_FORMAT_R16G16_UNORM						0x000000da
+#define   NV50TCL_RT_FORMAT_R16G16_SNORM						0x000000db
+#define   NV50TCL_RT_FORMAT_R16G16_SINT							0x000000dc
+#define   NV50TCL_RT_FORMAT_R16G16_UINT							0x000000dd
+#define   NV50TCL_RT_FORMAT_R16G16_FLOAT						0x000000de
+#define   NV50TCL_RT_FORMAT_A2R10G10B10_UNORM						0x000000df
+#define   NV50TCL_RT_FORMAT_B10G11R11_FLOAT						0x000000e0
+#define   NV50TCL_RT_FORMAT_R32_FLOAT							0x000000e5
+#define   NV50TCL_RT_FORMAT_X8R8G8B8_UNORM						0x000000e6
+#define   NV50TCL_RT_FORMAT_X8R8G8B8_SRGB						0x000000e7
+#define   NV50TCL_RT_FORMAT_R5G6B5_UNORM						0x000000e8
+#define   NV50TCL_RT_FORMAT_A1R5G5B5_UNORM						0x000000e9
+#define   NV50TCL_RT_FORMAT_R8G8_UNORM							0x000000ea
+#define   NV50TCL_RT_FORMAT_R8G8_SNORM							0x000000eb
+#define   NV50TCL_RT_FORMAT_R8G8_SINT							0x000000ec
+#define   NV50TCL_RT_FORMAT_R8G8_UINT							0x000000ed
+#define   NV50TCL_RT_FORMAT_R16_UNORM							0x000000ee
+#define   NV50TCL_RT_FORMAT_R16_SNORM							0x000000ef
+#define   NV50TCL_RT_FORMAT_R16_SINT							0x000000f0
+#define   NV50TCL_RT_FORMAT_R16_UINT							0x000000f1
+#define   NV50TCL_RT_FORMAT_R16_FLOAT							0x000000f2
+#define   NV50TCL_RT_FORMAT_R8_UNORM							0x000000f3
+#define   NV50TCL_RT_FORMAT_R8_SNORM							0x000000f4
+#define   NV50TCL_RT_FORMAT_R8_SINT							0x000000f5
+#define   NV50TCL_RT_FORMAT_R8_UINT							0x000000f6
+#define   NV50TCL_RT_FORMAT_A8_UNORM							0x000000f7
+#define   NV50TCL_RT_FORMAT_X1R5G5B5_UNORM						0x000000f8
+#define   NV50TCL_RT_FORMAT_X8B8G8R8_UNORM						0x000000f9
+#define   NV50TCL_RT_FORMAT_X8B8G8R8_SRGB						0x000000fa
+#define  NV50TCL_RT_TILE_MODE(x)							(0x0000020c+((x)*32))
+#define  NV50TCL_RT_TILE_MODE__SIZE							0x00000008
+#define  NV50TCL_RT_LAYER_STRIDE(x)							(0x00000210+((x)*32))
+#define  NV50TCL_RT_LAYER_STRIDE__SIZE							0x00000008
+#define  NV50TCL_VTX_ATTR_1F(x)								(0x00000300+((x)*4))
+#define  NV50TCL_VTX_ATTR_1F__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_2H(x)								(0x00000340+((x)*4))
+#define  NV50TCL_VTX_ATTR_2H__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_2H_X_SHIFT							0
+#define   NV50TCL_VTX_ATTR_2H_X_MASK							0x0000ffff
+#define   NV50TCL_VTX_ATTR_2H_Y_SHIFT							16
+#define   NV50TCL_VTX_ATTR_2H_Y_MASK							0xffff0000
+#define  NV50TCL_VTX_ATTR_2F_X(x)							(0x00000380+((x)*8))
+#define  NV50TCL_VTX_ATTR_2F_X__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_2F_Y(x)							(0x00000384+((x)*8))
+#define  NV50TCL_VTX_ATTR_2F_Y__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_3F_X(x)							(0x00000400+((x)*16))
+#define  NV50TCL_VTX_ATTR_3F_X__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_3F_Y(x)							(0x00000404+((x)*16))
+#define  NV50TCL_VTX_ATTR_3F_Y__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_3F_Z(x)							(0x00000408+((x)*16))
+#define  NV50TCL_VTX_ATTR_3F_Z__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_4F_X(x)							(0x00000500+((x)*16))
+#define  NV50TCL_VTX_ATTR_4F_X__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_4F_Y(x)							(0x00000504+((x)*16))
+#define  NV50TCL_VTX_ATTR_4F_Y__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_4F_Z(x)							(0x00000508+((x)*16))
+#define  NV50TCL_VTX_ATTR_4F_Z__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_4F_W(x)							(0x0000050c+((x)*16))
+#define  NV50TCL_VTX_ATTR_4F_W__SIZE							0x00000010
+#define  NV50TCL_VTX_ATTR_4H_0(x)							(0x00000600+((x)*8))
+#define  NV50TCL_VTX_ATTR_4H_0__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4H_0_X_SHIFT							0
+#define   NV50TCL_VTX_ATTR_4H_0_X_MASK							0x0000ffff
+#define   NV50TCL_VTX_ATTR_4H_0_Y_SHIFT							16
+#define   NV50TCL_VTX_ATTR_4H_0_Y_MASK							0xffff0000
+#define  NV50TCL_VTX_ATTR_4H_1(x)							(0x00000604+((x)*8))
+#define  NV50TCL_VTX_ATTR_4H_1__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4H_1_Z_SHIFT							0
+#define   NV50TCL_VTX_ATTR_4H_1_Z_MASK							0x0000ffff
+#define   NV50TCL_VTX_ATTR_4H_1_W_SHIFT							16
+#define   NV50TCL_VTX_ATTR_4H_1_W_MASK							0xffff0000
+#define  NV50TCL_VTX_ATTR_2I(x)								(0x00000680+((x)*4))
+#define  NV50TCL_VTX_ATTR_2I__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_2I_X_SHIFT							0
+#define   NV50TCL_VTX_ATTR_2I_X_MASK							0x0000ffff
+#define   NV50TCL_VTX_ATTR_2I_Y_SHIFT							16
+#define   NV50TCL_VTX_ATTR_2I_Y_MASK							0xffff0000
+#define  NV50TCL_VTX_ATTR_2NI(x)							(0x000006c0+((x)*4))
+#define  NV50TCL_VTX_ATTR_2NI__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_2NI_X_SHIFT							0
+#define   NV50TCL_VTX_ATTR_2NI_X_MASK							0x0000ffff
+#define   NV50TCL_VTX_ATTR_2NI_Y_SHIFT							16
+#define   NV50TCL_VTX_ATTR_2NI_Y_MASK							0xffff0000
+#define  NV50TCL_VTX_ATTR_4I_0(x)							(0x00000700+((x)*8))
+#define  NV50TCL_VTX_ATTR_4I_0__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4I_0_X_SHIFT							0
+#define   NV50TCL_VTX_ATTR_4I_0_X_MASK							0x0000ffff
+#define   NV50TCL_VTX_ATTR_4I_0_Y_SHIFT							16
+#define   NV50TCL_VTX_ATTR_4I_0_Y_MASK							0xffff0000
+#define  NV50TCL_VTX_ATTR_4I_1(x)							(0x00000704+((x)*8))
+#define  NV50TCL_VTX_ATTR_4I_1__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4I_1_Z_SHIFT							0
+#define   NV50TCL_VTX_ATTR_4I_1_Z_MASK							0x0000ffff
+#define   NV50TCL_VTX_ATTR_4I_1_W_SHIFT							16
+#define   NV50TCL_VTX_ATTR_4I_1_W_MASK							0xffff0000
+#define  NV50TCL_VTX_ATTR_4NI_0(x)							(0x00000780+((x)*8))
+#define  NV50TCL_VTX_ATTR_4NI_0__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4NI_0_X_SHIFT						0
+#define   NV50TCL_VTX_ATTR_4NI_0_X_MASK							0x0000ffff
+#define   NV50TCL_VTX_ATTR_4NI_0_Y_SHIFT						16
+#define   NV50TCL_VTX_ATTR_4NI_0_Y_MASK							0xffff0000
+#define  NV50TCL_VTX_ATTR_4NI_1(x)							(0x00000784+((x)*8))
+#define  NV50TCL_VTX_ATTR_4NI_1__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4NI_1_Z_SHIFT						0
+#define   NV50TCL_VTX_ATTR_4NI_1_Z_MASK							0x0000ffff
+#define   NV50TCL_VTX_ATTR_4NI_1_W_SHIFT						16
+#define   NV50TCL_VTX_ATTR_4NI_1_W_MASK							0xffff0000
+#define  NV50TCL_VTX_ATTR_4UB(x)							(0x00000800+((x)*4))
+#define  NV50TCL_VTX_ATTR_4UB__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4UB_X_SHIFT							0
+#define   NV50TCL_VTX_ATTR_4UB_X_MASK							0x000000ff
+#define   NV50TCL_VTX_ATTR_4UB_Y_SHIFT							8
+#define   NV50TCL_VTX_ATTR_4UB_Y_MASK							0x0000ff00
+#define   NV50TCL_VTX_ATTR_4UB_Z_SHIFT							16
+#define   NV50TCL_VTX_ATTR_4UB_Z_MASK							0x00ff0000
+#define   NV50TCL_VTX_ATTR_4UB_W_SHIFT							24
+#define   NV50TCL_VTX_ATTR_4UB_W_MASK							0xff000000
+#define  NV50TCL_VTX_ATTR_4B(x)								(0x00000840+((x)*4))
+#define  NV50TCL_VTX_ATTR_4B__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4B_X_SHIFT							0
+#define   NV50TCL_VTX_ATTR_4B_X_MASK							0x000000ff
+#define   NV50TCL_VTX_ATTR_4B_Y_SHIFT							8
+#define   NV50TCL_VTX_ATTR_4B_Y_MASK							0x0000ff00
+#define   NV50TCL_VTX_ATTR_4B_Z_SHIFT							16
+#define   NV50TCL_VTX_ATTR_4B_Z_MASK							0x00ff0000
+#define   NV50TCL_VTX_ATTR_4B_W_SHIFT							24
+#define   NV50TCL_VTX_ATTR_4B_W_MASK							0xff000000
+#define  NV50TCL_VTX_ATTR_4NUB(x)							(0x00000880+((x)*4))
+#define  NV50TCL_VTX_ATTR_4NUB__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4NUB_X_SHIFT							0
+#define   NV50TCL_VTX_ATTR_4NUB_X_MASK							0x000000ff
+#define   NV50TCL_VTX_ATTR_4NUB_Y_SHIFT							8
+#define   NV50TCL_VTX_ATTR_4NUB_Y_MASK							0x0000ff00
+#define   NV50TCL_VTX_ATTR_4NUB_Z_SHIFT							16
+#define   NV50TCL_VTX_ATTR_4NUB_Z_MASK							0x00ff0000
+#define   NV50TCL_VTX_ATTR_4NUB_W_SHIFT							24
+#define   NV50TCL_VTX_ATTR_4NUB_W_MASK							0xff000000
+#define  NV50TCL_VTX_ATTR_4NB(x)							(0x000008c0+((x)*4))
+#define  NV50TCL_VTX_ATTR_4NB__SIZE							0x00000010
+#define   NV50TCL_VTX_ATTR_4NB_X_SHIFT							0
+#define   NV50TCL_VTX_ATTR_4NB_X_MASK							0x000000ff
+#define   NV50TCL_VTX_ATTR_4NB_Y_SHIFT							8
+#define   NV50TCL_VTX_ATTR_4NB_Y_MASK							0x0000ff00
+#define   NV50TCL_VTX_ATTR_4NB_Z_SHIFT							16
+#define   NV50TCL_VTX_ATTR_4NB_Z_MASK							0x00ff0000
+#define   NV50TCL_VTX_ATTR_4NB_W_SHIFT							24
+#define   NV50TCL_VTX_ATTR_4NB_W_MASK							0xff000000
+#define  NV50TCL_VERTEX_ARRAY_FORMAT(x)							(0x00000900+((x)*16))
+#define  NV50TCL_VERTEX_ARRAY_FORMAT__SIZE						0x00000010
+#define   NV50TCL_VERTEX_ARRAY_FORMAT_STRIDE_SHIFT					0
+#define   NV50TCL_VERTEX_ARRAY_FORMAT_STRIDE_MASK					0x00000fff
+#define   NV50TCL_VERTEX_ARRAY_FORMAT_ENABLE						(1 << 29)
+#define  NV50TCL_VERTEX_ARRAY_START_HIGH(x)						(0x00000904+((x)*16))
+#define  NV50TCL_VERTEX_ARRAY_START_HIGH__SIZE						0x00000010
+#define  NV50TCL_VERTEX_ARRAY_START_LOW(x)						(0x00000908+((x)*16))
+#define  NV50TCL_VERTEX_ARRAY_START_LOW__SIZE						0x00000010
+#define  NV50TCL_VIEWPORT_SCALE_X(x)							(0x00000a00+((x)*32))
+#define  NV50TCL_VIEWPORT_SCALE_X__SIZE							0x00000010
+#define  NV50TCL_VIEWPORT_SCALE_Y(x)							(0x00000a04+((x)*32))
+#define  NV50TCL_VIEWPORT_SCALE_Y__SIZE							0x00000010
+#define  NV50TCL_VIEWPORT_SCALE_Z(x)							(0x00000a08+((x)*32))
+#define  NV50TCL_VIEWPORT_SCALE_Z__SIZE							0x00000010
+#define  NV50TCL_VIEWPORT_TRANSLATE_X(x)						(0x00000a0c+((x)*32))
+#define  NV50TCL_VIEWPORT_TRANSLATE_X__SIZE						0x00000010
+#define  NV50TCL_VIEWPORT_TRANSLATE_Y(x)						(0x00000a10+((x)*32))
+#define  NV50TCL_VIEWPORT_TRANSLATE_Y__SIZE						0x00000010
+#define  NV50TCL_VIEWPORT_TRANSLATE_Z(x)						(0x00000a14+((x)*32))
+#define  NV50TCL_VIEWPORT_TRANSLATE_Z__SIZE						0x00000010
+#define  NV50TCL_VIEWPORT_HORIZ(x)							(0x00000c00+((x)*16))
+#define  NV50TCL_VIEWPORT_HORIZ__SIZE							0x00000010
+#define   NV50TCL_VIEWPORT_HORIZ_X_SHIFT						0
+#define   NV50TCL_VIEWPORT_HORIZ_X_MASK							0x0000ffff
+#define   NV50TCL_VIEWPORT_HORIZ_W_SHIFT						16
+#define   NV50TCL_VIEWPORT_HORIZ_W_MASK							0xffff0000
+#define  NV50TCL_VIEWPORT_VERT(x)							(0x00000c04+((x)*16))
+#define  NV50TCL_VIEWPORT_VERT__SIZE							0x00000010
+#define   NV50TCL_VIEWPORT_VERT_Y_SHIFT							0
+#define   NV50TCL_VIEWPORT_VERT_Y_MASK							0x0000ffff
+#define   NV50TCL_VIEWPORT_VERT_H_SHIFT							16
+#define   NV50TCL_VIEWPORT_VERT_H_MASK							0xffff0000
+#define  NV50TCL_DEPTH_RANGE_NEAR(x)							(0x00000c08+((x)*16))
+#define  NV50TCL_DEPTH_RANGE_NEAR__SIZE							0x00000010
+#define  NV50TCL_DEPTH_RANGE_FAR(x)							(0x00000c0c+((x)*16))
+#define  NV50TCL_DEPTH_RANGE_FAR__SIZE							0x00000010
+#define  NV50TCL_VIEWPORT_CLIP_HORIZ(x)							(0x00000d00+((x)*8))
+#define  NV50TCL_VIEWPORT_CLIP_HORIZ__SIZE						0x00000008
+#define  NV50TCL_VIEWPORT_CLIP_VERT(x)							(0x00000d04+((x)*8))
+#define  NV50TCL_VIEWPORT_CLIP_VERT__SIZE						0x00000008
+#define  NV50TCL_VERTEX_BUFFER_FIRST							0x00000d74
+#define  NV50TCL_VERTEX_BUFFER_COUNT							0x00000d78
+#define  NV50TCL_CLEAR_COLOR(x)								(0x00000d80+((x)*4))
+#define  NV50TCL_CLEAR_COLOR__SIZE							0x00000004
+#define  NV50TCL_CLEAR_DEPTH								0x00000d90
+#define  NV50TCL_STACK_ADDRESS_HIGH							0x00000d94
+#define  NV50TCL_STACK_ADDRESS_LOW							0x00000d98
+#define  NV50TCL_STACK_SIZE_LOG								0x00000d9c
+#define  NV50TCL_CLEAR_STENCIL								0x00000da0
+#define  NV50TCL_STRMOUT_PRIMITIVE_COUNT						0x00000da8
+#define  NV50TCL_POLYGON_MODE_FRONT							0x00000dac
+#define   NV50TCL_POLYGON_MODE_FRONT_POINT						0x00001b00
+#define   NV50TCL_POLYGON_MODE_FRONT_LINE						0x00001b01
+#define   NV50TCL_POLYGON_MODE_FRONT_FILL						0x00001b02
+#define  NV50TCL_POLYGON_MODE_BACK							0x00000db0
+#define   NV50TCL_POLYGON_MODE_BACK_POINT						0x00001b00
+#define   NV50TCL_POLYGON_MODE_BACK_LINE						0x00001b01
+#define   NV50TCL_POLYGON_MODE_BACK_FILL						0x00001b02
+#define  NV50TCL_POLYGON_SMOOTH_ENABLE							0x00000db4
+#define  NV50TCL_POLYGON_OFFSET_POINT_ENABLE						0x00000dc0
+#define  NV50TCL_POLYGON_OFFSET_LINE_ENABLE						0x00000dc4
+#define  NV50TCL_POLYGON_OFFSET_FILL_ENABLE						0x00000dc8
+#define  NV50TCL_WATCHDOG_TIMER								0x00000de4
+#define  NV50TCL_WINDOW_OFFSET_X							0x00000df8
+#define  NV50TCL_WINDOW_OFFSET_Y							0x00000dfc
+#define  NV50TCL_SCISSOR_ENABLE(x)							(0x00000e00+((x)*16))
+#define  NV50TCL_SCISSOR_ENABLE__SIZE							0x00000010
+#define  NV50TCL_SCISSOR_HORIZ(x)							(0x00000e04+((x)*16))
+#define  NV50TCL_SCISSOR_HORIZ__SIZE							0x00000010
+#define   NV50TCL_SCISSOR_HORIZ_MIN_SHIFT						0
+#define   NV50TCL_SCISSOR_HORIZ_MIN_MASK						0x0000ffff
+#define   NV50TCL_SCISSOR_HORIZ_MAX_SHIFT						16
+#define   NV50TCL_SCISSOR_HORIZ_MAX_MASK						0xffff0000
+#define  NV50TCL_SCISSOR_VERT(x)							(0x00000e08+((x)*16))
+#define  NV50TCL_SCISSOR_VERT__SIZE							0x00000010
+#define   NV50TCL_SCISSOR_VERT_MIN_SHIFT						0
+#define   NV50TCL_SCISSOR_VERT_MIN_MASK							0x0000ffff
+#define   NV50TCL_SCISSOR_VERT_MAX_SHIFT						16
+#define   NV50TCL_SCISSOR_VERT_MAX_MASK							0xffff0000
+#define  NV50TCL_CB_ADDR								0x00000f00
+#define   NV50TCL_CB_ADDR_ID_SHIFT							8
+#define   NV50TCL_CB_ADDR_ID_MASK							0x003fff00
+#define   NV50TCL_CB_ADDR_BUFFER_SHIFT							0
+#define   NV50TCL_CB_ADDR_BUFFER_MASK							0x0000007f
+#define  NV50TCL_CB_DATA(x)								(0x00000f04+((x)*4))
+#define  NV50TCL_CB_DATA__SIZE								0x00000010
+#define  NV50TCL_LOCAL_WARPS_LOG_ALLOC							0x00000f44
+#define  NV50TCL_LOCAL_WARPS_NO_CLAMP							0x00000f48
+#define  NV50TCL_STACK_WARPS_LOG_ALLOC							0x00000f4c
+#define  NV50TCL_STACK_WARPS_NO_CLAMP							0x00000f50
+#define  NV50TCL_STENCIL_BACK_FUNC_REF							0x00000f54
+#define  NV50TCL_STENCIL_BACK_MASK							0x00000f58
+#define  NV50TCL_STENCIL_BACK_FUNC_MASK							0x00000f5c
+#define  NV50TCL_GP_ADDRESS_HIGH							0x00000f70
+#define  NV50TCL_GP_ADDRESS_LOW								0x00000f74
+#define  NV50TCL_VP_ADDRESS_HIGH							0x00000f7c
+#define  NV50TCL_VP_ADDRESS_LOW								0x00000f80
+#define  NV50TCL_UNK0F84_ADDRESS_HIGH							0x00000f84
+#define  NV50TCL_UNK0F84_ADDRESS_LOW							0x00000f88
+#define  NV50TCL_DEPTH_BOUNDS(x)							(0x00000f9c+((x)*4))
+#define  NV50TCL_DEPTH_BOUNDS__SIZE							0x00000002
+#define  NV50TCL_FP_ADDRESS_HIGH							0x00000fa4
+#define  NV50TCL_FP_ADDRESS_LOW								0x00000fa8
+#define  NV50TCL_MSAA_MASK(x)								(0x00000fbc+((x)*4))
+#define  NV50TCL_MSAA_MASK__SIZE							0x00000004
+#define  NV50TCL_ZETA_ADDRESS_HIGH							0x00000fe0
+#define  NV50TCL_ZETA_ADDRESS_LOW							0x00000fe4
+#define  NV50TCL_ZETA_FORMAT								0x00000fe8
+#define   NV50TCL_ZETA_FORMAT_Z32_FLOAT							0x0000000a
+#define   NV50TCL_ZETA_FORMAT_Z16_UNORM							0x00000013
+#define   NV50TCL_ZETA_FORMAT_Z24S8_UNORM						0x00000014
+#define   NV50TCL_ZETA_FORMAT_X8Z24_UNORM						0x00000015
+#define   NV50TCL_ZETA_FORMAT_S8Z24_UNORM						0x00000016
+#define   NV50TCL_ZETA_FORMAT_Z32_FLOAT_X24S8_UNORM					0x00000019
+#define  NV50TCL_ZETA_TILE_MODE								0x00000fec
+#define  NV50TCL_ZETA_LAYER_STRIDE							0x00000ff0
+#define  NV50TCL_SCREEN_SCISSOR_HORIZ							0x00000ff4
+#define   NV50TCL_SCREEN_SCISSOR_HORIZ_W_SHIFT						16
+#define   NV50TCL_SCREEN_SCISSOR_HORIZ_W_MASK						0xffff0000
+#define   NV50TCL_SCREEN_SCISSOR_HORIZ_X_SHIFT						0
+#define   NV50TCL_SCREEN_SCISSOR_HORIZ_X_MASK						0x0000ffff
+#define  NV50TCL_SCREEN_SCISSOR_VERT							0x00000ff8
+#define   NV50TCL_SCREEN_SCISSOR_VERT_H_SHIFT						16
+#define   NV50TCL_SCREEN_SCISSOR_VERT_H_MASK						0xffff0000
+#define   NV50TCL_SCREEN_SCISSOR_VERT_Y_SHIFT						0
+#define   NV50TCL_SCREEN_SCISSOR_VERT_Y_MASK						0x0000ffff
+#define  NV50TCL_VERTEX_ARRAY_LIMIT_HIGH(x)						(0x00001080+((x)*8))
+#define  NV50TCL_VERTEX_ARRAY_LIMIT_HIGH__SIZE						0x00000010
+#define  NV50TCL_VERTEX_ARRAY_LIMIT_LOW(x)						(0x00001084+((x)*8))
+#define  NV50TCL_VERTEX_ARRAY_LIMIT_LOW__SIZE						0x00000010
+#define  NV50TCL_RT_CONTROL								0x0000121c
+#define   NV50TCL_RT_CONTROL_COUNT_SHIFT						0
+#define   NV50TCL_RT_CONTROL_COUNT_MASK							0x0000000f
+#define   NV50TCL_RT_CONTROL_MAP0_SHIFT							4
+#define   NV50TCL_RT_CONTROL_MAP0_MASK							0x00000070
+#define   NV50TCL_RT_CONTROL_MAP1_SHIFT							7
+#define   NV50TCL_RT_CONTROL_MAP1_MASK							0x00000380
+#define   NV50TCL_RT_CONTROL_MAP2_SHIFT							10
+#define   NV50TCL_RT_CONTROL_MAP2_MASK							0x00001c00
+#define   NV50TCL_RT_CONTROL_MAP3_SHIFT							13
+#define   NV50TCL_RT_CONTROL_MAP3_MASK							0x0000e000
+#define   NV50TCL_RT_CONTROL_MAP4_SHIFT							16
+#define   NV50TCL_RT_CONTROL_MAP4_MASK							0x00070000
+#define   NV50TCL_RT_CONTROL_MAP5_SHIFT							19
+#define   NV50TCL_RT_CONTROL_MAP5_MASK							0x00380000
+#define   NV50TCL_RT_CONTROL_MAP6_SHIFT							22
+#define   NV50TCL_RT_CONTROL_MAP6_MASK							0x01c00000
+#define   NV50TCL_RT_CONTROL_MAP7_SHIFT							25
+#define   NV50TCL_RT_CONTROL_MAP7_MASK							0x0e000000
+#define  NV50TCL_RT_ARRAY_MODE								0x00001224
+#define   NV50TCL_RT_ARRAY_MODE_LAYERS_SHIFT						0
+#define   NV50TCL_RT_ARRAY_MODE_LAYERS_MASK						0x0000ffff
+#define   NV50TCL_RT_ARRAY_MODE_VOLUME							(1 << 16)
+#define  NV50TCL_ZETA_HORIZ								0x00001228
+#define  NV50TCL_ZETA_VERT								0x0000122c
+#define  NV50TCL_ZETA_ARRAY_MODE							0x00001230
+#define   NV50TCL_ZETA_ARRAY_MODE_LAYERS_SHIFT						0
+#define   NV50TCL_ZETA_ARRAY_MODE_LAYERS_MASK						0x0000ffff
+#define   NV50TCL_ZETA_ARRAY_MODE_UNK							(1 << 16)
+#define  NV50TCL_LINKED_TSC								0x00001234
+#define  NV50TCL_RT_HORIZ(x)								(0x00001240+((x)*8))
+#define  NV50TCL_RT_HORIZ__SIZE								0x00000008
+#define  NV50TCL_RT_VERT(x)								(0x00001244+((x)*8))
+#define  NV50TCL_RT_VERT__SIZE								0x00000008
+#define  NV50TCL_CB_DEF_ADDRESS_HIGH							0x00001280
+#define  NV50TCL_CB_DEF_ADDRESS_LOW							0x00001284
+#define  NV50TCL_CB_DEF_SET								0x00001288
+#define   NV50TCL_CB_DEF_SET_SIZE_SHIFT							0
+#define   NV50TCL_CB_DEF_SET_SIZE_MASK							0x0000ffff
+#define   NV50TCL_CB_DEF_SET_BUFFER_SHIFT						16
+#define   NV50TCL_CB_DEF_SET_BUFFER_MASK						0x007f0000
+#define  NV50TCL_STRMOUT_BUFFERS_CTRL							0x00001294
+#define   NV50TCL_STRMOUT_BUFFERS_CTRL_INTERLEAVED					(1 <<  0)
+#define   NV50TCL_STRMOUT_BUFFERS_CTRL_SEPARATE_SHIFT					4
+#define   NV50TCL_STRMOUT_BUFFERS_CTRL_SEPARATE_MASK					0x000000f0
+#define   NV50TCL_STRMOUT_BUFFERS_CTRL_STRIDE_SHIFT					8
+#define   NV50TCL_STRMOUT_BUFFERS_CTRL_STRIDE_MASK					0x0000ff00
+#define  NV50TCL_FP_RESULT_COUNT							0x00001298
+#define  NV50TCL_DEPTH_TEST_ENABLE							0x000012cc
+#define  NV50TCL_SHADE_MODEL								0x000012d4
+#define   NV50TCL_SHADE_MODEL_FLAT							0x00001d00
+#define   NV50TCL_SHADE_MODEL_SMOOTH							0x00001d01
+#define  NV50TCL_LOCAL_ADDRESS_HIGH							0x000012d8
+#define  NV50TCL_LOCAL_ADDRESS_LOW							0x000012dc
+#define  NV50TCL_LOCAL_SIZE_LOG								0x000012e0
+#define  NV50TCL_DEPTH_WRITE_ENABLE							0x000012e8
+#define  NV50TCL_ALPHA_TEST_ENABLE							0x000012ec
+#define  NV50TCL_PM_SET(x)								(0x000012f0+((x)*4))
+#define  NV50TCL_PM_SET__SIZE								0x00000004
+#define  NV50TCL_VB_ELEMENT_U8_SETUP							0x00001300
+#define   NV50TCL_VB_ELEMENT_U8_SETUP_OFFSET_SHIFT					30
+#define   NV50TCL_VB_ELEMENT_U8_SETUP_OFFSET_MASK					0xc0000000
+#define   NV50TCL_VB_ELEMENT_U8_SETUP_COUNT_SHIFT					0
+#define   NV50TCL_VB_ELEMENT_U8_SETUP_COUNT_MASK					0x3fffffff
+#define  NV50TCL_VB_ELEMENT_U8								0x00001304
+#define   NV50TCL_VB_ELEMENT_U8_I0_SHIFT						0
+#define   NV50TCL_VB_ELEMENT_U8_I0_MASK							0x000000ff
+#define   NV50TCL_VB_ELEMENT_U8_I1_SHIFT						8
+#define   NV50TCL_VB_ELEMENT_U8_I1_MASK							0x0000ff00
+#define   NV50TCL_VB_ELEMENT_U8_I2_SHIFT						16
+#define   NV50TCL_VB_ELEMENT_U8_I2_MASK							0x00ff0000
+#define   NV50TCL_VB_ELEMENT_U8_I3_SHIFT						24
+#define   NV50TCL_VB_ELEMENT_U8_I3_MASK							0xff000000
+#define  NV50TCL_DEPTH_TEST_FUNC							0x0000130c
+#define   NV50TCL_DEPTH_TEST_FUNC_NEVER							0x00000200
+#define   NV50TCL_DEPTH_TEST_FUNC_LESS							0x00000201
+#define   NV50TCL_DEPTH_TEST_FUNC_EQUAL							0x00000202
+#define   NV50TCL_DEPTH_TEST_FUNC_LEQUAL						0x00000203
+#define   NV50TCL_DEPTH_TEST_FUNC_GREATER						0x00000204
+#define   NV50TCL_DEPTH_TEST_FUNC_NOTEQUAL						0x00000205
+#define   NV50TCL_DEPTH_TEST_FUNC_GEQUAL						0x00000206
+#define   NV50TCL_DEPTH_TEST_FUNC_ALWAYS						0x00000207
+#define  NV50TCL_ALPHA_TEST_REF								0x00001310
+#define  NV50TCL_ALPHA_TEST_FUNC							0x00001314
+#define   NV50TCL_ALPHA_TEST_FUNC_NEVER							0x00000200
+#define   NV50TCL_ALPHA_TEST_FUNC_LESS							0x00000201
+#define   NV50TCL_ALPHA_TEST_FUNC_EQUAL							0x00000202
+#define   NV50TCL_ALPHA_TEST_FUNC_LEQUAL						0x00000203
+#define   NV50TCL_ALPHA_TEST_FUNC_GREATER						0x00000204
+#define   NV50TCL_ALPHA_TEST_FUNC_NOTEQUAL						0x00000205
+#define   NV50TCL_ALPHA_TEST_FUNC_GEQUAL						0x00000206
+#define   NV50TCL_ALPHA_TEST_FUNC_ALWAYS						0x00000207
+#define  NV50TCL_BLEND_COLOR(x)								(0x0000131c+((x)*4))
+#define  NV50TCL_BLEND_COLOR__SIZE							0x00000004
+#define  NV50TCL_TIC_FLUSH								0x00001330
+#define  NV50TCL_TSC_FLUSH								0x00001334
+#define  NV50TCL_TEX_CACHE_CTL								0x00001338
+#define  NV50TCL_BLEND_EQUATION_RGB							0x00001340
+#define   NV50TCL_BLEND_EQUATION_RGB_FUNC_ADD						0x00008006
+#define   NV50TCL_BLEND_EQUATION_RGB_MIN						0x00008007
+#define   NV50TCL_BLEND_EQUATION_RGB_MAX						0x00008008
+#define   NV50TCL_BLEND_EQUATION_RGB_FUNC_SUBTRACT					0x0000800a
+#define   NV50TCL_BLEND_EQUATION_RGB_FUNC_REVERSE_SUBTRACT				0x0000800b
+#define  NV50TCL_BLEND_FUNC_SRC_RGB							0x00001344
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_ZERO						0x00000000
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_ONE						0x00000001
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_SRC_COLOR						0x00000300
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_SRC_COLOR				0x00000301
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_SRC_ALPHA						0x00000302
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_SRC_ALPHA				0x00000303
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_DST_ALPHA						0x00000304
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_DST_ALPHA				0x00000305
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_DST_COLOR						0x00000306
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_DST_COLOR				0x00000307
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_SRC_ALPHA_SATURATE					0x00000308
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_CONSTANT_COLOR					0x00008001
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_CONSTANT_ALPHA					0x00008003
+#define   NV50TCL_BLEND_FUNC_SRC_RGB_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define  NV50TCL_BLEND_FUNC_DST_RGB							0x00001348
+#define   NV50TCL_BLEND_FUNC_DST_RGB_ZERO						0x00000000
+#define   NV50TCL_BLEND_FUNC_DST_RGB_ONE						0x00000001
+#define   NV50TCL_BLEND_FUNC_DST_RGB_SRC_COLOR						0x00000300
+#define   NV50TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_SRC_COLOR				0x00000301
+#define   NV50TCL_BLEND_FUNC_DST_RGB_SRC_ALPHA						0x00000302
+#define   NV50TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_SRC_ALPHA				0x00000303
+#define   NV50TCL_BLEND_FUNC_DST_RGB_DST_ALPHA						0x00000304
+#define   NV50TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_DST_ALPHA				0x00000305
+#define   NV50TCL_BLEND_FUNC_DST_RGB_DST_COLOR						0x00000306
+#define   NV50TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_DST_COLOR				0x00000307
+#define   NV50TCL_BLEND_FUNC_DST_RGB_SRC_ALPHA_SATURATE					0x00000308
+#define   NV50TCL_BLEND_FUNC_DST_RGB_CONSTANT_COLOR					0x00008001
+#define   NV50TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define   NV50TCL_BLEND_FUNC_DST_RGB_CONSTANT_ALPHA					0x00008003
+#define   NV50TCL_BLEND_FUNC_DST_RGB_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define  NV50TCL_BLEND_EQUATION_ALPHA							0x0000134c
+#define   NV50TCL_BLEND_EQUATION_ALPHA_FUNC_ADD						0x00008006
+#define   NV50TCL_BLEND_EQUATION_ALPHA_MIN						0x00008007
+#define   NV50TCL_BLEND_EQUATION_ALPHA_MAX						0x00008008
+#define   NV50TCL_BLEND_EQUATION_ALPHA_FUNC_SUBTRACT					0x0000800a
+#define   NV50TCL_BLEND_EQUATION_ALPHA_FUNC_REVERSE_SUBTRACT				0x0000800b
+#define  NV50TCL_BLEND_FUNC_SRC_ALPHA							0x00001350
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_ZERO						0x00000000
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_ONE						0x00000001
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_SRC_COLOR					0x00000300
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_SRC_COLOR				0x00000301
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_SRC_ALPHA					0x00000302
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_SRC_ALPHA				0x00000303
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_DST_ALPHA					0x00000304
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_DST_ALPHA				0x00000305
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_DST_COLOR					0x00000306
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_DST_COLOR				0x00000307
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_SRC_ALPHA_SATURATE				0x00000308
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_CONSTANT_COLOR					0x00008001
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_CONSTANT_ALPHA					0x00008003
+#define   NV50TCL_BLEND_FUNC_SRC_ALPHA_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define  NV50TCL_BLEND_FUNC_DST_ALPHA							0x00001358
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_ZERO						0x00000000
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_ONE						0x00000001
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_SRC_COLOR					0x00000300
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_SRC_COLOR				0x00000301
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_SRC_ALPHA					0x00000302
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_SRC_ALPHA				0x00000303
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_DST_ALPHA					0x00000304
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_DST_ALPHA				0x00000305
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_DST_COLOR					0x00000306
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_DST_COLOR				0x00000307
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_SRC_ALPHA_SATURATE				0x00000308
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_CONSTANT_COLOR					0x00008001
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_CONSTANT_COLOR				0x00008002
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_CONSTANT_ALPHA					0x00008003
+#define   NV50TCL_BLEND_FUNC_DST_ALPHA_ONE_MINUS_CONSTANT_ALPHA				0x00008004
+#define  NV50TCL_BLEND_ENABLE(x)							(0x00001360+((x)*4))
+#define  NV50TCL_BLEND_ENABLE__SIZE							0x00000008
+#define  NV50TCL_STENCIL_FRONT_ENABLE							0x00001380
+#define  NV50TCL_STENCIL_FRONT_OP_FAIL							0x00001384
+#define   NV50TCL_STENCIL_FRONT_OP_FAIL_ZERO						0x00000000
+#define   NV50TCL_STENCIL_FRONT_OP_FAIL_INVERT						0x0000150a
+#define   NV50TCL_STENCIL_FRONT_OP_FAIL_KEEP						0x00001e00
+#define   NV50TCL_STENCIL_FRONT_OP_FAIL_REPLACE						0x00001e01
+#define   NV50TCL_STENCIL_FRONT_OP_FAIL_INCR						0x00001e02
+#define   NV50TCL_STENCIL_FRONT_OP_FAIL_DECR						0x00001e03
+#define   NV50TCL_STENCIL_FRONT_OP_FAIL_INCR_WRAP					0x00008507
+#define   NV50TCL_STENCIL_FRONT_OP_FAIL_DECR_WRAP					0x00008508
+#define  NV50TCL_STENCIL_FRONT_OP_ZFAIL							0x00001388
+#define   NV50TCL_STENCIL_FRONT_OP_ZFAIL_ZERO						0x00000000
+#define   NV50TCL_STENCIL_FRONT_OP_ZFAIL_INVERT						0x0000150a
+#define   NV50TCL_STENCIL_FRONT_OP_ZFAIL_KEEP						0x00001e00
+#define   NV50TCL_STENCIL_FRONT_OP_ZFAIL_REPLACE					0x00001e01
+#define   NV50TCL_STENCIL_FRONT_OP_ZFAIL_INCR						0x00001e02
+#define   NV50TCL_STENCIL_FRONT_OP_ZFAIL_DECR						0x00001e03
+#define   NV50TCL_STENCIL_FRONT_OP_ZFAIL_INCR_WRAP					0x00008507
+#define   NV50TCL_STENCIL_FRONT_OP_ZFAIL_DECR_WRAP					0x00008508
+#define  NV50TCL_STENCIL_FRONT_OP_ZPASS							0x0000138c
+#define   NV50TCL_STENCIL_FRONT_OP_ZPASS_ZERO						0x00000000
+#define   NV50TCL_STENCIL_FRONT_OP_ZPASS_INVERT						0x0000150a
+#define   NV50TCL_STENCIL_FRONT_OP_ZPASS_KEEP						0x00001e00
+#define   NV50TCL_STENCIL_FRONT_OP_ZPASS_REPLACE					0x00001e01
+#define   NV50TCL_STENCIL_FRONT_OP_ZPASS_INCR						0x00001e02
+#define   NV50TCL_STENCIL_FRONT_OP_ZPASS_DECR						0x00001e03
+#define   NV50TCL_STENCIL_FRONT_OP_ZPASS_INCR_WRAP					0x00008507
+#define   NV50TCL_STENCIL_FRONT_OP_ZPASS_DECR_WRAP					0x00008508
+#define  NV50TCL_STENCIL_FRONT_FUNC_FUNC						0x00001390
+#define   NV50TCL_STENCIL_FRONT_FUNC_FUNC_NEVER						0x00000200
+#define   NV50TCL_STENCIL_FRONT_FUNC_FUNC_LESS						0x00000201
+#define   NV50TCL_STENCIL_FRONT_FUNC_FUNC_EQUAL						0x00000202
+#define   NV50TCL_STENCIL_FRONT_FUNC_FUNC_LEQUAL					0x00000203
+#define   NV50TCL_STENCIL_FRONT_FUNC_FUNC_GREATER					0x00000204
+#define   NV50TCL_STENCIL_FRONT_FUNC_FUNC_NOTEQUAL					0x00000205
+#define   NV50TCL_STENCIL_FRONT_FUNC_FUNC_GEQUAL					0x00000206
+#define   NV50TCL_STENCIL_FRONT_FUNC_FUNC_ALWAYS					0x00000207
+#define  NV50TCL_STENCIL_FRONT_FUNC_REF							0x00001394
+#define  NV50TCL_STENCIL_FRONT_MASK							0x00001398
+#define  NV50TCL_STENCIL_FRONT_FUNC_MASK						0x0000139c
+#define  NV50TCL_FRAG_COLOR_CLAMP_EN							0x000013a8
+#define  NV50TCL_Y_ORIGIN_BOTTOM							0x000013ac
+#define  NV50TCL_LINE_WIDTH								0x000013b0
+#define  NV50TCL_TEX_LIMITS(x)								(0x000013b4+((x)*4))
+#define  NV50TCL_TEX_LIMITS__SIZE							0x00000003
+#define   NV50TCL_TEX_LIMITS_SAMPLERS_LOG2_SHIFT					0
+#define   NV50TCL_TEX_LIMITS_SAMPLERS_LOG2_MASK						0x0000000f
+#define   NV50TCL_TEX_LIMITS_TEXTURES_LOG2_SHIFT					4
+#define   NV50TCL_TEX_LIMITS_TEXTURES_LOG2_MASK						0x000000f0
+#define  NV50TCL_POINT_COORD_REPLACE_MAP(x)						(0x000013c0+((x)*4))
+#define  NV50TCL_POINT_COORD_REPLACE_MAP__SIZE						0x00000008
+#define  NV50TCL_VP_START_ID								0x0000140c
+#define  NV50TCL_GP_START_ID								0x00001410
+#define  NV50TCL_FP_START_ID								0x00001414
+#define  NV50TCL_GP_VERTEX_OUTPUT_COUNT							0x00001420
+#define  NV50TCL_VB_ELEMENT_BASE							0x00001434
+#define  NV50TCL_CODE_CB_FLUSH								0x00001440
+#define  NV50TCL_BIND_TSC(x)								(0x00001444+((x)*8))
+#define  NV50TCL_BIND_TSC__SIZE								0x00000003
+#define   NV50TCL_BIND_TSC_VALID							(1 <<  0)
+#define   NV50TCL_BIND_TSC_SAMPLER_SHIFT						4
+#define   NV50TCL_BIND_TSC_SAMPLER_MASK							0x000000f0
+#define   NV50TCL_BIND_TSC_TSC_SHIFT							12
+#define   NV50TCL_BIND_TSC_TSC_MASK							0x001ff000
+#define  NV50TCL_BIND_TIC(x)								(0x00001448+((x)*8))
+#define  NV50TCL_BIND_TIC__SIZE								0x00000003
+#define   NV50TCL_BIND_TIC_VALID							(1 <<  0)
+#define   NV50TCL_BIND_TIC_TEXTURE_SHIFT						1
+#define   NV50TCL_BIND_TIC_TEXTURE_MASK							0x000001fe
+#define   NV50TCL_BIND_TIC_TIC_SHIFT							9
+#define   NV50TCL_BIND_TIC_TIC_MASK							0x7ffffe00
+#define  NV50TCL_STRMOUT_MAP(x)								(0x00001480+((x)*4))
+#define  NV50TCL_STRMOUT_MAP__SIZE							0x00000020
+#define  NV50TCL_VP_CLIP_DISTANCE_ENABLE						0x00001510
+#define   NV50TCL_VP_CLIP_DISTANCE_ENABLE_0						(1 <<  0)
+#define   NV50TCL_VP_CLIP_DISTANCE_ENABLE_1						(1 <<  1)
+#define   NV50TCL_VP_CLIP_DISTANCE_ENABLE_2						(1 <<  2)
+#define   NV50TCL_VP_CLIP_DISTANCE_ENABLE_3						(1 <<  3)
+#define   NV50TCL_VP_CLIP_DISTANCE_ENABLE_4						(1 <<  4)
+#define   NV50TCL_VP_CLIP_DISTANCE_ENABLE_5						(1 <<  5)
+#define   NV50TCL_VP_CLIP_DISTANCE_ENABLE_6						(1 <<  6)
+#define   NV50TCL_VP_CLIP_DISTANCE_ENABLE_7						(1 <<  7)
+#define  NV50TCL_SAMPLECNT_ENABLE							0x00001514
+#define  NV50TCL_POINT_SIZE								0x00001518
+#define  NV50TCL_POINT_SPRITE_ENABLE							0x00001520
+#define  NV50TCL_SAMPLECNT_RESET							0x00001530
+#define  NV50TCL_ZETA_ENABLE								0x00001538
+#define  NV50TCL_MULTISAMPLE_CTRL							0x0000153c
+#define   NV50TCL_MULTISAMPLE_CTRL_ALPHA_TO_COVERAGE					(1 <<  0)
+#define   NV50TCL_MULTISAMPLE_CTRL_ALPHA_TO_ONE						(1 <<  4)
+#define  NV50TCL_NOPERSPECTIVE_BITMAP(x)						(0x00001540+((x)*4))
+#define  NV50TCL_NOPERSPECTIVE_BITMAP__SIZE						0x00000004
+#define  NV50TCL_COND_ADDRESS_HIGH							0x00001550
+#define  NV50TCL_COND_ADDRESS_LOW							0x00001554
+#define  NV50TCL_COND_MODE								0x00001558
+#define   NV50TCL_COND_MODE_NEVER							0x00000000
+#define   NV50TCL_COND_MODE_ALWAYS							0x00000001
+#define   NV50TCL_COND_MODE_RES								0x00000002
+#define   NV50TCL_COND_MODE_NOT_RES_AND_NOT_ID						0x00000003
+#define   NV50TCL_COND_MODE_RES_OR_ID							0x00000004
+#define  NV50TCL_TSC_ADDRESS_HIGH							0x0000155c
+#define  NV50TCL_TSC_ADDRESS_LOW							0x00001560
+#define  NV50TCL_TSC_LIMIT								0x00001564
+#define  NV50TCL_POLYGON_OFFSET_FACTOR							0x0000156c
+#define  NV50TCL_LINE_SMOOTH_ENABLE							0x00001570
+#define  NV50TCL_TIC_ADDRESS_HIGH							0x00001574
+#define  NV50TCL_TIC_ADDRESS_LOW							0x00001578
+#define  NV50TCL_TIC_LIMIT								0x0000157c
+#define  NV50TCL_PM_CONTROL(x)								(0x00001580+((x)*4))
+#define  NV50TCL_PM_CONTROL__SIZE							0x00000004
+#define   NV50TCL_PM_CONTROL_UNK0							(1 <<  0)
+#define   NV50TCL_PM_CONTROL_UNK1_SHIFT							4
+#define   NV50TCL_PM_CONTROL_UNK1_MASK							0x00000070
+#define   NV50TCL_PM_CONTROL_UNK2_SHIFT							8
+#define   NV50TCL_PM_CONTROL_UNK2_MASK							0xffffff00
+#define  NV50TCL_STENCIL_BACK_ENABLE							0x00001594
+#define  NV50TCL_STENCIL_BACK_OP_FAIL							0x00001598
+#define   NV50TCL_STENCIL_BACK_OP_FAIL_ZERO						0x00000000
+#define   NV50TCL_STENCIL_BACK_OP_FAIL_INVERT						0x0000150a
+#define   NV50TCL_STENCIL_BACK_OP_FAIL_KEEP						0x00001e00
+#define   NV50TCL_STENCIL_BACK_OP_FAIL_REPLACE						0x00001e01
+#define   NV50TCL_STENCIL_BACK_OP_FAIL_INCR						0x00001e02
+#define   NV50TCL_STENCIL_BACK_OP_FAIL_DECR						0x00001e03
+#define   NV50TCL_STENCIL_BACK_OP_FAIL_INCR_WRAP					0x00008507
+#define   NV50TCL_STENCIL_BACK_OP_FAIL_DECR_WRAP					0x00008508
+#define  NV50TCL_STENCIL_BACK_OP_ZFAIL							0x0000159c
+#define   NV50TCL_STENCIL_BACK_OP_ZFAIL_ZERO						0x00000000
+#define   NV50TCL_STENCIL_BACK_OP_ZFAIL_INVERT						0x0000150a
+#define   NV50TCL_STENCIL_BACK_OP_ZFAIL_KEEP						0x00001e00
+#define   NV50TCL_STENCIL_BACK_OP_ZFAIL_REPLACE						0x00001e01
+#define   NV50TCL_STENCIL_BACK_OP_ZFAIL_INCR						0x00001e02
+#define   NV50TCL_STENCIL_BACK_OP_ZFAIL_DECR						0x00001e03
+#define   NV50TCL_STENCIL_BACK_OP_ZFAIL_INCR_WRAP					0x00008507
+#define   NV50TCL_STENCIL_BACK_OP_ZFAIL_DECR_WRAP					0x00008508
+#define  NV50TCL_STENCIL_BACK_OP_ZPASS							0x000015a0
+#define   NV50TCL_STENCIL_BACK_OP_ZPASS_ZERO						0x00000000
+#define   NV50TCL_STENCIL_BACK_OP_ZPASS_INVERT						0x0000150a
+#define   NV50TCL_STENCIL_BACK_OP_ZPASS_KEEP						0x00001e00
+#define   NV50TCL_STENCIL_BACK_OP_ZPASS_REPLACE						0x00001e01
+#define   NV50TCL_STENCIL_BACK_OP_ZPASS_INCR						0x00001e02
+#define   NV50TCL_STENCIL_BACK_OP_ZPASS_DECR						0x00001e03
+#define   NV50TCL_STENCIL_BACK_OP_ZPASS_INCR_WRAP					0x00008507
+#define   NV50TCL_STENCIL_BACK_OP_ZPASS_DECR_WRAP					0x00008508
+#define  NV50TCL_STENCIL_BACK_FUNC_FUNC							0x000015a4
+#define   NV50TCL_STENCIL_BACK_FUNC_FUNC_NEVER						0x00000200
+#define   NV50TCL_STENCIL_BACK_FUNC_FUNC_LESS						0x00000201
+#define   NV50TCL_STENCIL_BACK_FUNC_FUNC_EQUAL						0x00000202
+#define   NV50TCL_STENCIL_BACK_FUNC_FUNC_LEQUAL						0x00000203
+#define   NV50TCL_STENCIL_BACK_FUNC_FUNC_GREATER					0x00000204
+#define   NV50TCL_STENCIL_BACK_FUNC_FUNC_NOTEQUAL					0x00000205
+#define   NV50TCL_STENCIL_BACK_FUNC_FUNC_GEQUAL						0x00000206
+#define   NV50TCL_STENCIL_BACK_FUNC_FUNC_ALWAYS						0x00000207
+#define  NV50TCL_FRAMEBUFFER_SRGB							0x000015b8
+#define  NV50TCL_POLYGON_OFFSET_UNITS							0x000015bc
+#define  NV50TCL_GP_BUILTIN_RESULT_EN							0x000015cc
+#define   NV50TCL_GP_BUILTIN_RESULT_EN_VPORT_IDX					(1 <<  0)
+#define   NV50TCL_GP_BUILTIN_RESULT_EN_LAYER_IDX					(1 << 16)
+#define  NV50TCL_MULTISAMPLE_SAMPLES_LOG2						0x000015d0
+#define  NV50TCL_VERTEX_BEGIN								0x000015dc
+#define   NV50TCL_VERTEX_BEGIN_POINTS							0x00000000
+#define   NV50TCL_VERTEX_BEGIN_LINES							0x00000001
+#define   NV50TCL_VERTEX_BEGIN_LINE_LOOP						0x00000002
+#define   NV50TCL_VERTEX_BEGIN_LINE_STRIP						0x00000003
+#define   NV50TCL_VERTEX_BEGIN_TRIANGLES						0x00000004
+#define   NV50TCL_VERTEX_BEGIN_TRIANGLE_STRIP						0x00000005
+#define   NV50TCL_VERTEX_BEGIN_TRIANGLE_FAN						0x00000006
+#define   NV50TCL_VERTEX_BEGIN_QUADS							0x00000007
+#define   NV50TCL_VERTEX_BEGIN_QUAD_STRIP						0x00000008
+#define   NV50TCL_VERTEX_BEGIN_POLYGON							0x00000009
+#define   NV50TCL_VERTEX_BEGIN_LINES_ADJACENCY						0x0000000a
+#define   NV50TCL_VERTEX_BEGIN_LINE_STRIP_ADJACENCY					0x0000000b
+#define   NV50TCL_VERTEX_BEGIN_TRIANGLES_ADJACENCY					0x0000000c
+#define   NV50TCL_VERTEX_BEGIN_TRIANGLE_STRIP_ADJACENCY					0x0000000d
+#define  NV50TCL_VERTEX_END								0x000015e0
+#define  NV50TCL_EDGEFLAG_ENABLE							0x000015e4
+#define  NV50TCL_VB_ELEMENT_U32								0x000015e8
+#define  NV50TCL_VB_ELEMENT_U16_SETUP							0x000015ec
+#define   NV50TCL_VB_ELEMENT_U16_SETUP_OFFSET_SHIFT					30
+#define   NV50TCL_VB_ELEMENT_U16_SETUP_OFFSET_MASK					0xc0000000
+#define   NV50TCL_VB_ELEMENT_U16_SETUP_COUNT_SHIFT					0
+#define   NV50TCL_VB_ELEMENT_U16_SETUP_COUNT_MASK					0x3fffffff
+#define  NV50TCL_VB_ELEMENT_U16								0x000015f0
+#define   NV50TCL_VB_ELEMENT_U16_I0_SHIFT						0
+#define   NV50TCL_VB_ELEMENT_U16_I0_MASK						0x0000ffff
+#define   NV50TCL_VB_ELEMENT_U16_I1_SHIFT						16
+#define   NV50TCL_VB_ELEMENT_U16_I1_MASK						0xffff0000
+#define  NV50TCL_VERTEX_DATA								0x00001640
+#define  NV50TCL_PRIM_RESTART_ENABLE							0x00001644
+#define  NV50TCL_PRIM_RESTART_INDEX							0x00001648
+#define  NV50TCL_VP_GP_BUILTIN_ATTR_EN							0x0000164c
+#define   NV50TCL_VP_GP_BUILTIN_ATTR_EN_VERTEX_ID					(1 <<  0)
+#define   NV50TCL_VP_GP_BUILTIN_ATTR_EN_INSTANCE_ID					(1 <<  4)
+#define   NV50TCL_VP_GP_BUILTIN_ATTR_EN_PRIMITIVE_ID					(1 <<  8)
+#define   NV50TCL_VP_GP_BUILTIN_ATTR_EN_UNK12						(1 << 12)
+#define  NV50TCL_VP_ATTR_EN_0								0x00001650
+#define   NV50TCL_VP_ATTR_EN_0_7_SHIFT							28
+#define   NV50TCL_VP_ATTR_EN_0_7_MASK							0xf0000000
+#define    NV50TCL_VP_ATTR_EN_0_7_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_0_7_XNNN							0x10000000
+#define    NV50TCL_VP_ATTR_EN_0_7_NYNN							0x20000000
+#define    NV50TCL_VP_ATTR_EN_0_7_XYNN							0x30000000
+#define    NV50TCL_VP_ATTR_EN_0_7_NNZN							0x40000000
+#define    NV50TCL_VP_ATTR_EN_0_7_XNZN							0x50000000
+#define    NV50TCL_VP_ATTR_EN_0_7_NYZN							0x60000000
+#define    NV50TCL_VP_ATTR_EN_0_7_XYZN							0x70000000
+#define    NV50TCL_VP_ATTR_EN_0_7_NNNW							0x80000000
+#define    NV50TCL_VP_ATTR_EN_0_7_XNNW							0x90000000
+#define    NV50TCL_VP_ATTR_EN_0_7_NYNW							0xa0000000
+#define    NV50TCL_VP_ATTR_EN_0_7_XYNW							0xb0000000
+#define    NV50TCL_VP_ATTR_EN_0_7_NNZW							0xc0000000
+#define    NV50TCL_VP_ATTR_EN_0_7_XNZW							0xd0000000
+#define    NV50TCL_VP_ATTR_EN_0_7_NYZW							0xe0000000
+#define    NV50TCL_VP_ATTR_EN_0_7_XYZW							0xf0000000
+#define   NV50TCL_VP_ATTR_EN_0_6_SHIFT							24
+#define   NV50TCL_VP_ATTR_EN_0_6_MASK							0x0f000000
+#define    NV50TCL_VP_ATTR_EN_0_6_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_0_6_XNNN							0x01000000
+#define    NV50TCL_VP_ATTR_EN_0_6_NYNN							0x02000000
+#define    NV50TCL_VP_ATTR_EN_0_6_XYNN							0x03000000
+#define    NV50TCL_VP_ATTR_EN_0_6_NNZN							0x04000000
+#define    NV50TCL_VP_ATTR_EN_0_6_XNZN							0x05000000
+#define    NV50TCL_VP_ATTR_EN_0_6_NYZN							0x06000000
+#define    NV50TCL_VP_ATTR_EN_0_6_XYZN							0x07000000
+#define    NV50TCL_VP_ATTR_EN_0_6_NNNW							0x08000000
+#define    NV50TCL_VP_ATTR_EN_0_6_XNNW							0x09000000
+#define    NV50TCL_VP_ATTR_EN_0_6_NYNW							0x0a000000
+#define    NV50TCL_VP_ATTR_EN_0_6_XYNW							0x0b000000
+#define    NV50TCL_VP_ATTR_EN_0_6_NNZW							0x0c000000
+#define    NV50TCL_VP_ATTR_EN_0_6_XNZW							0x0d000000
+#define    NV50TCL_VP_ATTR_EN_0_6_NYZW							0x0e000000
+#define    NV50TCL_VP_ATTR_EN_0_6_XYZW							0x0f000000
+#define   NV50TCL_VP_ATTR_EN_0_5_SHIFT							20
+#define   NV50TCL_VP_ATTR_EN_0_5_MASK							0x00f00000
+#define    NV50TCL_VP_ATTR_EN_0_5_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_0_5_XNNN							0x00100000
+#define    NV50TCL_VP_ATTR_EN_0_5_NYNN							0x00200000
+#define    NV50TCL_VP_ATTR_EN_0_5_XYNN							0x00300000
+#define    NV50TCL_VP_ATTR_EN_0_5_NNZN							0x00400000
+#define    NV50TCL_VP_ATTR_EN_0_5_XNZN							0x00500000
+#define    NV50TCL_VP_ATTR_EN_0_5_NYZN							0x00600000
+#define    NV50TCL_VP_ATTR_EN_0_5_XYZN							0x00700000
+#define    NV50TCL_VP_ATTR_EN_0_5_NNNW							0x00800000
+#define    NV50TCL_VP_ATTR_EN_0_5_XNNW							0x00900000
+#define    NV50TCL_VP_ATTR_EN_0_5_NYNW							0x00a00000
+#define    NV50TCL_VP_ATTR_EN_0_5_XYNW							0x00b00000
+#define    NV50TCL_VP_ATTR_EN_0_5_NNZW							0x00c00000
+#define    NV50TCL_VP_ATTR_EN_0_5_XNZW							0x00d00000
+#define    NV50TCL_VP_ATTR_EN_0_5_NYZW							0x00e00000
+#define    NV50TCL_VP_ATTR_EN_0_5_XYZW							0x00f00000
+#define   NV50TCL_VP_ATTR_EN_0_4_SHIFT							16
+#define   NV50TCL_VP_ATTR_EN_0_4_MASK							0x000f0000
+#define    NV50TCL_VP_ATTR_EN_0_4_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_0_4_XNNN							0x00010000
+#define    NV50TCL_VP_ATTR_EN_0_4_NYNN							0x00020000
+#define    NV50TCL_VP_ATTR_EN_0_4_XYNN							0x00030000
+#define    NV50TCL_VP_ATTR_EN_0_4_NNZN							0x00040000
+#define    NV50TCL_VP_ATTR_EN_0_4_XNZN							0x00050000
+#define    NV50TCL_VP_ATTR_EN_0_4_NYZN							0x00060000
+#define    NV50TCL_VP_ATTR_EN_0_4_XYZN							0x00070000
+#define    NV50TCL_VP_ATTR_EN_0_4_NNNW							0x00080000
+#define    NV50TCL_VP_ATTR_EN_0_4_XNNW							0x00090000
+#define    NV50TCL_VP_ATTR_EN_0_4_NYNW							0x000a0000
+#define    NV50TCL_VP_ATTR_EN_0_4_XYNW							0x000b0000
+#define    NV50TCL_VP_ATTR_EN_0_4_NNZW							0x000c0000
+#define    NV50TCL_VP_ATTR_EN_0_4_XNZW							0x000d0000
+#define    NV50TCL_VP_ATTR_EN_0_4_NYZW							0x000e0000
+#define    NV50TCL_VP_ATTR_EN_0_4_XYZW							0x000f0000
+#define   NV50TCL_VP_ATTR_EN_0_3_SHIFT							12
+#define   NV50TCL_VP_ATTR_EN_0_3_MASK							0x0000f000
+#define    NV50TCL_VP_ATTR_EN_0_3_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_0_3_XNNN							0x00001000
+#define    NV50TCL_VP_ATTR_EN_0_3_NYNN							0x00002000
+#define    NV50TCL_VP_ATTR_EN_0_3_XYNN							0x00003000
+#define    NV50TCL_VP_ATTR_EN_0_3_NNZN							0x00004000
+#define    NV50TCL_VP_ATTR_EN_0_3_XNZN							0x00005000
+#define    NV50TCL_VP_ATTR_EN_0_3_NYZN							0x00006000
+#define    NV50TCL_VP_ATTR_EN_0_3_XYZN							0x00007000
+#define    NV50TCL_VP_ATTR_EN_0_3_NNNW							0x00008000
+#define    NV50TCL_VP_ATTR_EN_0_3_XNNW							0x00009000
+#define    NV50TCL_VP_ATTR_EN_0_3_NYNW							0x0000a000
+#define    NV50TCL_VP_ATTR_EN_0_3_XYNW							0x0000b000
+#define    NV50TCL_VP_ATTR_EN_0_3_NNZW							0x0000c000
+#define    NV50TCL_VP_ATTR_EN_0_3_XNZW							0x0000d000
+#define    NV50TCL_VP_ATTR_EN_0_3_NYZW							0x0000e000
+#define    NV50TCL_VP_ATTR_EN_0_3_XYZW							0x0000f000
+#define   NV50TCL_VP_ATTR_EN_0_2_SHIFT							8
+#define   NV50TCL_VP_ATTR_EN_0_2_MASK							0x00000f00
+#define    NV50TCL_VP_ATTR_EN_0_2_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_0_2_XNNN							0x00000100
+#define    NV50TCL_VP_ATTR_EN_0_2_NYNN							0x00000200
+#define    NV50TCL_VP_ATTR_EN_0_2_XYNN							0x00000300
+#define    NV50TCL_VP_ATTR_EN_0_2_NNZN							0x00000400
+#define    NV50TCL_VP_ATTR_EN_0_2_XNZN							0x00000500
+#define    NV50TCL_VP_ATTR_EN_0_2_NYZN							0x00000600
+#define    NV50TCL_VP_ATTR_EN_0_2_XYZN							0x00000700
+#define    NV50TCL_VP_ATTR_EN_0_2_NNNW							0x00000800
+#define    NV50TCL_VP_ATTR_EN_0_2_XNNW							0x00000900
+#define    NV50TCL_VP_ATTR_EN_0_2_NYNW							0x00000a00
+#define    NV50TCL_VP_ATTR_EN_0_2_XYNW							0x00000b00
+#define    NV50TCL_VP_ATTR_EN_0_2_NNZW							0x00000c00
+#define    NV50TCL_VP_ATTR_EN_0_2_XNZW							0x00000d00
+#define    NV50TCL_VP_ATTR_EN_0_2_NYZW							0x00000e00
+#define    NV50TCL_VP_ATTR_EN_0_2_XYZW							0x00000f00
+#define   NV50TCL_VP_ATTR_EN_0_1_SHIFT							4
+#define   NV50TCL_VP_ATTR_EN_0_1_MASK							0x000000f0
+#define    NV50TCL_VP_ATTR_EN_0_1_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_0_1_XNNN							0x00000010
+#define    NV50TCL_VP_ATTR_EN_0_1_NYNN							0x00000020
+#define    NV50TCL_VP_ATTR_EN_0_1_XYNN							0x00000030
+#define    NV50TCL_VP_ATTR_EN_0_1_NNZN							0x00000040
+#define    NV50TCL_VP_ATTR_EN_0_1_XNZN							0x00000050
+#define    NV50TCL_VP_ATTR_EN_0_1_NYZN							0x00000060
+#define    NV50TCL_VP_ATTR_EN_0_1_XYZN							0x00000070
+#define    NV50TCL_VP_ATTR_EN_0_1_NNNW							0x00000080
+#define    NV50TCL_VP_ATTR_EN_0_1_XNNW							0x00000090
+#define    NV50TCL_VP_ATTR_EN_0_1_NYNW							0x000000a0
+#define    NV50TCL_VP_ATTR_EN_0_1_XYNW							0x000000b0
+#define    NV50TCL_VP_ATTR_EN_0_1_NNZW							0x000000c0
+#define    NV50TCL_VP_ATTR_EN_0_1_XNZW							0x000000d0
+#define    NV50TCL_VP_ATTR_EN_0_1_NYZW							0x000000e0
+#define    NV50TCL_VP_ATTR_EN_0_1_XYZW							0x000000f0
+#define   NV50TCL_VP_ATTR_EN_0_0_SHIFT							0
+#define   NV50TCL_VP_ATTR_EN_0_0_MASK							0x0000000f
+#define    NV50TCL_VP_ATTR_EN_0_0_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_0_0_XNNN							0x00000001
+#define    NV50TCL_VP_ATTR_EN_0_0_NYNN							0x00000002
+#define    NV50TCL_VP_ATTR_EN_0_0_XYNN							0x00000003
+#define    NV50TCL_VP_ATTR_EN_0_0_NNZN							0x00000004
+#define    NV50TCL_VP_ATTR_EN_0_0_XNZN							0x00000005
+#define    NV50TCL_VP_ATTR_EN_0_0_NYZN							0x00000006
+#define    NV50TCL_VP_ATTR_EN_0_0_XYZN							0x00000007
+#define    NV50TCL_VP_ATTR_EN_0_0_NNNW							0x00000008
+#define    NV50TCL_VP_ATTR_EN_0_0_XNNW							0x00000009
+#define    NV50TCL_VP_ATTR_EN_0_0_NYNW							0x0000000a
+#define    NV50TCL_VP_ATTR_EN_0_0_XYNW							0x0000000b
+#define    NV50TCL_VP_ATTR_EN_0_0_NNZW							0x0000000c
+#define    NV50TCL_VP_ATTR_EN_0_0_XNZW							0x0000000d
+#define    NV50TCL_VP_ATTR_EN_0_0_NYZW							0x0000000e
+#define    NV50TCL_VP_ATTR_EN_0_0_XYZW							0x0000000f
+#define  NV50TCL_VP_ATTR_EN_1								0x00001654
+#define   NV50TCL_VP_ATTR_EN_1_15_SHIFT							28
+#define   NV50TCL_VP_ATTR_EN_1_15_MASK							0xf0000000
+#define    NV50TCL_VP_ATTR_EN_1_15_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_1_15_XNNN							0x10000000
+#define    NV50TCL_VP_ATTR_EN_1_15_NYNN							0x20000000
+#define    NV50TCL_VP_ATTR_EN_1_15_XYNN							0x30000000
+#define    NV50TCL_VP_ATTR_EN_1_15_NNZN							0x40000000
+#define    NV50TCL_VP_ATTR_EN_1_15_XNZN							0x50000000
+#define    NV50TCL_VP_ATTR_EN_1_15_NYZN							0x60000000
+#define    NV50TCL_VP_ATTR_EN_1_15_XYZN							0x70000000
+#define    NV50TCL_VP_ATTR_EN_1_15_NNNW							0x80000000
+#define    NV50TCL_VP_ATTR_EN_1_15_XNNW							0x90000000
+#define    NV50TCL_VP_ATTR_EN_1_15_NYNW							0xa0000000
+#define    NV50TCL_VP_ATTR_EN_1_15_XYNW							0xb0000000
+#define    NV50TCL_VP_ATTR_EN_1_15_NNZW							0xc0000000
+#define    NV50TCL_VP_ATTR_EN_1_15_XNZW							0xd0000000
+#define    NV50TCL_VP_ATTR_EN_1_15_NYZW							0xe0000000
+#define    NV50TCL_VP_ATTR_EN_1_15_XYZW							0xf0000000
+#define   NV50TCL_VP_ATTR_EN_1_14_SHIFT							24
+#define   NV50TCL_VP_ATTR_EN_1_14_MASK							0x0f000000
+#define    NV50TCL_VP_ATTR_EN_1_14_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_1_14_XNNN							0x01000000
+#define    NV50TCL_VP_ATTR_EN_1_14_NYNN							0x02000000
+#define    NV50TCL_VP_ATTR_EN_1_14_XYNN							0x03000000
+#define    NV50TCL_VP_ATTR_EN_1_14_NNZN							0x04000000
+#define    NV50TCL_VP_ATTR_EN_1_14_XNZN							0x05000000
+#define    NV50TCL_VP_ATTR_EN_1_14_NYZN							0x06000000
+#define    NV50TCL_VP_ATTR_EN_1_14_XYZN							0x07000000
+#define    NV50TCL_VP_ATTR_EN_1_14_NNNW							0x08000000
+#define    NV50TCL_VP_ATTR_EN_1_14_XNNW							0x09000000
+#define    NV50TCL_VP_ATTR_EN_1_14_NYNW							0x0a000000
+#define    NV50TCL_VP_ATTR_EN_1_14_XYNW							0x0b000000
+#define    NV50TCL_VP_ATTR_EN_1_14_NNZW							0x0c000000
+#define    NV50TCL_VP_ATTR_EN_1_14_XNZW							0x0d000000
+#define    NV50TCL_VP_ATTR_EN_1_14_NYZW							0x0e000000
+#define    NV50TCL_VP_ATTR_EN_1_14_XYZW							0x0f000000
+#define   NV50TCL_VP_ATTR_EN_1_13_SHIFT							20
+#define   NV50TCL_VP_ATTR_EN_1_13_MASK							0x00f00000
+#define    NV50TCL_VP_ATTR_EN_1_13_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_1_13_XNNN							0x00100000
+#define    NV50TCL_VP_ATTR_EN_1_13_NYNN							0x00200000
+#define    NV50TCL_VP_ATTR_EN_1_13_XYNN							0x00300000
+#define    NV50TCL_VP_ATTR_EN_1_13_NNZN							0x00400000
+#define    NV50TCL_VP_ATTR_EN_1_13_XNZN							0x00500000
+#define    NV50TCL_VP_ATTR_EN_1_13_NYZN							0x00600000
+#define    NV50TCL_VP_ATTR_EN_1_13_XYZN							0x00700000
+#define    NV50TCL_VP_ATTR_EN_1_13_NNNW							0x00800000
+#define    NV50TCL_VP_ATTR_EN_1_13_XNNW							0x00900000
+#define    NV50TCL_VP_ATTR_EN_1_13_NYNW							0x00a00000
+#define    NV50TCL_VP_ATTR_EN_1_13_XYNW							0x00b00000
+#define    NV50TCL_VP_ATTR_EN_1_13_NNZW							0x00c00000
+#define    NV50TCL_VP_ATTR_EN_1_13_XNZW							0x00d00000
+#define    NV50TCL_VP_ATTR_EN_1_13_NYZW							0x00e00000
+#define    NV50TCL_VP_ATTR_EN_1_13_XYZW							0x00f00000
+#define   NV50TCL_VP_ATTR_EN_1_12_SHIFT							16
+#define   NV50TCL_VP_ATTR_EN_1_12_MASK							0x000f0000
+#define    NV50TCL_VP_ATTR_EN_1_12_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_1_12_XNNN							0x00010000
+#define    NV50TCL_VP_ATTR_EN_1_12_NYNN							0x00020000
+#define    NV50TCL_VP_ATTR_EN_1_12_XYNN							0x00030000
+#define    NV50TCL_VP_ATTR_EN_1_12_NNZN							0x00040000
+#define    NV50TCL_VP_ATTR_EN_1_12_XNZN							0x00050000
+#define    NV50TCL_VP_ATTR_EN_1_12_NYZN							0x00060000
+#define    NV50TCL_VP_ATTR_EN_1_12_XYZN							0x00070000
+#define    NV50TCL_VP_ATTR_EN_1_12_NNNW							0x00080000
+#define    NV50TCL_VP_ATTR_EN_1_12_XNNW							0x00090000
+#define    NV50TCL_VP_ATTR_EN_1_12_NYNW							0x000a0000
+#define    NV50TCL_VP_ATTR_EN_1_12_XYNW							0x000b0000
+#define    NV50TCL_VP_ATTR_EN_1_12_NNZW							0x000c0000
+#define    NV50TCL_VP_ATTR_EN_1_12_XNZW							0x000d0000
+#define    NV50TCL_VP_ATTR_EN_1_12_NYZW							0x000e0000
+#define    NV50TCL_VP_ATTR_EN_1_12_XYZW							0x000f0000
+#define   NV50TCL_VP_ATTR_EN_1_11_SHIFT							12
+#define   NV50TCL_VP_ATTR_EN_1_11_MASK							0x0000f000
+#define    NV50TCL_VP_ATTR_EN_1_11_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_1_11_XNNN							0x00001000
+#define    NV50TCL_VP_ATTR_EN_1_11_NYNN							0x00002000
+#define    NV50TCL_VP_ATTR_EN_1_11_XYNN							0x00003000
+#define    NV50TCL_VP_ATTR_EN_1_11_NNZN							0x00004000
+#define    NV50TCL_VP_ATTR_EN_1_11_XNZN							0x00005000
+#define    NV50TCL_VP_ATTR_EN_1_11_NYZN							0x00006000
+#define    NV50TCL_VP_ATTR_EN_1_11_XYZN							0x00007000
+#define    NV50TCL_VP_ATTR_EN_1_11_NNNW							0x00008000
+#define    NV50TCL_VP_ATTR_EN_1_11_XNNW							0x00009000
+#define    NV50TCL_VP_ATTR_EN_1_11_NYNW							0x0000a000
+#define    NV50TCL_VP_ATTR_EN_1_11_XYNW							0x0000b000
+#define    NV50TCL_VP_ATTR_EN_1_11_NNZW							0x0000c000
+#define    NV50TCL_VP_ATTR_EN_1_11_XNZW							0x0000d000
+#define    NV50TCL_VP_ATTR_EN_1_11_NYZW							0x0000e000
+#define    NV50TCL_VP_ATTR_EN_1_11_XYZW							0x0000f000
+#define   NV50TCL_VP_ATTR_EN_1_10_SHIFT							8
+#define   NV50TCL_VP_ATTR_EN_1_10_MASK							0x00000f00
+#define    NV50TCL_VP_ATTR_EN_1_10_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_1_10_XNNN							0x00000100
+#define    NV50TCL_VP_ATTR_EN_1_10_NYNN							0x00000200
+#define    NV50TCL_VP_ATTR_EN_1_10_XYNN							0x00000300
+#define    NV50TCL_VP_ATTR_EN_1_10_NNZN							0x00000400
+#define    NV50TCL_VP_ATTR_EN_1_10_XNZN							0x00000500
+#define    NV50TCL_VP_ATTR_EN_1_10_NYZN							0x00000600
+#define    NV50TCL_VP_ATTR_EN_1_10_XYZN							0x00000700
+#define    NV50TCL_VP_ATTR_EN_1_10_NNNW							0x00000800
+#define    NV50TCL_VP_ATTR_EN_1_10_XNNW							0x00000900
+#define    NV50TCL_VP_ATTR_EN_1_10_NYNW							0x00000a00
+#define    NV50TCL_VP_ATTR_EN_1_10_XYNW							0x00000b00
+#define    NV50TCL_VP_ATTR_EN_1_10_NNZW							0x00000c00
+#define    NV50TCL_VP_ATTR_EN_1_10_XNZW							0x00000d00
+#define    NV50TCL_VP_ATTR_EN_1_10_NYZW							0x00000e00
+#define    NV50TCL_VP_ATTR_EN_1_10_XYZW							0x00000f00
+#define   NV50TCL_VP_ATTR_EN_1_9_SHIFT							4
+#define   NV50TCL_VP_ATTR_EN_1_9_MASK							0x000000f0
+#define    NV50TCL_VP_ATTR_EN_1_9_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_1_9_XNNN							0x00000010
+#define    NV50TCL_VP_ATTR_EN_1_9_NYNN							0x00000020
+#define    NV50TCL_VP_ATTR_EN_1_9_XYNN							0x00000030
+#define    NV50TCL_VP_ATTR_EN_1_9_NNZN							0x00000040
+#define    NV50TCL_VP_ATTR_EN_1_9_XNZN							0x00000050
+#define    NV50TCL_VP_ATTR_EN_1_9_NYZN							0x00000060
+#define    NV50TCL_VP_ATTR_EN_1_9_XYZN							0x00000070
+#define    NV50TCL_VP_ATTR_EN_1_9_NNNW							0x00000080
+#define    NV50TCL_VP_ATTR_EN_1_9_XNNW							0x00000090
+#define    NV50TCL_VP_ATTR_EN_1_9_NYNW							0x000000a0
+#define    NV50TCL_VP_ATTR_EN_1_9_XYNW							0x000000b0
+#define    NV50TCL_VP_ATTR_EN_1_9_NNZW							0x000000c0
+#define    NV50TCL_VP_ATTR_EN_1_9_XNZW							0x000000d0
+#define    NV50TCL_VP_ATTR_EN_1_9_NYZW							0x000000e0
+#define    NV50TCL_VP_ATTR_EN_1_9_XYZW							0x000000f0
+#define   NV50TCL_VP_ATTR_EN_1_8_SHIFT							0
+#define   NV50TCL_VP_ATTR_EN_1_8_MASK							0x0000000f
+#define    NV50TCL_VP_ATTR_EN_1_8_NONE							0x00000000
+#define    NV50TCL_VP_ATTR_EN_1_8_XNNN							0x00000001
+#define    NV50TCL_VP_ATTR_EN_1_8_NYNN							0x00000002
+#define    NV50TCL_VP_ATTR_EN_1_8_XYNN							0x00000003
+#define    NV50TCL_VP_ATTR_EN_1_8_NNZN							0x00000004
+#define    NV50TCL_VP_ATTR_EN_1_8_XNZN							0x00000005
+#define    NV50TCL_VP_ATTR_EN_1_8_NYZN							0x00000006
+#define    NV50TCL_VP_ATTR_EN_1_8_XYZN							0x00000007
+#define    NV50TCL_VP_ATTR_EN_1_8_NNNW							0x00000008
+#define    NV50TCL_VP_ATTR_EN_1_8_XNNW							0x00000009
+#define    NV50TCL_VP_ATTR_EN_1_8_NYNW							0x0000000a
+#define    NV50TCL_VP_ATTR_EN_1_8_XYNW							0x0000000b
+#define    NV50TCL_VP_ATTR_EN_1_8_NNZW							0x0000000c
+#define    NV50TCL_VP_ATTR_EN_1_8_XNZW							0x0000000d
+#define    NV50TCL_VP_ATTR_EN_1_8_NYZW							0x0000000e
+#define    NV50TCL_VP_ATTR_EN_1_8_XYZW							0x0000000f
+#define  NV50TCL_POINT_SPRITE_CTRL							0x00001660
+#define  NV50TCL_LINE_STIPPLE_ENABLE							0x0000166c
+#define  NV50TCL_LINE_STIPPLE_PATTERN							0x00001680
+#define  NV50TCL_PROVOKING_VERTEX_LAST							0x00001684
+#define  NV50TCL_VERTEX_TWO_SIDE_ENABLE							0x00001688
+#define  NV50TCL_POLYGON_STIPPLE_ENABLE							0x0000168c
+#define  NV50TCL_SET_PROGRAM_CB								0x00001694
+#define   NV50TCL_SET_PROGRAM_CB_PROGRAM_SHIFT						4
+#define   NV50TCL_SET_PROGRAM_CB_PROGRAM_MASK						0x000000f0
+#define    NV50TCL_SET_PROGRAM_CB_PROGRAM_VERTEX					0x00000000
+#define    NV50TCL_SET_PROGRAM_CB_PROGRAM_GEOMETRY					0x00000020
+#define    NV50TCL_SET_PROGRAM_CB_PROGRAM_FRAGMENT					0x00000030
+#define   NV50TCL_SET_PROGRAM_CB_INDEX_SHIFT						8
+#define   NV50TCL_SET_PROGRAM_CB_INDEX_MASK						0x00000f00
+#define   NV50TCL_SET_PROGRAM_CB_BUFFER_SHIFT						12
+#define   NV50TCL_SET_PROGRAM_CB_BUFFER_MASK						0x0007f000
+#define   NV50TCL_SET_PROGRAM_CB_VALID							(1 <<  0)
+#define  NV50TCL_VP_RESULT_MAP_SIZE							0x000016ac
+#define  NV50TCL_VP_REG_ALLOC_TEMP							0x000016b0
+#define  NV50TCL_VP_REG_ALLOC_RESULT							0x000016b8
+#define  NV50TCL_VP_RESULT_MAP(x)							(0x000016bc+((x)*4))
+#define  NV50TCL_VP_RESULT_MAP__SIZE							0x00000010
+#define   NV50TCL_VP_RESULT_MAP_0_SHIFT							0
+#define   NV50TCL_VP_RESULT_MAP_0_MASK							0x000000ff
+#define   NV50TCL_VP_RESULT_MAP_1_SHIFT							8
+#define   NV50TCL_VP_RESULT_MAP_1_MASK							0x0000ff00
+#define   NV50TCL_VP_RESULT_MAP_2_SHIFT							16
+#define   NV50TCL_VP_RESULT_MAP_2_MASK							0x00ff0000
+#define   NV50TCL_VP_RESULT_MAP_3_SHIFT							24
+#define   NV50TCL_VP_RESULT_MAP_3_MASK							0xff000000
+#define  NV50TCL_POLYGON_STIPPLE_PATTERN(x)						(0x00001700+((x)*4))
+#define  NV50TCL_POLYGON_STIPPLE_PATTERN__SIZE						0x00000020
+#define  NV50TCL_GP_ENABLE								0x00001798
+#define  NV50TCL_GP_REG_ALLOC_TEMP							0x000017a0
+#define  NV50TCL_GP_REG_ALLOC_RESULT							0x000017a8
+#define  NV50TCL_GP_RESULT_MAP_SIZE							0x000017ac
+#define  NV50TCL_GP_OUTPUT_PRIMITIVE_TYPE						0x000017b0
+#define   NV50TCL_GP_OUTPUT_PRIMITIVE_TYPE_POINTS					0x00000001
+#define   NV50TCL_GP_OUTPUT_PRIMITIVE_TYPE_LINE_STRIP					0x00000002
+#define   NV50TCL_GP_OUTPUT_PRIMITIVE_TYPE_TRIANGLE_STRIP				0x00000003
+#define  NV50TCL_RASTERIZE_ENABLE							0x000017b4
+#define  NV50TCL_STRMOUT_ENABLE								0x000017b8
+#define  NV50TCL_GP_RESULT_MAP(x)							(0x000017fc+((x)*4))
+#define  NV50TCL_GP_RESULT_MAP__SIZE							0x00000020
+#define   NV50TCL_GP_RESULT_MAP_0_SHIFT							0
+#define   NV50TCL_GP_RESULT_MAP_0_MASK							0x000000ff
+#define   NV50TCL_GP_RESULT_MAP_1_SHIFT							8
+#define   NV50TCL_GP_RESULT_MAP_1_MASK							0x0000ff00
+#define   NV50TCL_GP_RESULT_MAP_2_SHIFT							16
+#define   NV50TCL_GP_RESULT_MAP_2_MASK							0x00ff0000
+#define   NV50TCL_GP_RESULT_MAP_3_SHIFT							24
+#define   NV50TCL_GP_RESULT_MAP_3_MASK							0xff000000
+#define  NV50TCL_MAP_SEMANTIC_0								0x00001904
+#define   NV50TCL_MAP_SEMANTIC_0_FFC0_ID_SHIFT						0
+#define   NV50TCL_MAP_SEMANTIC_0_FFC0_ID_MASK						0x000000ff
+#define   NV50TCL_MAP_SEMANTIC_0_BFC0_ID_SHIFT						8
+#define   NV50TCL_MAP_SEMANTIC_0_BFC0_ID_MASK						0x0000ff00
+#define   NV50TCL_MAP_SEMANTIC_0_COLR_NR_SHIFT						16
+#define   NV50TCL_MAP_SEMANTIC_0_COLR_NR_MASK						0x00ff0000
+#define   NV50TCL_MAP_SEMANTIC_0_CLMP_EN_SHIFT						24
+#define   NV50TCL_MAP_SEMANTIC_0_CLMP_EN_MASK						0xff000000
+#define  NV50TCL_MAP_SEMANTIC_1								0x00001908
+#define   NV50TCL_MAP_SEMANTIC_1_CLIP_LO_SHIFT						0
+#define   NV50TCL_MAP_SEMANTIC_1_CLIP_LO_MASK						0x000000ff
+#define   NV50TCL_MAP_SEMANTIC_1_CLIP_HI_SHIFT						8
+#define   NV50TCL_MAP_SEMANTIC_1_CLIP_HI_MASK						0x0000ff00
+#define  NV50TCL_MAP_SEMANTIC_2								0x0000190c
+#define   NV50TCL_MAP_SEMANTIC_2_LAYER_ID_SHIFT						0
+#define   NV50TCL_MAP_SEMANTIC_2_LAYER_ID_MASK						0x000000ff
+#define  NV50TCL_MAP_SEMANTIC_3								0x00001910
+#define   NV50TCL_MAP_SEMANTIC_3_PTSZ_EN						(1 <<  0)
+#define   NV50TCL_MAP_SEMANTIC_3_PTSZ_ID_SHIFT						4
+#define   NV50TCL_MAP_SEMANTIC_3_PTSZ_ID_MASK						0x00000ff0
+#define  NV50TCL_MAP_SEMANTIC_4								0x00001914
+#define   NV50TCL_MAP_SEMANTIC_4_PRIM_ID_SHIFT						0
+#define   NV50TCL_MAP_SEMANTIC_4_PRIM_ID_MASK						0x000000ff
+#define  NV50TCL_CULL_FACE_ENABLE							0x00001918
+#define  NV50TCL_FRONT_FACE								0x0000191c
+#define   NV50TCL_FRONT_FACE_CW								0x00000900
+#define   NV50TCL_FRONT_FACE_CCW							0x00000901
+#define  NV50TCL_CULL_FACE								0x00001920
+#define   NV50TCL_CULL_FACE_FRONT							0x00000404
+#define   NV50TCL_CULL_FACE_BACK							0x00000405
+#define   NV50TCL_CULL_FACE_FRONT_AND_BACK						0x00000408
+#define  NV50TCL_VIEWPORT_TRANSFORM_EN							0x0000192c
+#define  NV50TCL_VIEW_VOLUME_CLIP_CTRL							0x0000193c
+#define  NV50TCL_VIEWPORT_CLIP_RECTS_EN							0x0000194c
+#define  NV50TCL_FP_CTRL_UNK196C							0x0000196c
+#define  NV50TCL_FP_INTERPOLANT_CTRL							0x00001988
+#define   NV50TCL_FP_INTERPOLANT_CTRL_UMASK_SHIFT					24
+#define   NV50TCL_FP_INTERPOLANT_CTRL_UMASK_MASK					0xff000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_NONE					0x00000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_XNNN					0x01000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_NYNN					0x02000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_XYNN					0x03000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_NNZN					0x04000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_XNZN					0x05000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_NYZN					0x06000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_XYZN					0x07000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_NNNW					0x08000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_XNNW					0x09000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_NYNW					0x0a000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_XYNW					0x0b000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_NNZW					0x0c000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_XNZW					0x0d000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_NYZW					0x0e000000
+#define    NV50TCL_FP_INTERPOLANT_CTRL_UMASK_XYZW					0x0f000000
+#define   NV50TCL_FP_INTERPOLANT_CTRL_COUNT_NONFLAT_SHIFT				16
+#define   NV50TCL_FP_INTERPOLANT_CTRL_COUNT_NONFLAT_MASK				0x00ff0000
+#define   NV50TCL_FP_INTERPOLANT_CTRL_OFFSET_SHIFT					8
+#define   NV50TCL_FP_INTERPOLANT_CTRL_OFFSET_MASK					0x0000ff00
+#define   NV50TCL_FP_INTERPOLANT_CTRL_COUNT_SHIFT					0
+#define   NV50TCL_FP_INTERPOLANT_CTRL_COUNT_MASK					0x000000ff
+#define  NV50TCL_FP_REG_ALLOC_TEMP							0x0000198c
+#define  NV50TCL_REG_MODE								0x000019a0
+#define   NV50TCL_REG_MODE_PACKED							0x00000001
+#define   NV50TCL_REG_MODE_STRIPED							0x00000002
+#define  NV50TCL_FP_CONTROL								0x000019a8
+#define   NV50TCL_FP_CONTROL_MULTIPLE_RESULTS						(1 <<  0)
+#define   NV50TCL_FP_CONTROL_EXPORTS_Z							(1 <<  8)
+#define   NV50TCL_FP_CONTROL_USES_KIL							(1 << 20)
+#define  NV50TCL_DEPTH_BOUNDS_EN							0x000019bc
+#define  NV50TCL_LOGIC_OP_ENABLE							0x000019c4
+#define  NV50TCL_LOGIC_OP								0x000019c8
+#define   NV50TCL_LOGIC_OP_CLEAR							0x00001500
+#define   NV50TCL_LOGIC_OP_AND								0x00001501
+#define   NV50TCL_LOGIC_OP_AND_REVERSE							0x00001502
+#define   NV50TCL_LOGIC_OP_COPY								0x00001503
+#define   NV50TCL_LOGIC_OP_AND_INVERTED							0x00001504
+#define   NV50TCL_LOGIC_OP_NOOP								0x00001505
+#define   NV50TCL_LOGIC_OP_XOR								0x00001506
+#define   NV50TCL_LOGIC_OP_OR								0x00001507
+#define   NV50TCL_LOGIC_OP_NOR								0x00001508
+#define   NV50TCL_LOGIC_OP_EQUIV							0x00001509
+#define   NV50TCL_LOGIC_OP_INVERT							0x0000150a
+#define   NV50TCL_LOGIC_OP_OR_REVERSE							0x0000150b
+#define   NV50TCL_LOGIC_OP_COPY_INVERTED						0x0000150c
+#define   NV50TCL_LOGIC_OP_OR_INVERTED							0x0000150d
+#define   NV50TCL_LOGIC_OP_NAND								0x0000150e
+#define   NV50TCL_LOGIC_OP_SET								0x0000150f
+#define  NV50TCL_CLEAR_BUFFERS								0x000019d0
+#define   NV50TCL_CLEAR_BUFFERS_Z							(1 <<  0)
+#define   NV50TCL_CLEAR_BUFFERS_S							(1 <<  1)
+#define   NV50TCL_CLEAR_BUFFERS_R							(1 <<  2)
+#define   NV50TCL_CLEAR_BUFFERS_G							(1 <<  3)
+#define   NV50TCL_CLEAR_BUFFERS_B							(1 <<  4)
+#define   NV50TCL_CLEAR_BUFFERS_A							(1 <<  5)
+#define   NV50TCL_CLEAR_BUFFERS_RT_SHIFT						6
+#define   NV50TCL_CLEAR_BUFFERS_RT_MASK							0x000003c0
+#define   NV50TCL_CLEAR_BUFFERS_LAYER_SHIFT						10
+#define   NV50TCL_CLEAR_BUFFERS_LAYER_MASK						0x0007fc00
+#define  NV50TCL_COLOR_MASK(x)								(0x00001a00+((x)*4))
+#define  NV50TCL_COLOR_MASK__SIZE							0x00000008
+#define   NV50TCL_COLOR_MASK_R_SHIFT							0
+#define   NV50TCL_COLOR_MASK_R_MASK							0x0000000f
+#define   NV50TCL_COLOR_MASK_G_SHIFT							4
+#define   NV50TCL_COLOR_MASK_G_MASK							0x000000f0
+#define   NV50TCL_COLOR_MASK_B_SHIFT							8
+#define   NV50TCL_COLOR_MASK_B_MASK							0x00000f00
+#define   NV50TCL_COLOR_MASK_A_SHIFT							12
+#define   NV50TCL_COLOR_MASK_A_MASK							0x0000f000
+#define  NV50TCL_STRMOUT_ADDRESS_HIGH(x)						(0x00001a80+((x)*16))
+#define  NV50TCL_STRMOUT_ADDRESS_HIGH__SIZE						0x00000004
+#define  NV50TCL_STRMOUT_ADDRESS_LOW(x)							(0x00001a84+((x)*16))
+#define  NV50TCL_STRMOUT_ADDRESS_LOW__SIZE						0x00000004
+#define  NV50TCL_STRMOUT_NUM_ATTRIBS(x)							(0x00001a88+((x)*16))
+#define  NV50TCL_STRMOUT_NUM_ATTRIBS__SIZE						0x00000004
+#define  NV50TCL_VERTEX_ARRAY_ATTRIB(x)							(0x00001ac0+((x)*4))
+#define  NV50TCL_VERTEX_ARRAY_ATTRIB__SIZE						0x00000010
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_BUFFER_SHIFT					0
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_BUFFER_MASK					0x0000000f
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_CONST						(1 <<  4)
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_OFFSET_SHIFT					5
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_OFFSET_MASK					0x0007ffe0
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_SHIFT					19
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_MASK					0x01f80000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_32_32_32_32				0x00080000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_32_32_32					0x00100000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_16_16_16_16				0x00180000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_32_32					0x00200000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_16_16_16					0x00280000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_8_8_8_8					0x00500000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_16_16					0x00780000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_32					0x00900000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_8_8_8					0x00980000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_8_8					0x00c00000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_16					0x00d80000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_FORMAT_8						0x00e80000
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_TYPE_SHIFT					25
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_TYPE_MASK						0x7e000000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_TYPE_FLOAT					0x7e000000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_TYPE_UNORM					0x24000000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_TYPE_SNORM					0x12000000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_TYPE_USCALED					0x5a000000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_TYPE_SSCALED					0x6c000000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_TYPE_UINT					0x48000000
+#define    NV50TCL_VERTEX_ARRAY_ATTRIB_TYPE_SINT					0x36000000
+#define   NV50TCL_VERTEX_ARRAY_ATTRIB_BGRA						(1 << 31)
+#define  NV50TCL_QUERY_ADDRESS_HIGH							0x00001b00
+#define  NV50TCL_QUERY_ADDRESS_LOW							0x00001b04
+#define  NV50TCL_QUERY_COUNTER								0x00001b08
+#define  NV50TCL_QUERY_GET								0x00001b0c
+
+
+#define NV84TCL										0x00008297
+
+
+
+#define NVA0TCL										0x00008397
+
+
+
+#define NVA8TCL										0x00008597
+
+
+
+#define NV50_COMPUTE									0x000050c0
+
+#define  NV50_COMPUTE_NOP								0x00000100
+#define  NV50_COMPUTE_NOTIFY								0x00000104
+#define  NV50_COMPUTE_SERIALIZE								0x00000110
+#define  NV50_COMPUTE_DMA_NOTIFY							0x00000180
+#define  NV50_COMPUTE_DMA_GLOBAL							0x000001a0
+#define  NV50_COMPUTE_DMA_QUERY								0x000001a4
+#define  NV50_COMPUTE_DMA_LOCAL								0x000001b8
+#define  NV50_COMPUTE_DMA_STACK								0x000001bc
+#define  NV50_COMPUTE_DMA_CODE_CB							0x000001c0
+#define  NV50_COMPUTE_DMA_TSC								0x000001c4
+#define  NV50_COMPUTE_DMA_TIC								0x000001c8
+#define  NV50_COMPUTE_DMA_TEXTURE							0x000001cc
+#define  NV50_COMPUTE_CP_ADDRESS_HIGH							0x00000210
+#define  NV50_COMPUTE_CP_ADDRESS_LOW							0x00000214
+#define  NV50_COMPUTE_STACK_ADDRESS_HIGH						0x00000218
+#define  NV50_COMPUTE_STACK_ADDRESS_LOW							0x0000021c
+#define  NV50_COMPUTE_STACK_SIZE_LOG							0x00000220
+#define  NV50_COMPUTE_TSC_ADDRESS_HIGH							0x0000022c
+#define  NV50_COMPUTE_TSC_ADDRESS_LOW							0x00000230
+#define  NV50_COMPUTE_TSC_LIMIT								0x00000234
+#define  NV50_COMPUTE_CB_ADDR								0x00000238
+#define   NV50_COMPUTE_CB_ADDR_ID_SHIFT							8
+#define   NV50_COMPUTE_CB_ADDR_ID_MASK							0x003fff00
+#define   NV50_COMPUTE_CB_ADDR_BUFFER_SHIFT						0
+#define   NV50_COMPUTE_CB_ADDR_BUFFER_MASK						0x0000007f
+#define  NV50_COMPUTE_CB_DATA(x)							(0x0000023c+((x)*4))
+#define  NV50_COMPUTE_CB_DATA__SIZE							0x00000010
+#define  NV50_COMPUTE_DELAY1								0x00000284
+#define  NV50_COMPUTE_WATCHDOG_TIMER							0x00000288
+#define  NV50_COMPUTE_DELAY2								0x0000028c
+#define  NV50_COMPUTE_LOCAL_ADDRESS_HIGH						0x00000294
+#define  NV50_COMPUTE_LOCAL_ADDRESS_LOW							0x00000298
+#define  NV50_COMPUTE_LOCAL_SIZE_LOG							0x0000029c
+#define  NV50_COMPUTE_CB_DEF_ADDRESS_HIGH						0x000002a4
+#define  NV50_COMPUTE_CB_DEF_ADDRESS_LOW						0x000002a8
+#define  NV50_COMPUTE_CB_DEF_SET							0x000002ac
+#define   NV50_COMPUTE_CB_DEF_SET_SIZE_SHIFT						0
+#define   NV50_COMPUTE_CB_DEF_SET_SIZE_MASK						0x0000ffff
+#define   NV50_COMPUTE_CB_DEF_SET_BUFFER_SHIFT						16
+#define   NV50_COMPUTE_CB_DEF_SET_BUFFER_MASK						0x007f0000
+#define  NV50_COMPUTE_BLOCK_ALLOC							0x000002b4
+#define   NV50_COMPUTE_BLOCK_ALLOC_THREADS_SHIFT					0
+#define   NV50_COMPUTE_BLOCK_ALLOC_THREADS_MASK						0x0000ffff
+#define   NV50_COMPUTE_BLOCK_ALLOC_BARRIERS_SHIFT					16
+#define   NV50_COMPUTE_BLOCK_ALLOC_BARRIERS_MASK					0xffff0000
+#define  NV50_COMPUTE_LANES32_ENABLE							0x000002b8
+#define  NV50_COMPUTE_CP_REG_ALLOC_TEMP							0x000002c0
+#define  NV50_COMPUTE_TIC_ADDRESS_HIGH							0x000002c4
+#define  NV50_COMPUTE_TIC_ADDRESS_LOW							0x000002c8
+#define  NV50_COMPUTE_TIC_LIMIT								0x000002cc
+#define  NV50_COMPUTE_PM_SET(x)								(0x000002d0+((x)*4))
+#define  NV50_COMPUTE_PM_SET__SIZE							0x00000004
+#define  NV50_COMPUTE_PM_CONTROL(x)							(0x000002e0+((x)*4))
+#define  NV50_COMPUTE_PM_CONTROL__SIZE							0x00000004
+#define   NV50_COMPUTE_PM_CONTROL_UNK0							(1 <<  0)
+#define   NV50_COMPUTE_PM_CONTROL_UNK1_SHIFT						4
+#define   NV50_COMPUTE_PM_CONTROL_UNK1_MASK						0x00000070
+#define   NV50_COMPUTE_PM_CONTROL_UNK2_SHIFT						8
+#define   NV50_COMPUTE_PM_CONTROL_UNK2_MASK						0xffffff00
+#define  NV50_COMPUTE_LOCAL_WARPS_LOG_ALLOC						0x000002fc
+#define  NV50_COMPUTE_LOCAL_WARPS_NO_CLAMP						0x00000300
+#define  NV50_COMPUTE_STACK_WARPS_LOG_ALLOC						0x00000304
+#define  NV50_COMPUTE_STACK_WARPS_NO_CLAMP						0x00000308
+#define  NV50_COMPUTE_QUERY_ADDRESS_HIGH						0x00000310
+#define  NV50_COMPUTE_QUERY_ADDRESS_LOW							0x00000314
+#define  NV50_COMPUTE_QUERY_COUNTER							0x00000318
+#define  NV50_COMPUTE_QUERY_GET								0x0000031c
+#define  NV50_COMPUTE_COND_ADDRESS_HIGH							0x00000320
+#define  NV50_COMPUTE_COND_ADDRESS_LOW							0x00000324
+#define  NV50_COMPUTE_COND_MODE								0x00000328
+#define   NV50_COMPUTE_COND_MODE_NEVER							0x00000000
+#define   NV50_COMPUTE_COND_MODE_ALWAYS							0x00000001
+#define   NV50_COMPUTE_COND_MODE_RES							0x00000002
+#define   NV50_COMPUTE_COND_MODE_NOT_RES_AND_NOT_ID					0x00000003
+#define   NV50_COMPUTE_COND_MODE_RES_OR_ID						0x00000004
+#define  NV50_COMPUTE_LAUNCH								0x00000368
+#define  NV50_COMPUTE_USER_PARAM_COUNT							0x00000374
+#define   NV50_COMPUTE_USER_PARAM_COUNT_COUNT_SHIFT					8
+#define   NV50_COMPUTE_USER_PARAM_COUNT_COUNT_MASK					0x0000ff00
+#define  NV50_COMPUTE_LINKED_TSC							0x00000378
+#define  NV50_COMPUTE_CODE_CB_FLUSH							0x00000380
+#define  NV50_COMPUTE_GRIDDIM								0x000003a4
+#define   NV50_COMPUTE_GRIDDIM_X_SHIFT							0
+#define   NV50_COMPUTE_GRIDDIM_X_MASK							0x0000ffff
+#define   NV50_COMPUTE_GRIDDIM_Y_SHIFT							16
+#define   NV50_COMPUTE_GRIDDIM_Y_MASK							0xffff0000
+#define  NV50_COMPUTE_SHARED_SIZE							0x000003a8
+#define  NV50_COMPUTE_BLOCKDIM_YX							0x000003ac
+#define   NV50_COMPUTE_BLOCKDIM_YX_X_SHIFT						0
+#define   NV50_COMPUTE_BLOCKDIM_YX_X_MASK						0x0000ffff
+#define   NV50_COMPUTE_BLOCKDIM_YX_Y_SHIFT						16
+#define   NV50_COMPUTE_BLOCKDIM_YX_Y_MASK						0xffff0000
+#define  NV50_COMPUTE_BLOCKDIM_Z							0x000003b0
+#define  NV50_COMPUTE_CP_START_ID							0x000003b4
+#define  NV50_COMPUTE_REG_MODE								0x000003b8
+#define   NV50_COMPUTE_REG_MODE_PACKED							0x00000001
+#define   NV50_COMPUTE_REG_MODE_STRIPED							0x00000002
+#define  NV50_COMPUTE_TEX_LIMITS							0x000003bc
+#define   NV50_COMPUTE_TEX_LIMITS_SAMPLERS_LOG2_SHIFT					0
+#define   NV50_COMPUTE_TEX_LIMITS_SAMPLERS_LOG2_MASK					0x0000000f
+#define   NV50_COMPUTE_TEX_LIMITS_TEXTURES_LOG2_SHIFT					4
+#define   NV50_COMPUTE_TEX_LIMITS_TEXTURES_LOG2_MASK					0x000000f0
+#define  NV50_COMPUTE_BIND_TSC								0x000003c0
+#define   NV50_COMPUTE_BIND_TSC_VALID							(1 <<  0)
+#define   NV50_COMPUTE_BIND_TSC_SAMPLER_SHIFT						4
+#define   NV50_COMPUTE_BIND_TSC_SAMPLER_MASK						0x000000f0
+#define   NV50_COMPUTE_BIND_TSC_TSC_SHIFT						12
+#define   NV50_COMPUTE_BIND_TSC_TSC_MASK						0x001ff000
+#define  NV50_COMPUTE_BIND_TIC								0x000003c4
+#define   NV50_COMPUTE_BIND_TIC_VALID							(1 <<  0)
+#define   NV50_COMPUTE_BIND_TIC_TEXTURE_SHIFT						1
+#define   NV50_COMPUTE_BIND_TIC_TEXTURE_MASK						0x000001fe
+#define   NV50_COMPUTE_BIND_TIC_TIC_SHIFT						9
+#define   NV50_COMPUTE_BIND_TIC_TIC_MASK						0x7ffffe00
+#define  NV50_COMPUTE_SET_PROGRAM_CB							0x000003c8
+#define   NV50_COMPUTE_SET_PROGRAM_CB_INDEX_SHIFT					8
+#define   NV50_COMPUTE_SET_PROGRAM_CB_INDEX_MASK					0x00000f00
+#define   NV50_COMPUTE_SET_PROGRAM_CB_BUFFER_SHIFT					12
+#define   NV50_COMPUTE_SET_PROGRAM_CB_BUFFER_MASK					0x0007f000
+#define   NV50_COMPUTE_SET_PROGRAM_CB_VALID						(1 <<  0)
+#define  NV50_COMPUTE_GLOBAL_ADDRESS_HIGH(x)						(0x00000400+((x)*32))
+#define  NV50_COMPUTE_GLOBAL_ADDRESS_HIGH__SIZE						0x00000010
+#define  NV50_COMPUTE_GLOBAL_ADDRESS_LOW(x)						(0x00000404+((x)*32))
+#define  NV50_COMPUTE_GLOBAL_ADDRESS_LOW__SIZE						0x00000010
+#define  NV50_COMPUTE_GLOBAL_PITCH(x)							(0x00000408+((x)*32))
+#define  NV50_COMPUTE_GLOBAL_PITCH__SIZE						0x00000010
+#define  NV50_COMPUTE_GLOBAL_LIMIT(x)							(0x0000040c+((x)*32))
+#define  NV50_COMPUTE_GLOBAL_LIMIT__SIZE						0x00000010
+#define  NV50_COMPUTE_GLOBAL_MODE(x)							(0x00000410+((x)*32))
+#define  NV50_COMPUTE_GLOBAL_MODE__SIZE							0x00000010
+#define   NV50_COMPUTE_GLOBAL_MODE_LINEAR						(1 <<  0)
+#define   NV50_COMPUTE_GLOBAL_MODE_TILE_MODE_SHIFT					8
+#define   NV50_COMPUTE_GLOBAL_MODE_TILE_MODE_MASK					0x00000f00
+#define  NV50_COMPUTE_USER_PARAM(x)							(0x00000600+((x)*4))
+#define  NV50_COMPUTE_USER_PARAM__SIZE							0x00000040
+
+
+#endif /* NOUVEAU_REG_H */
diff --git a/src/gallium/drivers/nouveau/nouveau_context.c b/src/gallium/drivers/nouveau/nouveau_context.c
deleted file mode 100644
index 15174983e7f..00000000000
--- a/src/gallium/drivers/nouveau/nouveau_context.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "pipe/p_defines.h"
-#include "pipe/p_context.h"
-
-#include "nouveau/nouveau_screen.h"
-#include "nouveau/nouveau_context.h"
-
-#include "nouveau/nouveau_bo.h"
-
-static unsigned int
-nouveau_reference_flags(struct nouveau_bo *bo)
-{
-	uint32_t bo_flags;
-	int flags = 0;
-
-	bo_flags = nouveau_bo_pending(bo);
-	if (bo_flags & NOUVEAU_BO_RD)
-		flags |= PIPE_REFERENCED_FOR_READ;
-	if (bo_flags & NOUVEAU_BO_WR)
-		flags |= PIPE_REFERENCED_FOR_WRITE;
-
-	return flags;
-}
-
-unsigned int
-nouveau_is_texture_referenced(struct pipe_context *pipe,
-			      struct pipe_texture *pt,
-			      unsigned face, unsigned level)
-{
-	struct nouveau_miptree *mt = nouveau_miptree(pt);
-
-	return nouveau_reference_flags(mt->bo);
-}
-
-unsigned int
-nouveau_is_buffer_referenced(struct pipe_context *pipe, struct pipe_buffer *pb)
-{
-	struct nouveau_bo *bo = nouveau_bo(pb);
-
-	return nouveau_reference_flags(bo);
-}
-
diff --git a/src/gallium/drivers/nouveau/nouveau_context.h b/src/gallium/drivers/nouveau/nouveau_context.h
deleted file mode 100644
index 6a28d40da7b..00000000000
--- a/src/gallium/drivers/nouveau/nouveau_context.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef __NOUVEAU_CONTEXT_H__
-#define __NOUVEAU_CONTEXT_H__
-
-unsigned int
-nouveau_is_texture_referenced(struct pipe_context *, struct pipe_texture *,
-			      unsigned face, unsigned level);
-
-unsigned int
-nouveau_is_buffer_referenced(struct pipe_context *, struct pipe_buffer *);
-
-#endif
diff --git a/src/gallium/drivers/nouveau/nouveau_screen.c b/src/gallium/drivers/nouveau/nouveau_screen.c
index b1ad686022a..233a91a2ffd 100644
--- a/src/gallium/drivers/nouveau/nouveau_screen.c
+++ b/src/gallium/drivers/nouveau/nouveau_screen.c
@@ -15,6 +15,7 @@
 
 /* XXX this should go away */
 #include "state_tracker/drm_api.h"
+#include "util/u_simple_screen.h"
 
 static const char *
 nouveau_screen_get_name(struct pipe_screen *pscreen)
@@ -32,56 +33,38 @@ nouveau_screen_get_vendor(struct pipe_screen *pscreen)
 	return "nouveau";
 }
 
-static struct pipe_buffer *
-nouveau_screen_bo_skel(struct pipe_screen *pscreen, struct nouveau_bo *bo,
-		       unsigned alignment, unsigned usage, unsigned size)
-{
-	struct pipe_buffer *pb;
-
-	pb = CALLOC(1, sizeof(struct pipe_buffer)+sizeof(struct nouveau_bo *));
-	if (!pb) {
-		nouveau_bo_ref(NULL, &bo);
-		return NULL;
-	}
 
-	pipe_reference_init(&pb->reference, 1);
-	pb->screen = pscreen;
-	pb->alignment = alignment;
-	pb->usage = usage;
-	pb->size = size;
-	*(struct nouveau_bo **)(pb + 1) = bo;
-	return pb;
-}
 
-static struct pipe_buffer *
+struct nouveau_bo *
 nouveau_screen_bo_new(struct pipe_screen *pscreen, unsigned alignment,
-		      unsigned usage, unsigned size)
+		      unsigned usage, unsigned bind, unsigned size)
 {
 	struct nouveau_device *dev = nouveau_screen(pscreen)->device;
 	struct nouveau_bo *bo = NULL;
 	uint32_t flags = NOUVEAU_BO_MAP, tile_mode = 0, tile_flags = 0;
 	int ret;
 
-	if (usage & NOUVEAU_BUFFER_USAGE_TRANSFER)
-		flags |= NOUVEAU_BO_GART;
-	else
-	if (usage & PIPE_BUFFER_USAGE_VERTEX) {
-		if (pscreen->get_param(pscreen, NOUVEAU_CAP_HW_VTXBUF))
-			flags |= NOUVEAU_BO_GART;
-	} else
-	if (usage & PIPE_BUFFER_USAGE_INDEX) {
-		if (pscreen->get_param(pscreen, NOUVEAU_CAP_HW_IDXBUF))
-			flags |= NOUVEAU_BO_GART;
-	}
-
-	if (usage & PIPE_BUFFER_USAGE_PIXEL) {
-		if (usage & NOUVEAU_BUFFER_USAGE_TEXTURE)
+	if (bind & PIPE_BIND_VERTEX_BUFFER)
+		flags |= nouveau_screen(pscreen)->vertex_buffer_flags;
+	else if (bind & PIPE_BIND_INDEX_BUFFER)
+		flags |= nouveau_screen(pscreen)->index_buffer_flags;
+
+	if (bind & (PIPE_BIND_RENDER_TARGET |
+			PIPE_BIND_DEPTH_STENCIL |
+			PIPE_BIND_BLIT_SOURCE |
+			PIPE_BIND_BLIT_DESTINATION |
+			PIPE_BIND_SCANOUT |
+			PIPE_BIND_DISPLAY_TARGET |
+			PIPE_BIND_SAMPLER_VIEW))
+	{
+		/* TODO: this may be incorrect or suboptimal */
+		if (!(bind & PIPE_BIND_SCANOUT))
 			flags |= NOUVEAU_BO_GART;
-		if (!(usage & PIPE_BUFFER_USAGE_CPU_READ_WRITE))
+		if (usage != PIPE_USAGE_DYNAMIC)
 			flags |= NOUVEAU_BO_VRAM;
 
 		if (dev->chipset == 0x50 || dev->chipset >= 0x80) {
-			if (usage & NOUVEAU_BUFFER_USAGE_ZETA)
+			if (bind & PIPE_BIND_DEPTH_STENCIL)
 				tile_flags = 0x2800;
 			else
 				tile_flags = 0x7000;
@@ -93,10 +76,10 @@ nouveau_screen_bo_new(struct pipe_screen *pscreen, unsigned alignment,
 	if (ret)
 		return NULL;
 
-	return nouveau_screen_bo_skel(pscreen, bo, alignment, usage, size);
+	return bo;
 }
 
-static struct pipe_buffer *
+struct nouveau_bo *
 nouveau_screen_bo_user(struct pipe_screen *pscreen, void *ptr, unsigned bytes)
 {
 	struct nouveau_device *dev = nouveau_screen(pscreen)->device;
@@ -107,47 +90,17 @@ nouveau_screen_bo_user(struct pipe_screen *pscreen, void *ptr, unsigned bytes)
 	if (ret)
 		return NULL;
 
-	return nouveau_screen_bo_skel(pscreen, bo, 0, 0, bytes);
-}
-
-static inline uint32_t
-nouveau_screen_map_flags(unsigned pipe)
-{
-	uint32_t flags = 0;
-
-	if (pipe & PIPE_BUFFER_USAGE_CPU_READ)
-		flags |= NOUVEAU_BO_RD;
-	if (pipe & PIPE_BUFFER_USAGE_CPU_WRITE)
-		flags |= NOUVEAU_BO_WR;
-	if (pipe & PIPE_BUFFER_USAGE_DISCARD)
-		flags |= NOUVEAU_BO_INVAL;
-	if (pipe & PIPE_BUFFER_USAGE_DONTBLOCK)
-		flags |= NOUVEAU_BO_NOWAIT;
-	else
-	if (pipe & PIPE_BUFFER_USAGE_UNSYNCHRONIZED)
-		flags |= NOUVEAU_BO_NOSYNC;
-
-	return flags;
+	return bo;
 }
 
-static void *
-nouveau_screen_bo_map(struct pipe_screen *pscreen, struct pipe_buffer *pb,
-		      unsigned usage)
+void *
+nouveau_screen_bo_map(struct pipe_screen *pscreen,
+		      struct nouveau_bo *bo,
+		      unsigned map_flags)
 {
-	struct nouveau_bo *bo = nouveau_bo(pb);
-	struct nouveau_screen *nscreen = nouveau_screen(pscreen);
 	int ret;
 
-	if (nscreen->pre_pipebuffer_map_callback) {
-		ret = nscreen->pre_pipebuffer_map_callback(pscreen, pb, usage);
-		if (ret) {
-			debug_printf("pre_pipebuffer_map_callback failed %d\n",
-				ret);
-			return NULL;
-		}
-	}
-
-	ret = nouveau_bo_map(bo, nouveau_screen_map_flags(usage));
+	ret = nouveau_bo_map(bo, map_flags);
 	if (ret) {
 		debug_printf("map failed: %d\n", ret);
 		return NULL;
@@ -156,24 +109,12 @@ nouveau_screen_bo_map(struct pipe_screen *pscreen, struct pipe_buffer *pb,
 	return bo->map;
 }
 
-static void *
-nouveau_screen_bo_map_range(struct pipe_screen *pscreen, struct pipe_buffer *pb,
-			    unsigned offset, unsigned length, unsigned usage)
+void *
+nouveau_screen_bo_map_range(struct pipe_screen *pscreen, struct nouveau_bo *bo,
+			    unsigned offset, unsigned length, unsigned flags)
 {
-	struct nouveau_bo *bo = nouveau_bo(pb);
-	struct nouveau_screen *nscreen = nouveau_screen(pscreen);
-	uint32_t flags = nouveau_screen_map_flags(usage);
 	int ret;
 
-	if (nscreen->pre_pipebuffer_map_callback) {
-		ret = nscreen->pre_pipebuffer_map_callback(pscreen, pb, usage);
-		if (ret) {
-			debug_printf("pre_pipebuffer_map_callback failed %d\n",
-				ret);
-			return NULL;
-		}
-	}
-
 	ret = nouveau_bo_map_range(bo, offset, length, flags);
 	if (ret) {
 		nouveau_bo_unmap(bo);
@@ -185,30 +126,23 @@ nouveau_screen_bo_map_range(struct pipe_screen *pscreen, struct pipe_buffer *pb,
 	return (char *)bo->map - offset; /* why gallium? why? */
 }
 
-static void
-nouveau_screen_bo_map_flush(struct pipe_screen *pscreen, struct pipe_buffer *pb,
-			    unsigned offset, unsigned length)
+void
+nouveau_screen_bo_map_flush_range(struct pipe_screen *pscreen, struct nouveau_bo *bo,
+				  unsigned offset, unsigned length)
 {
-	struct nouveau_bo *bo = nouveau_bo(pb);
-
 	nouveau_bo_map_flush(bo, offset, length);
 }
 
-static void
-nouveau_screen_bo_unmap(struct pipe_screen *pscreen, struct pipe_buffer *pb)
+void
+nouveau_screen_bo_unmap(struct pipe_screen *pscreen, struct nouveau_bo *bo)
 {
-	struct nouveau_bo *bo = nouveau_bo(pb);
-
 	nouveau_bo_unmap(bo);
 }
 
-static void
-nouveau_screen_bo_del(struct pipe_buffer *pb)
+void
+nouveau_screen_bo_release(struct pipe_screen *pscreen, struct nouveau_bo *bo)
 {
-	struct nouveau_bo *bo = nouveau_bo(pb);
-
 	nouveau_bo_ref(NULL, &bo);
-	FREE(pb);
 }
 
 static void
@@ -236,71 +170,65 @@ nouveau_screen_fence_finish(struct pipe_screen *screen,
 }
 
 
-/*
- * Both texture_{from|get}_handle use drm api defines directly which they
- * shouldn't do. The problem is that from|get are pipe functions and as
- * such they should be defined in the pipe level. If nouveau had a propper
- * winsys interface we would have added from|get to that interface using
- * the winsys_handle struct as done with other drivers. However this code
- * calls directly into the libdrm_nouveau.so functions (nouveau_bo_*). So
- * we need to translate the handle into something they understand.
- */
-static struct pipe_texture *
-nouveau_screen_texture_from_handle(struct pipe_screen *pscreen,
-				   const struct pipe_texture *templ,
-				   struct winsys_handle *whandle)
+struct nouveau_bo *
+nouveau_screen_bo_from_handle(struct pipe_screen *pscreen,
+			      struct winsys_handle *whandle,
+			      unsigned *out_stride)
 {
 	struct nouveau_device *dev = nouveau_screen(pscreen)->device;
-	struct pipe_texture *pt;
-	struct pipe_buffer *pb;
+	struct nouveau_bo *bo = 0;
 	int ret;
-
-	pb = CALLOC(1, sizeof(struct pipe_buffer) + sizeof(struct nouveau_bo*));
-	if (!pb)
-		return NULL;
-
-	ret = nouveau_bo_handle_ref(dev, whandle->handle, (struct nouveau_bo**)(pb+1));
+ 
+	ret = nouveau_bo_handle_ref(dev, whandle->handle, &bo);
 	if (ret) {
 		debug_printf("%s: ref name 0x%08x failed with %d\n",
 			     __func__, whandle->handle, ret);
-		FREE(pb);
 		return NULL;
 	}
 
-	pipe_reference_init(&pb->reference, 1);
-	pb->screen = pscreen;
-	pb->alignment = 0;
-	pb->usage = PIPE_BUFFER_USAGE_GPU_READ_WRITE |
-		    PIPE_BUFFER_USAGE_CPU_READ_WRITE;
-	pb->size = nouveau_bo(pb)->size;
-	pt = nouveau_screen(pscreen)->texture_blanket(pscreen, templ,
-                                                      &whandle->stride, pb);
-	pipe_buffer_reference(&pb, NULL);
-	return pt;
+	*out_stride = whandle->stride;
+	return bo;
 }
 
-static boolean
-nouveau_screen_texture_get_handle(struct pipe_screen *pscreen,
-				  struct pipe_texture *pt,
-				  struct winsys_handle *whandle)
-{
-	struct nouveau_miptree *mt = nouveau_miptree(pt);
-
-	if (!mt || !mt->bo)
-		return false;
 
-	whandle->stride = util_format_get_stride(mt->base.format, mt->base.width0);
+boolean
+nouveau_screen_bo_get_handle(struct pipe_screen *pscreen,
+			     struct nouveau_bo *bo,
+			     unsigned stride,
+			     struct winsys_handle *whandle)
+{
+	whandle->stride = stride;
 
 	if (whandle->type == DRM_API_HANDLE_TYPE_SHARED) { 
-		return nouveau_bo_handle_get(mt->bo, &whandle->handle) == 0;
+		return nouveau_bo_handle_get(bo, &whandle->handle) == 0;
 	} else if (whandle->type == DRM_API_HANDLE_TYPE_KMS) {
-		whandle->handle = mt->bo->handle;
+		whandle->handle = bo->handle;
 		return TRUE;
 	} else {
 		return FALSE;
 	}
 }
 
+
+unsigned int
+nouveau_reference_flags(struct nouveau_bo *bo)
+{
+	uint32_t bo_flags;
+	int flags = 0;
+
+	bo_flags = nouveau_bo_pending(bo);
+	if (bo_flags & NOUVEAU_BO_RD)
+		flags |= PIPE_REFERENCED_FOR_READ;
+	if (bo_flags & NOUVEAU_BO_WR)
+		flags |= PIPE_REFERENCED_FOR_WRITE;
+
+	return flags;
+}
+
+
+
+
+
 int
 nouveau_screen_init(struct nouveau_screen *screen, struct nouveau_device *dev)
 {
@@ -316,21 +244,10 @@ nouveau_screen_init(struct nouveau_screen *screen, struct nouveau_device *dev)
 	pscreen->get_name = nouveau_screen_get_name;
 	pscreen->get_vendor = nouveau_screen_get_vendor;
 
-	pscreen->buffer_create = nouveau_screen_bo_new;
-	pscreen->user_buffer_create = nouveau_screen_bo_user;
-	pscreen->buffer_map = nouveau_screen_bo_map;
-	pscreen->buffer_map_range = nouveau_screen_bo_map_range;
-	pscreen->buffer_flush_mapped_range = nouveau_screen_bo_map_flush;
-	pscreen->buffer_unmap = nouveau_screen_bo_unmap;
-	pscreen->buffer_destroy = nouveau_screen_bo_del;
-
 	pscreen->fence_reference = nouveau_screen_fence_ref;
 	pscreen->fence_signalled = nouveau_screen_fence_signalled;
 	pscreen->fence_finish = nouveau_screen_fence_finish;
 
-	pscreen->texture_from_handle = nouveau_screen_texture_from_handle;
-	pscreen->texture_get_handle = nouveau_screen_texture_get_handle;
-
 	return 0;
 }
 
diff --git a/src/gallium/drivers/nouveau/nouveau_screen.h b/src/gallium/drivers/nouveau/nouveau_screen.h
index f4a7a2bc234..747fd15acdd 100644
--- a/src/gallium/drivers/nouveau/nouveau_screen.h
+++ b/src/gallium/drivers/nouveau/nouveau_screen.h
@@ -6,20 +6,10 @@ struct nouveau_screen {
 	struct nouveau_device *device;
 	struct nouveau_channel *channel;
 
-        /**
-         * Create a new texture object, using the given template info, but on top of
-         * existing memory.
-         * 
-         * It is assumed that the buffer data is layed out according to the expected
-         * by the hardware. NULL will be returned if any inconsistency is found.  
-         */
-        struct pipe_texture * (*texture_blanket)(struct pipe_screen *,
-                                                 const struct pipe_texture *templat,
-                                                 const unsigned *stride,
-                                                 struct pipe_buffer *buffer);
-
-	int (*pre_pipebuffer_map_callback) (struct pipe_screen *pscreen,
-		struct pipe_buffer *pb, unsigned usage);
+	/* note that OpenGL doesn't distinguish between these, so
+	 * these almost always should be set to the same value */
+	unsigned vertex_buffer_flags;
+	unsigned index_buffer_flags;
 };
 
 static inline struct nouveau_screen *
@@ -28,24 +18,63 @@ nouveau_screen(struct pipe_screen *pscreen)
 	return (struct nouveau_screen *)pscreen;
 }
 
-static inline struct nouveau_bo *
-nouveau_bo(struct pipe_buffer *pb)
-{
-	return pb ? *(struct nouveau_bo **)(pb + 1) : NULL;
-}
+
+
+/* Not really sure if this is needed, or whether the individual
+ * drivers are happy to talk to the bo functions themselves.  In a way
+ * this is what we'd expect from a regular winsys interface.
+ */
+struct nouveau_bo *
+nouveau_screen_bo_new(struct pipe_screen *pscreen, unsigned alignment,
+		      unsigned usage, unsigned bind, unsigned size);
+struct nouveau_bo *
+nouveau_screen_bo_user(struct pipe_screen *pscreen, void *ptr, unsigned bytes);
+void *
+nouveau_screen_bo_map(struct pipe_screen *pscreen,
+		      struct nouveau_bo *pb,
+		      unsigned usage);
+void *
+nouveau_screen_bo_map_range(struct pipe_screen *pscreen, struct nouveau_bo *bo,
+			    unsigned offset, unsigned length, unsigned usage);
+void
+nouveau_screen_bo_map_flush_range(struct pipe_screen *pscreen, struct nouveau_bo *bo,
+				  unsigned offset, unsigned length);
+void
+nouveau_screen_bo_unmap(struct pipe_screen *pscreen, struct nouveau_bo *bo);
+void
+nouveau_screen_bo_release(struct pipe_screen *pscreen, struct nouveau_bo *bo);
+
+boolean
+nouveau_screen_bo_get_handle(struct pipe_screen *pscreen,
+			     struct nouveau_bo *bo,
+			     unsigned stride,
+			     struct winsys_handle *whandle);
+struct nouveau_bo *
+nouveau_screen_bo_from_handle(struct pipe_screen *pscreen,
+			      struct winsys_handle *whandle,
+			      unsigned *out_stride);
+
+unsigned int
+nouveau_reference_flags(struct nouveau_bo *bo);
+
+
 
 int nouveau_screen_init(struct nouveau_screen *, struct nouveau_device *);
 void nouveau_screen_fini(struct nouveau_screen *);
 
-struct nouveau_miptree {
-	struct pipe_texture base;
-	struct nouveau_bo *bo;
-};
 
-static inline struct nouveau_miptree *
-nouveau_miptree(struct pipe_texture *pt)
+
+
+static __inline__ unsigned
+RING_3D(unsigned mthd, unsigned size)
+{
+	return (7 << 13) | (size << 18) | mthd;
+}
+
+static __inline__ unsigned
+RING_3D_NI(unsigned mthd, unsigned size)
 {
-	return (struct nouveau_miptree *)pt;
+	return 0x40000000 | (7 << 13) | (size << 18) | mthd;
 }
 
 #endif
diff --git a/src/gallium/drivers/nouveau/nouveau_statebuf.h b/src/gallium/drivers/nouveau/nouveau_statebuf.h
new file mode 100644
index 00000000000..dcffdd91154
--- /dev/null
+++ b/src/gallium/drivers/nouveau/nouveau_statebuf.h
@@ -0,0 +1,27 @@
+#ifndef __NOUVEAU_STATEBUF_H__
+#define __NOUVEAU_STATEBUF_H__
+
+/* state buffers: lightweight state objects interface */
+/* relocations are not supported, but Gallium CSOs don't require them */
+
+struct nouveau_statebuf_builder
+{
+	uint32_t* p;
+#ifdef DEBUG
+	uint32_t* pend;
+#endif
+};
+
+#ifdef DEBUG
+#define sb_init(var) {var, var + sizeof(var) / sizeof((var)[0])}
+#define sb_data(sb, v) do {assert((sb).p != (sb).pend);  *(sb).p++ = (v);} while(0)
+#else
+#define sb_init(var) {var}
+#define sb_data(sb, v) *(sb).p++ = (v)
+#endif
+
+#define sb_method(sb, v, n)  sb_data(sb, RING_3D(v, n));
+
+#define sb_len(sb, var) ((sb).p - (var))
+#define sb_emit(chan, sb_buf, sb_len) do {WAIT_RING((chan), (sb_len)); OUT_RINGp((chan), (sb_buf), (sb_len)); } while(0)
+#endif
diff --git a/src/gallium/drivers/nouveau/nouveau_stateobj.h b/src/gallium/drivers/nouveau/nouveau_stateobj.h
index 5357e981de3..f5c1c5ca2c3 100644
--- a/src/gallium/drivers/nouveau/nouveau_stateobj.h
+++ b/src/gallium/drivers/nouveau/nouveau_stateobj.h
@@ -271,7 +271,6 @@ so_emit(struct nouveau_channel *chan, struct nouveau_stateobj *so)
 static INLINE void
 so_emit_reloc_markers(struct nouveau_channel *chan, struct nouveau_stateobj *so)
 {
-	struct nouveau_grobj *gr = NULL;
 	unsigned i;
 	int ret = 0;
 
@@ -289,14 +288,11 @@ so_emit_reloc_markers(struct nouveau_channel *chan, struct nouveau_stateobj *so)
 		}
 #endif /* DEBUG_NOUVEAU_STATEOBJ */
 
-		/* The object needs to be bound and the system must know the
-		 * subchannel is being used. Otherwise it will discard it.
+		/* We don't need to autobind, since there are enough subchannels
+		 * for all objects we use. If this is changed, account for the extra
+		 * space in callers of this function.
 		 */
-		if (gr != r->gr) {
-			BEGIN_RING(chan, r->gr, 0x100, 1);
-			OUT_RING(chan, 0);
-			gr = r->gr;
-		}
+		assert(r->gr->bound != NOUVEAU_GROBJ_UNBOUND);
 
 		/* Some relocs really don't like to be hammered,
 		 * NOUVEAU_BO_DUMMY makes sure it only
diff --git a/src/gallium/drivers/nouveau/nouveau_util.h b/src/gallium/drivers/nouveau/nouveau_util.h
index ab7761a31da..ed6e643785d 100644
--- a/src/gallium/drivers/nouveau/nouveau_util.h
+++ b/src/gallium/drivers/nouveau/nouveau_util.h
@@ -98,9 +98,9 @@ struct u_split_prim {
    unsigned p_start;
    unsigned p_end;
 
-   int repeat_first:1;
-   int close_first:1;
-   int edgeflag_off:1;
+   uint repeat_first:1;
+   uint close_first:1;
+   uint edgeflag_off:1;
 };
 
 static inline void
diff --git a/src/gallium/drivers/nouveau/nouveau_winsys.h b/src/gallium/drivers/nouveau/nouveau_winsys.h
index bed014b9ce0..cd7da9977d8 100644
--- a/src/gallium/drivers/nouveau/nouveau_winsys.h
+++ b/src/gallium/drivers/nouveau/nouveau_winsys.h
@@ -2,7 +2,6 @@
 #define NOUVEAU_WINSYS_H
 
 #include <stdint.h>
-#include "util/u_simple_screen.h"
 #include "pipe/p_defines.h"
 
 #include "nouveau/nouveau_bo.h"
@@ -14,17 +13,25 @@
 #include "nouveau/nouveau_resource.h"
 #include "nouveau/nouveau_pushbuf.h"
 
-#define NOUVEAU_CAP_HW_VTXBUF (0xbeef0000)
-#define NOUVEAU_CAP_HW_IDXBUF (0xbeef0001)
-
-#define NOUVEAU_TEXTURE_USAGE_LINEAR (1 << 16)
-
-#define NOUVEAU_BUFFER_USAGE_TEXTURE  (1 << 16)
-#define NOUVEAU_BUFFER_USAGE_ZETA     (1 << 17)
-#define NOUVEAU_BUFFER_USAGE_TRANSFER (1 << 18)
-
-/* use along with GPU_WRITE for 2D-only writes */
-#define NOUVEAU_BUFFER_USAGE_NO_RENDER (1 << 19)
+static inline uint32_t
+nouveau_screen_transfer_flags(unsigned pipe)
+{
+	uint32_t flags = 0;
+
+	if (pipe & PIPE_TRANSFER_READ)
+		flags |= NOUVEAU_BO_RD;
+	if (pipe & PIPE_TRANSFER_WRITE)
+		flags |= NOUVEAU_BO_WR;
+	if (pipe & PIPE_TRANSFER_DISCARD)
+		flags |= NOUVEAU_BO_INVAL;
+	if (pipe & PIPE_TRANSFER_DONTBLOCK)
+		flags |= NOUVEAU_BO_NOWAIT;
+	else
+	if (pipe & PIPE_TRANSFER_UNSYNCHRONIZED)
+		flags |= NOUVEAU_BO_NOSYNC;
+
+	return flags;
+}
 
 extern struct pipe_screen *
 nvfx_screen_create(struct pipe_winsys *ws, struct nouveau_device *);
diff --git a/src/gallium/drivers/nv50/Makefile b/src/gallium/drivers/nv50/Makefile
index 5d622e1c13c..e31e6f8662a 100644
--- a/src/gallium/drivers/nv50/Makefile
+++ b/src/gallium/drivers/nv50/Makefile
@@ -4,12 +4,14 @@ include $(TOP)/configs/current
 LIBNAME = nv50
 
 C_SOURCES = \
+	nv50_buffer.c \
 	nv50_clear.c \
 	nv50_context.c \
 	nv50_draw.c \
 	nv50_miptree.c \
 	nv50_query.c \
 	nv50_program.c \
+	nv50_resource.c \
 	nv50_screen.c \
 	nv50_state.c \
 	nv50_state_validate.c \
diff --git a/src/gallium/drivers/nv50/nv50_buffer.c b/src/gallium/drivers/nv50/nv50_buffer.c
new file mode 100644
index 00000000000..0bda7f78fb5
--- /dev/null
+++ b/src/gallium/drivers/nv50/nv50_buffer.c
@@ -0,0 +1,150 @@
+
+#include "util/u_inlines.h"
+#include "util/u_memory.h"
+#include "util/u_math.h"
+
+#include "nouveau/nouveau_screen.h"
+#include "nouveau/nouveau_winsys.h"
+#include "nv50_resource.h"
+
+
+
+static void nv50_buffer_destroy(struct pipe_screen *pscreen,
+				struct pipe_resource *presource)
+{
+	struct nv50_resource *buffer = nv50_resource(presource);
+
+	nouveau_screen_bo_release(pscreen, buffer->bo);
+	FREE(buffer);
+}
+
+
+
+
+/* Utility functions for transfer create/destroy are hooked in and
+ * just record the arguments to those functions.
+ */
+static void *
+nv50_buffer_transfer_map( struct pipe_context *pipe,
+			  struct pipe_transfer *transfer )
+{
+	struct nv50_resource *buffer = nv50_resource(transfer->resource);
+	uint8_t *map;
+
+	map = nouveau_screen_bo_map_range( pipe->screen,
+					   buffer->bo,
+					   transfer->box.x,
+					   transfer->box.width,
+					   nouveau_screen_transfer_flags(transfer->usage) );
+	if (map == NULL)
+		return NULL;
+	
+	return map + transfer->box.x;
+}
+
+
+
+static void nv50_buffer_transfer_flush_region( struct pipe_context *pipe,
+					       struct pipe_transfer *transfer,
+					       const struct pipe_box *box)
+{
+	struct nv50_resource *buffer = nv50_resource(transfer->resource);
+
+	nouveau_screen_bo_map_flush_range(pipe->screen,
+					  buffer->bo,
+					  transfer->box.x + box->x,
+					  box->width);
+}
+
+static void nv50_buffer_transfer_unmap( struct pipe_context *pipe,
+					struct pipe_transfer *transfer )
+{
+	struct nv50_resource *buffer = nv50_resource(transfer->resource);
+
+	nouveau_screen_bo_unmap(pipe->screen, buffer->bo);
+}
+
+
+
+
+const struct u_resource_vtbl nv50_buffer_vtbl =
+{
+	u_default_resource_get_handle,      /* get_handle */
+	nv50_buffer_destroy,		    /* resource_destroy */
+	NULL,			            /* is_resource_referenced */
+	u_default_get_transfer,		    /* get_transfer */
+	u_default_transfer_destroy,	    /* transfer_destroy */
+	nv50_buffer_transfer_map,	    /* transfer_map */
+	nv50_buffer_transfer_flush_region,  /* transfer_flush_region */
+	nv50_buffer_transfer_unmap,	    /* transfer_unmap */
+	u_default_transfer_inline_write	    /* transfer_inline_write */
+};
+
+
+
+
+struct pipe_resource *
+nv50_buffer_create(struct pipe_screen *pscreen,
+		   const struct pipe_resource *template)
+{
+	struct nv50_resource *buffer;
+
+	buffer = CALLOC_STRUCT(nv50_resource);
+	if (!buffer)
+		return NULL;
+
+	buffer->base = *template;
+	buffer->vtbl = &nv50_buffer_vtbl;
+	pipe_reference_init(&buffer->base.reference, 1);
+	buffer->base.screen = pscreen;
+
+	buffer->bo = nouveau_screen_bo_new(pscreen,
+					   16,
+					   buffer->base._usage,
+					   buffer->base.bind,
+					   buffer->base.width0);
+
+	if (buffer->bo == NULL)
+		goto fail;
+
+	return &buffer->base;
+
+fail:
+	FREE(buffer);
+	return NULL;
+}
+
+
+struct pipe_resource *
+nv50_user_buffer_create(struct pipe_screen *pscreen,
+			void *ptr,
+			unsigned bytes,
+			unsigned bind)
+{
+	struct nv50_resource *buffer;
+
+	buffer = CALLOC_STRUCT(nv50_resource);
+	if (!buffer)
+		return NULL;
+
+	pipe_reference_init(&buffer->base.reference, 1);
+	buffer->vtbl = &nv50_buffer_vtbl;
+	buffer->base.screen = pscreen;
+	buffer->base.format = PIPE_FORMAT_R8_UNORM;
+	buffer->base._usage = PIPE_USAGE_IMMUTABLE;
+	buffer->base.bind = bind;
+	buffer->base.width0 = bytes;
+	buffer->base.height0 = 1;
+	buffer->base.depth0 = 1;
+
+	buffer->bo = nouveau_screen_bo_user(pscreen, ptr, bytes);
+	if (!buffer->bo)
+		goto fail;
+	
+	return &buffer->base;
+
+fail:
+	FREE(buffer);
+	return NULL;
+}
+
diff --git a/src/gallium/drivers/nv50/nv50_context.c b/src/gallium/drivers/nv50/nv50_context.c
index 92b194a8f82..f543b3c504d 100644
--- a/src/gallium/drivers/nv50/nv50_context.c
+++ b/src/gallium/drivers/nv50/nv50_context.c
@@ -22,10 +22,10 @@
 
 #include "draw/draw_context.h"
 #include "pipe/p_defines.h"
-#include "util/u_format.h"
 
 #include "nv50_context.h"
 #include "nv50_screen.h"
+#include "nv50_resource.h"
 
 static void
 nv50_flush(struct pipe_context *pipe, unsigned flags,
@@ -90,15 +90,12 @@ nv50_create(struct pipe_screen *pscreen, void *priv)
 
 	nv50->pipe.flush = nv50_flush;
 
-	nv50->pipe.is_texture_referenced = nouveau_is_texture_referenced;
-	nv50->pipe.is_buffer_referenced = nouveau_is_buffer_referenced;
-
 	screen->base.channel->user_private = nv50;
 
 	nv50_init_surface_functions(nv50);
 	nv50_init_state_functions(nv50);
 	nv50_init_query_functions(nv50);
-        nv50_init_transfer_functions(nv50);
+	nv50_init_resource_functions(&nv50->pipe);
 
 	nv50->draw = draw_create();
 	assert(nv50->draw);
diff --git a/src/gallium/drivers/nv50/nv50_context.h b/src/gallium/drivers/nv50/nv50_context.h
index bc7831d9aca..8bf465378e3 100644
--- a/src/gallium/drivers/nv50/nv50_context.h
+++ b/src/gallium/drivers/nv50/nv50_context.h
@@ -16,7 +16,6 @@
 #include "nouveau/nouveau_winsys.h"
 #include "nouveau/nouveau_gldefs.h"
 #include "nouveau/nouveau_stateobj.h"
-#include "nouveau/nouveau_context.h"
 
 #include "nv50_screen.h"
 #include "nv50_program.h"
@@ -101,27 +100,6 @@ get_tile_depth(uint32_t tile_mode)
         return 1 << (tile_mode >> 4);
 }
 
-struct nv50_miptree_level {
-	int *image_offset;
-	unsigned pitch;
-	unsigned tile_mode;
-};
-
-#define NV50_MAX_TEXTURE_LEVELS 16
-
-struct nv50_miptree {
-	struct nouveau_miptree base;
-
-	struct nv50_miptree_level level[NV50_MAX_TEXTURE_LEVELS];
-	int image_nr;
-	int total_size;
-};
-
-static INLINE struct nv50_miptree *
-nv50_miptree(struct pipe_texture *pt)
-{
-	return (struct nv50_miptree *)pt;
-}
 
 struct nv50_surface {
 	struct pipe_surface base;
@@ -165,7 +143,7 @@ struct nv50_context {
 	struct nv50_program *vertprog;
 	struct nv50_program *fragprog;
 	struct nv50_program *geomprog;
-	struct pipe_buffer *constbuf[PIPE_SHADER_TYPES];
+	struct pipe_resource *constbuf[PIPE_SHADER_TYPES];
 	struct pipe_vertex_buffer vtxbuf[PIPE_MAX_ATTRIBS];
 	unsigned vtxbuf_nr;
 	struct nv50_vtxelt_stateobj *vtxelt;
@@ -206,12 +184,12 @@ extern void nv50_draw_arrays_instanced(struct pipe_context *, unsigned mode,
 					unsigned startInstance,
 					unsigned instanceCount);
 extern void nv50_draw_elements(struct pipe_context *pipe,
-				  struct pipe_buffer *indexBuffer,
+				  struct pipe_resource *indexBuffer,
 				  unsigned indexSize,
 				  unsigned mode, unsigned start,
 				  unsigned count);
 extern void nv50_draw_elements_instanced(struct pipe_context *pipe,
-					 struct pipe_buffer *indexBuffer,
+					 struct pipe_resource *indexBuffer,
 					 unsigned indexSize,
 					 unsigned mode, unsigned start,
 					 unsigned count,
@@ -222,7 +200,7 @@ extern struct nouveau_stateobj *nv50_vbo_validate(struct nv50_context *nv50);
 
 /* nv50_push.c */
 extern void
-nv50_push_elements_instanced(struct pipe_context *, struct pipe_buffer *,
+nv50_push_elements_instanced(struct pipe_context *, struct pipe_resource *,
 			     unsigned idxsize, unsigned mode, unsigned start,
 			     unsigned count, unsigned i_start,
 			     unsigned i_count);
@@ -258,13 +236,6 @@ extern boolean nv50_tex_construct(struct nv50_sampler_view *view);
 extern void nv50_tex_relocs(struct nv50_context *);
 extern struct nouveau_stateobj *nv50_tex_validate(struct nv50_context *);
 
-/* nv50_transfer.c */
-extern void
-nv50_upload_sifc(struct nv50_context *nv50,
-		 struct nouveau_bo *bo, unsigned dst_offset, unsigned reloc,
-		 unsigned dst_format, int dst_w, int dst_h, int dst_pitch,
-		 void *src, unsigned src_format, int src_pitch,
-		 int x, int y, int w, int h, int cpp);
 
 /* nv50_context.c */
 struct pipe_context *
diff --git a/src/gallium/drivers/nv50/nv50_miptree.c b/src/gallium/drivers/nv50/nv50_miptree.c
index 85b0aef20cc..b7cd92158fe 100644
--- a/src/gallium/drivers/nv50/nv50_miptree.c
+++ b/src/gallium/drivers/nv50/nv50_miptree.c
@@ -26,6 +26,8 @@
 #include "util/u_format.h"
 
 #include "nv50_context.h"
+#include "nv50_resource.h"
+#include "nv50_transfer.h"
 
 /* The restrictions in tile mode selection probably aren't necessary. */
 static INLINE uint32_t
@@ -70,18 +72,76 @@ get_zslice_offset(unsigned tile_mode, unsigned z, unsigned pitch, unsigned nb_h)
 	return (z % tile_d) * pitch_2d + (z / tile_d) * pitch_3d;
 }
 
-static struct pipe_texture *
-nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
+
+
+
+static void
+nv50_miptree_destroy(struct pipe_screen *pscreen,
+		     struct pipe_resource *pt)
+{
+	struct nv50_miptree *mt = nv50_miptree(pt);
+	unsigned l;
+
+	for (l = 0; l <= pt->last_level; ++l)
+		FREE(mt->level[l].image_offset);
+
+	nouveau_screen_bo_release(pscreen, mt->base.bo);
+	FREE(mt);
+}
+
+static boolean
+nv50_miptree_get_handle(struct pipe_screen *pscreen,
+			struct pipe_resource *pt,
+			struct winsys_handle *whandle)
+{
+	struct nv50_miptree *mt = nv50_miptree(pt);
+	unsigned stride;
+
+
+	if (!mt || !mt->base.bo)
+		return FALSE;
+
+	stride = util_format_get_stride(mt->base.base.format,
+					mt->base.base.width0);
+
+	return nouveau_screen_bo_get_handle(pscreen,
+					    mt->base.bo,
+					    stride,
+					    whandle);
+}
+
+
+const struct u_resource_vtbl nv50_miptree_vtbl =
+{
+   nv50_miptree_get_handle,	      /* get_handle */
+   nv50_miptree_destroy,	      /* resource_destroy */
+   NULL,			      /* is_resource_referenced */
+   nv50_miptree_transfer_new,	      /* get_transfer */
+   nv50_miptree_transfer_del,     /* transfer_destroy */
+   nv50_miptree_transfer_map,	      /* transfer_map */
+   u_default_transfer_flush_region,   /* transfer_flush_region */
+   nv50_miptree_transfer_unmap,	      /* transfer_unmap */
+   u_default_transfer_inline_write    /* transfer_inline_write */
+};
+
+
+
+struct pipe_resource *
+nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_resource *tmp)
 {
 	struct nouveau_device *dev = nouveau_screen(pscreen)->device;
 	struct nv50_miptree *mt = CALLOC_STRUCT(nv50_miptree);
-	struct pipe_texture *pt = &mt->base.base;
+	struct pipe_resource *pt = &mt->base.base;
 	unsigned width = tmp->width0, height = tmp->height0;
 	unsigned depth = tmp->depth0, image_alignment;
 	uint32_t tile_flags;
 	int ret, i, l;
 
+	if (!mt)
+		return NULL;
+
 	*pt = *tmp;
+	mt->base.vtbl = &nv50_miptree_vtbl;
 	pipe_reference_init(&pt->reference, 1);
 	pt->screen = pscreen;
 
@@ -104,7 +164,7 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
 		tile_flags = 0x7400;
 		break;
 	default:
-		if ((pt->tex_usage & PIPE_TEXTURE_USAGE_SCANOUT) &&
+		if ((pt->bind & PIPE_BIND_SCANOUT) &&
 		    util_format_get_blocksizebits(pt->format) == 32)
 			tile_flags = 0x7a00;
 		else
@@ -165,49 +225,54 @@ nv50_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *tmp)
 	return pt;
 }
 
-static struct pipe_texture *
-nv50_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
-		     const unsigned *stride, struct pipe_buffer *pb)
+
+struct pipe_resource *
+nv50_miptree_from_handle(struct pipe_screen *pscreen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle)
 {
-	struct nouveau_bo *bo = nouveau_bo(pb);
 	struct nv50_miptree *mt;
+	unsigned stride;
 
 	/* Only supports 2D, non-mipmapped textures for the moment */
-	if (pt->target != PIPE_TEXTURE_2D || pt->last_level != 0 ||
-	    pt->depth0 != 1)
+	if (template->target != PIPE_TEXTURE_2D ||
+	    template->last_level != 0 ||
+	    template->depth0 != 1)
 		return NULL;
 
 	mt = CALLOC_STRUCT(nv50_miptree);
 	if (!mt)
 		return NULL;
 
-	mt->base.base = *pt;
+	mt->base.bo = nouveau_screen_bo_from_handle(pscreen, whandle, &stride);
+	if (mt->base.bo == NULL) {
+		FREE(mt);
+		return NULL;
+	}
+
+
+	mt->base.base = *template;
+	mt->base.vtbl = &nv50_miptree_vtbl;
 	pipe_reference_init(&mt->base.base.reference, 1);
 	mt->base.base.screen = pscreen;
 	mt->image_nr = 1;
-	mt->level[0].pitch = *stride;
+	mt->level[0].pitch = stride;
 	mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
-	mt->level[0].tile_mode = bo->tile_mode;
+	mt->level[0].tile_mode = mt->base.bo->tile_mode;
 
-	nouveau_bo_ref(bo, &mt->base.bo);
+	/* XXX: Need to adjust bo refcount??
+	 */
+	/* nouveau_bo_ref(bo, &mt->base.bo); */
 	return &mt->base.base;
 }
 
-static void
-nv50_miptree_destroy(struct pipe_texture *pt)
-{
-	struct nv50_miptree *mt = nv50_miptree(pt);
-	unsigned l;
 
-	for (l = 0; l <= pt->last_level; ++l)
-		FREE(mt->level[l].image_offset);
 
-	nouveau_bo_ref(NULL, &mt->base.bo);
-	FREE(mt);
-}
+/* Surface functions
+ */
 
-static struct pipe_surface *
-nv50_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
+struct pipe_surface *
+nv50_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_resource *pt,
 			 unsigned face, unsigned level, unsigned zslice,
 			 unsigned flags)
 {
@@ -222,7 +287,7 @@ nv50_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
 	ps = CALLOC_STRUCT(pipe_surface);
 	if (!ps)
 		return NULL;
-	pipe_texture_reference(&ps->texture, pt);
+	pipe_resource_reference(&ps->texture, pt);
 	ps->format = pt->format;
 	ps->width = u_minify(pt->width0, level);
 	ps->height = u_minify(pt->height0, level);
@@ -242,23 +307,11 @@ nv50_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
 	return ps;
 }
 
-static void
+void
 nv50_miptree_surface_del(struct pipe_surface *ps)
 {
 	struct nv50_surface *s = nv50_surface(ps);
 
-	pipe_texture_reference(&ps->texture, NULL);
+	pipe_resource_reference(&ps->texture, NULL);
 	FREE(s);
 }
-
-void
-nv50_screen_init_miptree_functions(struct pipe_screen *pscreen)
-{
-	pscreen->texture_create = nv50_miptree_create;
-	pscreen->texture_destroy = nv50_miptree_destroy;
-	pscreen->get_tex_surface = nv50_miptree_surface_new;
-	pscreen->tex_surface_destroy = nv50_miptree_surface_del;
-
-	nouveau_screen(pscreen)->texture_blanket = nv50_miptree_blanket;
-}
-
diff --git a/src/gallium/drivers/nv50/nv50_program.c b/src/gallium/drivers/nv50/nv50_program.c
index d7e06c93272..11ca2a21178 100644
--- a/src/gallium/drivers/nv50/nv50_program.c
+++ b/src/gallium/drivers/nv50/nv50_program.c
@@ -30,6 +30,7 @@
 #include "tgsi/tgsi_util.h"
 
 #include "nv50_context.h"
+#include "nv50_transfer.h"
 
 #define NV50_SU_MAX_TEMP 127
 #define NV50_SU_MAX_ADDR 4
@@ -4157,7 +4158,8 @@ nv50_program_upload_data(struct nv50_context *nv50, uint32_t *map,
 static void
 nv50_program_validate_data(struct nv50_context *nv50, struct nv50_program *p)
 {
-	struct pipe_screen *pscreen = nv50->pipe.screen;
+	struct pipe_context *pipe = &nv50->pipe;
+	struct pipe_transfer *transfer;
 
 	if (!p->data[0] && p->immd_nr) {
 		struct nouveau_resource *heap = nv50->screen->immd_heap[0];
@@ -4182,9 +4184,10 @@ nv50_program_validate_data(struct nv50_context *nv50, struct nv50_program *p)
 
 	if (p->param_nr) {
 		unsigned cb;
-		uint32_t *map = pipe_buffer_map(pscreen,
+		uint32_t *map = pipe_buffer_map(pipe,
 						nv50->constbuf[p->type],
-						PIPE_BUFFER_USAGE_CPU_READ);
+						PIPE_TRANSFER_READ,
+						&transfer);
 		switch (p->type) {
 		case PIPE_SHADER_GEOMETRY: cb = NV50_CB_PGP; break;
 		case PIPE_SHADER_FRAGMENT: cb = NV50_CB_PFP; break;
@@ -4195,7 +4198,8 @@ nv50_program_validate_data(struct nv50_context *nv50, struct nv50_program *p)
 		}
 
 		nv50_program_upload_data(nv50, map, 0, p->param_nr, cb);
-		pipe_buffer_unmap(pscreen, nv50->constbuf[p->type]);
+		pipe_buffer_unmap(pipe, nv50->constbuf[p->type],
+				  transfer);
 	}
 }
 
@@ -4546,7 +4550,7 @@ nv50_fp_linkage_validate(struct nv50_context *nv50)
 	so = so_new(10, 54, 0);
 
 	n = (m + 3) / 4;
-	assert(m <= 32);
+	assert(m <= 64);
 	if (vp->type == PIPE_SHADER_GEOMETRY) {
 		so_method(so, tesla, NV50TCL_GP_RESULT_MAP_SIZE, 1);
 		so_data  (so, m);
diff --git a/src/gallium/drivers/nv50/nv50_push.c b/src/gallium/drivers/nv50/nv50_push.c
index 96a1f32d304..6981e5b919b 100644
--- a/src/gallium/drivers/nv50/nv50_push.c
+++ b/src/gallium/drivers/nv50/nv50_push.c
@@ -5,6 +5,7 @@
 
 #include "nouveau/nouveau_util.h"
 #include "nv50_context.h"
+#include "nv50_resource.h"
 
 struct push_context {
    struct nv50_context *nv50;
@@ -171,7 +172,7 @@ emit_verts(void *priv, unsigned start, unsigned count)
 
 void
 nv50_push_elements_instanced(struct pipe_context *pipe,
-                             struct pipe_buffer *idxbuf, unsigned idxsize,
+                             struct pipe_resource *idxbuf, unsigned idxsize,
                              unsigned mode, unsigned start, unsigned count,
                              unsigned i_start, unsigned i_count)
 {
@@ -199,7 +200,7 @@ nv50_push_elements_instanced(struct pipe_context *pipe,
    for (i = 0; i < nv50->vtxelt->num_elements; i++) {
       struct pipe_vertex_element *ve = &nv50->vtxelt->pipe[i];
       struct pipe_vertex_buffer *vb = &nv50->vtxbuf[ve->vertex_buffer_index];
-      struct nouveau_bo *bo = nouveau_bo(vb->buffer);
+      struct nouveau_bo *bo = nv50_resource(vb->buffer)->bo;
       unsigned size, nr_components, n;
 
       if (!(nv50->vbo_fifo & (1 << i)))
@@ -260,7 +261,7 @@ nv50_push_elements_instanced(struct pipe_context *pipe,
 
    /* map index buffer, if present */
    if (idxbuf) {
-      struct nouveau_bo *bo = nouveau_bo(idxbuf);
+      struct nouveau_bo *bo = nv50_resource(idxbuf)->bo;
 
       if (nouveau_bo_map(bo, NOUVEAU_BO_RD)) {
          assert(bo->map);
diff --git a/src/gallium/drivers/nv50/nv50_resource.c b/src/gallium/drivers/nv50/nv50_resource.c
new file mode 100644
index 00000000000..cfdb60418b5
--- /dev/null
+++ b/src/gallium/drivers/nv50/nv50_resource.c
@@ -0,0 +1,67 @@
+
+#include "pipe/p_context.h"
+#include "nv50_resource.h"
+#include "nouveau/nouveau_screen.h"
+
+
+/* This doesn't look quite right - this query is supposed to ask
+ * whether the particular context has references to the resource in
+ * any unflushed rendering command buffer, and hence requires a
+ * pipe->flush() for serializing some modification to that resource.
+ *
+ * This seems to be answering the question of whether the resource is
+ * currently on hardware.
+ */
+static unsigned int
+nv50_resource_is_referenced(struct pipe_context *pipe,
+			    struct pipe_resource *resource,
+			    unsigned face, unsigned level)
+{
+	return nouveau_reference_flags(nv50_resource(resource)->bo);
+}
+
+static struct pipe_resource *
+nv50_resource_create(struct pipe_screen *screen,
+		     const struct pipe_resource *template)
+{
+	if (template->target == PIPE_BUFFER)
+		return nv50_buffer_create(screen, template);
+	else
+		return nv50_miptree_create(screen, template);
+}
+
+static struct pipe_resource *
+nv50_resource_from_handle(struct pipe_screen * screen,
+			  const struct pipe_resource *template,
+			  struct winsys_handle *whandle)
+{
+	if (template->target == PIPE_BUFFER)
+		return NULL;
+	else
+		return nv50_miptree_from_handle(screen, template, whandle);
+}
+
+void
+nv50_init_resource_functions(struct pipe_context *pcontext)
+{
+	pcontext->get_transfer = u_get_transfer_vtbl;
+	pcontext->transfer_map = u_transfer_map_vtbl;
+	pcontext->transfer_flush_region = u_transfer_flush_region_vtbl;
+	pcontext->transfer_unmap = u_transfer_unmap_vtbl;
+	pcontext->transfer_destroy = u_transfer_destroy_vtbl;
+	pcontext->transfer_inline_write = u_transfer_inline_write_vtbl;
+	pcontext->is_resource_referenced = nv50_resource_is_referenced;
+}
+
+void
+nv50_screen_init_resource_functions(struct pipe_screen *pscreen)
+{
+	pscreen->resource_create = nv50_resource_create;
+	pscreen->resource_from_handle = nv50_resource_from_handle;
+	pscreen->resource_get_handle = u_resource_get_handle_vtbl;
+	pscreen->resource_destroy = u_resource_destroy_vtbl;
+	pscreen->user_buffer_create = nv50_user_buffer_create;
+   
+	pscreen->get_tex_surface = nv50_miptree_surface_new;
+	pscreen->tex_surface_destroy = nv50_miptree_surface_del;
+}
diff --git a/src/gallium/drivers/nv50/nv50_resource.h b/src/gallium/drivers/nv50/nv50_resource.h
new file mode 100644
index 00000000000..6cf7662124b
--- /dev/null
+++ b/src/gallium/drivers/nv50/nv50_resource.h
@@ -0,0 +1,90 @@
+
+#ifndef NV50_RESOURCE_H
+#define NV50_RESOURCE_H
+
+#include "util/u_transfer.h"
+
+struct pipe_resource;
+struct nouveau_bo;
+
+
+/* This gets further specialized into either buffer or texture
+ * structures.  In the future we'll want to remove much of that
+ * distinction, but for now try to keep as close to the existing code
+ * as possible and use the vtbl struct to choose between the two
+ * underlying implementations.
+ */
+struct nv50_resource {
+	struct pipe_resource base;
+	const struct u_resource_vtbl *vtbl;
+	struct nouveau_bo *bo;
+};
+
+struct nv50_miptree_level {
+	int *image_offset;
+	unsigned pitch;
+	unsigned tile_mode;
+};
+
+#define NV50_MAX_TEXTURE_LEVELS 16
+
+struct nv50_miptree {
+	struct nv50_resource base;
+
+	struct nv50_miptree_level level[NV50_MAX_TEXTURE_LEVELS];
+	int image_nr;
+	int total_size;
+};
+
+static INLINE struct nv50_miptree *
+nv50_miptree(struct pipe_resource *pt)
+{
+	return (struct nv50_miptree *)pt;
+}
+
+
+static INLINE 
+struct nv50_resource *nv50_resource(struct pipe_resource *resource)
+{
+	return (struct nv50_resource *)resource;
+}
+
+
+void
+nv50_init_resource_functions(struct pipe_context *pcontext);
+
+void
+nv50_screen_init_resource_functions(struct pipe_screen *pscreen);
+
+/* Internal functions
+ */
+struct pipe_resource *
+nv50_miptree_create(struct pipe_screen *pscreen,
+		    const struct pipe_resource *tmp);
+
+struct pipe_resource *
+nv50_miptree_from_handle(struct pipe_screen *pscreen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle);
+
+struct pipe_resource *
+nv50_buffer_create(struct pipe_screen *pscreen,
+		   const struct pipe_resource *template);
+
+struct pipe_resource *
+nv50_user_buffer_create(struct pipe_screen *screen,
+			void *ptr,
+			unsigned bytes,
+			unsigned usage);
+
+
+struct pipe_surface *
+nv50_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_resource *pt,
+			 unsigned face, unsigned level, unsigned zslice,
+			 unsigned flags);
+
+void
+nv50_miptree_surface_del(struct pipe_surface *ps);
+
+
+#endif
diff --git a/src/gallium/drivers/nv50/nv50_screen.c b/src/gallium/drivers/nv50/nv50_screen.c
index 801548d8a1b..7a831143f0f 100644
--- a/src/gallium/drivers/nv50/nv50_screen.c
+++ b/src/gallium/drivers/nv50/nv50_screen.c
@@ -24,6 +24,7 @@
 
 #include "nv50_context.h"
 #include "nv50_screen.h"
+#include "nv50_resource.h"
 
 #include "nouveau/nouveau_stateobj.h"
 
@@ -33,7 +34,7 @@ nv50_screen_is_format_supported(struct pipe_screen *pscreen,
 				enum pipe_texture_target target,
 				unsigned tex_usage, unsigned geom_flags)
 {
-	if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET) {
+	if (tex_usage & PIPE_BIND_RENDER_TARGET) {
 		switch (format) {
 		case PIPE_FORMAT_B8G8R8X8_UNORM:
 		case PIPE_FORMAT_B8G8R8A8_UNORM:
@@ -48,7 +49,7 @@ nv50_screen_is_format_supported(struct pipe_screen *pscreen,
 			break;
 		}
 	} else
-	if (tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL) {
+	if (tex_usage & PIPE_BIND_DEPTH_STENCIL) {
 		switch (format) {
 		case PIPE_FORMAT_Z32_FLOAT:
 		case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
@@ -133,10 +134,6 @@ nv50_screen_get_param(struct pipe_screen *pscreen, int param)
 		return 1;
 	case PIPE_CAP_BLEND_EQUATION_SEPARATE:
 		return 1;
-	case NOUVEAU_CAP_HW_VTXBUF:
-		return screen->force_push ? 0 : 1;
-	case NOUVEAU_CAP_HW_IDXBUF:
-		return screen->force_push ? 0 : 1;
 	case PIPE_CAP_INDEP_BLEND_ENABLE:
 		return 1;
 	case PIPE_CAP_INDEP_BLEND_FUNC:
@@ -280,7 +277,7 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_device *dev)
 	pscreen->is_format_supported = nv50_screen_is_format_supported;
 	pscreen->context_create = nv50_create;
 
-	nv50_screen_init_miptree_functions(pscreen);
+	nv50_screen_init_resource_functions(pscreen);
 
 	/* DMA engine object */
 	ret = nouveau_grobj_alloc(chan, 0xbeef5039,
@@ -334,6 +331,9 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_device *dev)
 		return NULL;
 	}
 
+	/* this is necessary for the new RING_3D / statebuffer code */
+	BIND_RING(chan, screen->tesla, 7);
+
 	/* Sync notifier */
 	ret = nouveau_notifier_alloc(chan, 0xbeef0301, 1, &screen->sync);
 	if (ret) {
@@ -379,8 +379,8 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_device *dev)
 	OUT_RING  (chan, 1);
 
 	/* activate all 32 lanes (threads) in a warp */
-	BEGIN_RING(chan, screen->tesla, NV50TCL_WARP_HALVES, 1);
-	OUT_RING  (chan, 2);
+	BEGIN_RING(chan, screen->tesla, NV50TCL_REG_MODE, 1);
+	OUT_RING  (chan, NV50TCL_REG_MODE_STRIPED);
 	BEGIN_RING(chan, screen->tesla, 0x1400, 1);
 	OUT_RING  (chan, 0xf);
 
@@ -497,6 +497,8 @@ nv50_screen_create(struct pipe_winsys *ws, struct nouveau_device *dev)
 	FIRE_RING (chan);
 
 	screen->force_push = debug_get_bool_option("NV50_ALWAYS_PUSH", FALSE);
+	if(!screen->force_push)
+		screen->base.vertex_buffer_flags = screen->base.index_buffer_flags = NOUVEAU_BO_GART;
 	return pscreen;
 }
 
diff --git a/src/gallium/drivers/nv50/nv50_screen.h b/src/gallium/drivers/nv50/nv50_screen.h
index 15bd4eed399..092333a3b10 100644
--- a/src/gallium/drivers/nv50/nv50_screen.h
+++ b/src/gallium/drivers/nv50/nv50_screen.h
@@ -22,7 +22,7 @@ struct nv50_screen {
 	struct nouveau_resource *immd_heap[1];
 	struct nouveau_resource *parm_heap[PIPE_SHADER_TYPES];
 
-	struct pipe_buffer *strm_vbuf[16];
+	struct pipe_resource *strm_vbuf[16];
 
 	struct nouveau_bo *tic;
 	struct nouveau_bo *tsc;
diff --git a/src/gallium/drivers/nv50/nv50_state.c b/src/gallium/drivers/nv50/nv50_state.c
index c1628089285..e885a2b7196 100644
--- a/src/gallium/drivers/nv50/nv50_state.c
+++ b/src/gallium/drivers/nv50/nv50_state.c
@@ -310,13 +310,13 @@ static void
 nv50_sampler_view_destroy(struct pipe_context *pipe,
 			  struct pipe_sampler_view *view)
 {
-	pipe_texture_reference(&view->texture, NULL);
+	pipe_resource_reference(&view->texture, NULL);
 	FREE(nv50_sampler_view(view));
 }
 
 static struct pipe_sampler_view *
 nv50_create_sampler_view(struct pipe_context *pipe,
-			 struct pipe_texture *texture,
+			 struct pipe_resource *texture,
 			 const struct pipe_sampler_view *templ)
 {
 	struct nv50_sampler_view *view = CALLOC_STRUCT(nv50_sampler_view);
@@ -324,7 +324,7 @@ nv50_create_sampler_view(struct pipe_context *pipe,
 	view->pipe = *templ;
 	view->pipe.reference.count = 1;
 	view->pipe.texture = NULL;
-	pipe_texture_reference(&view->pipe.texture, texture);
+	pipe_resource_reference(&view->pipe.texture, texture);
 	view->pipe.context = pipe;
 
 	if (!nv50_tex_construct(view)) {
@@ -690,7 +690,7 @@ nv50_set_clip_state(struct pipe_context *pipe,
 
 static void
 nv50_set_constant_buffer(struct pipe_context *pipe, uint shader, uint index,
-			 struct pipe_buffer *buf )
+			 struct pipe_resource *buf )
 {
 	struct nv50_context *nv50 = nv50_context(pipe);
 
diff --git a/src/gallium/drivers/nv50/nv50_state_validate.c b/src/gallium/drivers/nv50/nv50_state_validate.c
index 402045416c6..a4deb56ffc8 100644
--- a/src/gallium/drivers/nv50/nv50_state_validate.c
+++ b/src/gallium/drivers/nv50/nv50_state_validate.c
@@ -23,6 +23,7 @@
 #include "util/u_format.h"
 
 #include "nv50_context.h"
+#include "nv50_resource.h"
 #include "nouveau/nouveau_stateobj.h"
 
 static struct nouveau_stateobj *
@@ -43,7 +44,7 @@ validate_fb(struct nv50_context *nv50)
 		  (4 << 16) | (5 << 19) | (6 << 22) | (7 << 25));
 
 	for (i = 0; i < fb->nr_cbufs; i++) {
-		struct pipe_texture *pt = fb->cbufs[i]->texture;
+		struct pipe_resource *pt = fb->cbufs[i]->texture;
 		struct nouveau_bo *bo = nv50_miptree(pt)->base.bo;
 
 		if (!gw) {
@@ -104,7 +105,7 @@ validate_fb(struct nv50_context *nv50)
 	}
 
 	if (fb->zsbuf) {
-		struct pipe_texture *pt = fb->zsbuf->texture;
+		struct pipe_resource *pt = fb->zsbuf->texture;
 		struct nouveau_bo *bo = nv50_miptree(pt)->base.bo;
 
 		if (!gw) {
diff --git a/src/gallium/drivers/nv50/nv50_surface.c b/src/gallium/drivers/nv50/nv50_surface.c
index 7a9dada531b..c2d9e835260 100644
--- a/src/gallium/drivers/nv50/nv50_surface.c
+++ b/src/gallium/drivers/nv50/nv50_surface.c
@@ -24,6 +24,7 @@
 #include <stdint.h>
 #include "nouveau/nouveau_pushbuf.h"
 #include "nv50_context.h"
+#include "nv50_resource.h"
 #include "pipe/p_defines.h"
 #include "util/u_inlines.h"
 
diff --git a/src/gallium/drivers/nv50/nv50_tex.c b/src/gallium/drivers/nv50/nv50_tex.c
index d094b490edb..5ea0c1d7264 100644
--- a/src/gallium/drivers/nv50/nv50_tex.c
+++ b/src/gallium/drivers/nv50/nv50_tex.c
@@ -22,6 +22,7 @@
 
 #include "nv50_context.h"
 #include "nv50_texture.h"
+#include "nv50_resource.h"
 
 #include "nouveau/nouveau_stateobj.h"
 #include "nouveau/nouveau_reloc.h"
@@ -182,8 +183,10 @@ nv50_validate_textures(struct nv50_context *nv50, struct nouveau_stateobj *so,
 			struct nv50_miptree *mt =
 				nv50_miptree(view->pipe.texture);
 
+			tic2 &= ~NV50TIC_0_2_NORMALIZED_COORDS;
 			if (nv50->sampler[p][unit]->normalized)
 				tic2 |= NV50TIC_0_2_NORMALIZED_COORDS;
+			view->tic[2] = tic2;
 
 			so_data  (so, view->tic[0]);
 			so_reloc (so, mt->base.bo, 0, rll, 0, 0);
@@ -213,37 +216,39 @@ nv50_validate_textures(struct nv50_context *nv50, struct nouveau_stateobj *so,
 	return TRUE;
 }
 
-void
-nv50_tex_relocs(struct nv50_context *nv50)
+static void
+nv50_emit_texture_relocs(struct nv50_context *nv50, int prog)
 {
-	struct nouveau_channel *chan = nv50->screen->tesla->channel;
-	int p, unit;
+	struct nouveau_channel *chan = nv50->screen->base.channel;
+	struct nouveau_bo *tic = nv50->screen->tic;
+	int unit;
 
-	p = PIPE_SHADER_FRAGMENT;
-	for (unit = 0; unit < nv50->sampler_view_nr[p]; unit++) {
-		struct pipe_sampler_view *view = nv50->sampler_views[p][unit];
-		if (!view)
-			continue;
-		nouveau_reloc_emit(chan, nv50->screen->tic,
-				   ((p * 32) + unit) * 32, NULL,
-				   nv50_miptree(view->texture)->base.bo, 0, 0,
-				   NOUVEAU_BO_VRAM | NOUVEAU_BO_LOW |
-				   NOUVEAU_BO_RD, 0, 0);
-	}
+	for (unit = 0; unit < nv50->sampler_view_nr[prog]; unit++) {
+		struct nv50_sampler_view *view;
+		struct nv50_miptree *mt;
+		const unsigned base = ((prog * 32) + unit) * 32;
 
-	p = PIPE_SHADER_VERTEX;
-	for (unit = 0; unit < nv50->sampler_view_nr[p]; unit++) {
-		struct pipe_sampler_view *view = nv50->sampler_views[p][unit];
+		view = nv50_sampler_view(nv50->sampler_views[prog][unit]);
 		if (!view)
 			continue;
-		nouveau_reloc_emit(chan, nv50->screen->tic,
-				   ((p * 32) + unit) * 32, NULL,
-				   nv50_miptree(view->texture)->base.bo, 0, 0,
-				   NOUVEAU_BO_VRAM | NOUVEAU_BO_LOW |
-				   NOUVEAU_BO_RD, 0, 0);
+		mt = nv50_miptree(view->pipe.texture);
+
+		nouveau_reloc_emit(chan, tic, base + 4, NULL, mt->base.bo, 0, 0,
+				   NOUVEAU_BO_VRAM | NOUVEAU_BO_RD |
+				   NOUVEAU_BO_LOW, 0, 0);
+		nouveau_reloc_emit(chan, tic, base + 8, NULL, mt->base.bo, 0, 0,
+				   NOUVEAU_BO_VRAM | NOUVEAU_BO_RD |
+				   NOUVEAU_BO_HIGH, view->tic[2], view->tic[2]);
 	}
 }
 
+void
+nv50_tex_relocs(struct nv50_context *nv50)
+{
+	nv50_emit_texture_relocs(nv50, 2); /* FP */
+	nv50_emit_texture_relocs(nv50, 0); /* VP */
+}
+
 struct nouveau_stateobj *
 nv50_tex_validate(struct nv50_context *nv50)
 {
diff --git a/src/gallium/drivers/nv50/nv50_transfer.c b/src/gallium/drivers/nv50/nv50_transfer.c
index 9eb223eca65..9fefed4fef9 100644
--- a/src/gallium/drivers/nv50/nv50_transfer.c
+++ b/src/gallium/drivers/nv50/nv50_transfer.c
@@ -5,10 +5,13 @@
 #include "util/u_math.h"
 
 #include "nv50_context.h"
+#include "nv50_transfer.h"
+#include "nv50_resource.h"
 
 struct nv50_transfer {
 	struct pipe_transfer base;
 	struct nouveau_bo *bo;
+	int map_refcnt;
 	unsigned level_offset;
 	unsigned level_tiling;
 	int level_pitch;
@@ -120,44 +123,51 @@ nv50_transfer_rect_m2mf(struct pipe_screen *pscreen,
 	}
 }
 
-static struct pipe_transfer *
-nv50_transfer_new(struct pipe_context *pcontext, struct pipe_texture *pt,
-		  unsigned face, unsigned level, unsigned zslice,
-		  enum pipe_transfer_usage usage,
-		  unsigned x, unsigned y, unsigned w, unsigned h)
+struct pipe_transfer *
+nv50_miptree_transfer_new(struct pipe_context *pcontext,
+			  struct pipe_resource *pt,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box)
 {
         struct pipe_screen *pscreen = pcontext->screen;
 	struct nouveau_device *dev = nouveau_screen(pscreen)->device;
 	struct nv50_miptree *mt = nv50_miptree(pt);
-	struct nv50_miptree_level *lvl = &mt->level[level];
+	struct nv50_miptree_level *lvl = &mt->level[sr.level];
 	struct nv50_transfer *tx;
 	unsigned nx, ny, image = 0;
 	int ret;
 
 	if (pt->target == PIPE_TEXTURE_CUBE)
-		image = face;
+		image = sr.face;
 
 	tx = CALLOC_STRUCT(nv50_transfer);
 	if (!tx)
 		return NULL;
 
-	pipe_texture_reference(&tx->base.texture, pt);
-	tx->nblocksx = util_format_get_nblocksx(pt->format, u_minify(pt->width0, level));
-	tx->nblocksy = util_format_get_nblocksy(pt->format, u_minify(pt->height0, level));
-	tx->base.width = w;
-	tx->base.height = h;
+	/* Don't handle 3D transfers yet.
+	 */
+	assert(box->depth == 1);
+
+
+	pipe_resource_reference(&tx->base.resource, pt);
+	tx->base.sr = sr;
+	tx->base.usage = usage;
+	tx->base.box = *box;
+	tx->nblocksx = util_format_get_nblocksx(pt->format, u_minify(pt->width0, sr.level));
+	tx->nblocksy = util_format_get_nblocksy(pt->format, u_minify(pt->height0, sr.level));
 	tx->base.stride = tx->nblocksx * util_format_get_blocksize(pt->format);
 	tx->base.usage = usage;
 
 	tx->level_pitch = lvl->pitch;
-	tx->level_width = u_minify(mt->base.base.width0, level);
-	tx->level_height = u_minify(mt->base.base.height0, level);
-	tx->level_depth = u_minify(mt->base.base.depth0, level);
+	tx->level_width = u_minify(mt->base.base.width0, sr.level);
+	tx->level_height = u_minify(mt->base.base.height0, sr.level);
+	tx->level_depth = u_minify(mt->base.base.depth0, sr.level);
 	tx->level_offset = lvl->image_offset[image];
 	tx->level_tiling = lvl->tile_mode;
-	tx->level_z = zslice;
-	tx->level_x = util_format_get_nblocksx(pt->format, x);
-	tx->level_y = util_format_get_nblocksy(pt->format, y);
+	tx->level_z = box->z;
+	tx->level_x = util_format_get_nblocksx(pt->format, box->x);
+	tx->level_y = util_format_get_nblocksy(pt->format, box->y);
 	ret = nouveau_bo_new(dev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0,
 			     tx->nblocksy * tx->base.stride, &tx->bo);
 	if (ret) {
@@ -166,12 +176,12 @@ nv50_transfer_new(struct pipe_context *pcontext, struct pipe_texture *pt,
 	}
 
 	if (usage & PIPE_TRANSFER_READ) {
-		nx = util_format_get_nblocksx(pt->format, tx->base.width);
-		ny = util_format_get_nblocksy(pt->format, tx->base.height);
+		nx = util_format_get_nblocksx(pt->format, box->width);
+		ny = util_format_get_nblocksy(pt->format, box->height);
 
 		nv50_transfer_rect_m2mf(pscreen, mt->base.bo, tx->level_offset,
 					tx->level_pitch, tx->level_tiling,
-					x, y, zslice,
+					box->x, box->y, box->z,
 					tx->nblocksx, tx->nblocksy,
 					tx->level_depth,
 					tx->bo, 0,
@@ -186,15 +196,16 @@ nv50_transfer_new(struct pipe_context *pcontext, struct pipe_texture *pt,
 	return &tx->base;
 }
 
-static void
-nv50_transfer_del(struct pipe_context *pcontext, struct pipe_transfer *ptx)
+void
+nv50_miptree_transfer_del(struct pipe_context *pcontext,
+			  struct pipe_transfer *ptx)
 {
 	struct nv50_transfer *tx = (struct nv50_transfer *)ptx;
-	struct nv50_miptree *mt = nv50_miptree(ptx->texture);
-	struct pipe_texture *pt = ptx->texture;
+	struct nv50_miptree *mt = nv50_miptree(ptx->resource);
+	struct pipe_resource *pt = ptx->resource;
 
-	unsigned nx = util_format_get_nblocksx(pt->format, tx->base.width);
-	unsigned ny = util_format_get_nblocksy(pt->format, tx->base.height);
+	unsigned nx = util_format_get_nblocksx(pt->format, tx->base.box.width);
+	unsigned ny = util_format_get_nblocksy(pt->format, tx->base.box.height);
 
 	if (ptx->usage & PIPE_TRANSFER_WRITE) {
 		struct pipe_screen *pscreen = pcontext->screen;
@@ -214,44 +225,45 @@ nv50_transfer_del(struct pipe_context *pcontext, struct pipe_transfer *ptx)
 	}
 
 	nouveau_bo_ref(NULL, &tx->bo);
-	pipe_texture_reference(&ptx->texture, NULL);
+	pipe_resource_reference(&ptx->resource, NULL);
 	FREE(ptx);
 }
 
-static void *
-nv50_transfer_map(struct pipe_context *pcontext, struct pipe_transfer *ptx)
+void *
+nv50_miptree_transfer_map(struct pipe_context *pcontext,
+			  struct pipe_transfer *ptx)
 {
 	struct nv50_transfer *tx = (struct nv50_transfer *)ptx;
 	unsigned flags = 0;
 	int ret;
 
+	if (tx->map_refcnt++)
+		return tx->bo->map;
+
 	if (ptx->usage & PIPE_TRANSFER_WRITE)
 		flags |= NOUVEAU_BO_WR;
 	if (ptx->usage & PIPE_TRANSFER_READ)
 		flags |= NOUVEAU_BO_RD;
 
 	ret = nouveau_bo_map(tx->bo, flags);
-	if (ret)
+	if (ret) {
+		tx->map_refcnt = 0;
 		return NULL;
+	}
 	return tx->bo->map;
 }
 
-static void
-nv50_transfer_unmap(struct pipe_context *pcontext, struct pipe_transfer *ptx)
+void
+nv50_miptree_transfer_unmap(struct pipe_context *pcontext,
+			    struct pipe_transfer *ptx)
 {
 	struct nv50_transfer *tx = (struct nv50_transfer *)ptx;
 
+	if (--tx->map_refcnt)
+		return;
 	nouveau_bo_unmap(tx->bo);
 }
 
-void
-nv50_init_transfer_functions(struct nv50_context *nv50)
-{
-	nv50->pipe.get_tex_transfer = nv50_transfer_new;
-	nv50->pipe.tex_transfer_destroy = nv50_transfer_del;
-	nv50->pipe.transfer_map = nv50_transfer_map;
-	nv50->pipe.transfer_unmap = nv50_transfer_unmap;
-}
 
 void
 nv50_upload_sifc(struct nv50_context *nv50,
diff --git a/src/gallium/drivers/nv50/nv50_transfer.h b/src/gallium/drivers/nv50/nv50_transfer.h
new file mode 100644
index 00000000000..663503547cb
--- /dev/null
+++ b/src/gallium/drivers/nv50/nv50_transfer.h
@@ -0,0 +1,31 @@
+
+#ifndef NV50_TRANSFER_H
+#define NV50_TRANSFER_H
+
+#include "pipe/p_state.h"
+
+
+struct pipe_transfer *
+nv50_miptree_transfer_new(struct pipe_context *pcontext,
+			  struct pipe_resource *pt,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box);
+void
+nv50_miptree_transfer_del(struct pipe_context *pcontext,
+			  struct pipe_transfer *ptx);
+void *
+nv50_miptree_transfer_map(struct pipe_context *pcontext,
+			  struct pipe_transfer *ptx);
+void
+nv50_miptree_transfer_unmap(struct pipe_context *pcontext,
+			    struct pipe_transfer *ptx);
+
+extern void
+nv50_upload_sifc(struct nv50_context *nv50,
+		 struct nouveau_bo *bo, unsigned dst_offset, unsigned reloc,
+		 unsigned dst_format, int dst_w, int dst_h, int dst_pitch,
+		 void *src, unsigned src_format, int src_pitch,
+		 int x, int y, int w, int h, int cpp);
+
+#endif
diff --git a/src/gallium/drivers/nv50/nv50_vbo.c b/src/gallium/drivers/nv50/nv50_vbo.c
index 50472868063..609145db88a 100644
--- a/src/gallium/drivers/nv50/nv50_vbo.c
+++ b/src/gallium/drivers/nv50/nv50_vbo.c
@@ -27,6 +27,7 @@
 
 #include "nouveau/nouveau_util.h"
 #include "nv50_context.h"
+#include "nv50_resource.h"
 
 static INLINE uint32_t
 nv50_vbo_type_to_hw(enum pipe_format format)
@@ -139,7 +140,7 @@ instance_init(struct nv50_context *nv50, struct instance *a, unsigned first)
 		if (a[i].divisor) {
 			vb = &nv50->vtxbuf[ve->vertex_buffer_index];
 
-			a[i].bo = nouveau_bo(vb->buffer);
+			a[i].bo = nv50_resource(vb->buffer)->bo;
 			a[i].stride = vb->stride;
 			a[i].step = first % a[i].divisor;
 			a[i].delta = vb->buffer_offset + ve->src_offset +
@@ -307,14 +308,14 @@ inline_edgeflag(void *priv, boolean enabled)
 
 static void
 nv50_draw_elements_inline(struct pipe_context *pipe,
-			  struct pipe_buffer *indexBuffer, unsigned indexSize,
+			  struct pipe_resource *indexBuffer, unsigned indexSize,
 			  unsigned mode, unsigned start, unsigned count,
 			  unsigned startInstance, unsigned instanceCount)
 {
-	struct pipe_screen *pscreen = pipe->screen;
 	struct nv50_context *nv50 = nv50_context(pipe);
 	struct nouveau_channel *chan = nv50->screen->tesla->channel;
 	struct nouveau_grobj *tesla = nv50->screen->tesla;
+	struct pipe_transfer *transfer;
 	struct instance a[16];
 	struct inline_ctx ctx;
 	struct u_split_prim s;
@@ -337,7 +338,7 @@ nv50_draw_elements_inline(struct pipe_context *pipe,
 	s.edge = inline_edgeflag;
 
 	ctx.nv50 = nv50;
-	ctx.map = pipe_buffer_map(pscreen, indexBuffer, PIPE_BUFFER_USAGE_CPU_READ);
+	ctx.map = pipe_buffer_map(pipe, indexBuffer, PIPE_TRANSFER_READ, &transfer);
 	assert(ctx.map);
 	if (!ctx.map)
 		return;
@@ -380,12 +381,12 @@ nv50_draw_elements_inline(struct pipe_context *pipe,
 		nzi = TRUE;
 	}
 
-	pipe_buffer_unmap(pscreen, indexBuffer);
+	pipe_buffer_unmap(pipe, indexBuffer, transfer);
 }
 
 void
 nv50_draw_elements_instanced(struct pipe_context *pipe,
-			     struct pipe_buffer *indexBuffer,
+			     struct pipe_resource *indexBuffer,
 			     unsigned indexSize,
 			     unsigned mode, unsigned start, unsigned count,
 			     unsigned startInstance, unsigned instanceCount)
@@ -406,7 +407,7 @@ nv50_draw_elements_instanced(struct pipe_context *pipe,
 					     instanceCount);
 		return;
 	} else
-	if (!(indexBuffer->usage & PIPE_BUFFER_USAGE_INDEX) || indexSize == 1) {
+	if (!(indexBuffer->bind & PIPE_BIND_INDEX_BUFFER) || indexSize == 1) {
 		nv50_draw_elements_inline(pipe, indexBuffer, indexSize,
 					  mode, start, count, startInstance,
 					  instanceCount);
@@ -431,7 +432,8 @@ nv50_draw_elements_instanced(struct pipe_context *pipe,
 		if (indexSize == 4) {
 			BEGIN_RING(chan, tesla, NV50TCL_VB_ELEMENT_U32 | 0x30000, 0);
 			OUT_RING  (chan, count);
-			nouveau_pushbuf_submit(chan, nouveau_bo(indexBuffer),
+			nouveau_pushbuf_submit(chan, 
+					       nv50_resource(indexBuffer)->bo,
 					       start << 2, count << 2);
 		} else
 		if (indexSize == 2) {
@@ -443,7 +445,8 @@ nv50_draw_elements_instanced(struct pipe_context *pipe,
 			OUT_RING  (chan, ((start & 1) << 31) | count);
 			BEGIN_RING(chan, tesla, NV50TCL_VB_ELEMENT_U16 | 0x30000, 0);
 			OUT_RING  (chan, dwords);
-			nouveau_pushbuf_submit(chan, nouveau_bo(indexBuffer),
+			nouveau_pushbuf_submit(chan,
+					       nv50_resource(indexBuffer)->bo,
 					       vb_start << 1, dwords << 2);
 			BEGIN_RING(chan, tesla, NV50TCL_VB_ELEMENT_U16_SETUP, 1);
 			OUT_RING  (chan, 0);
@@ -457,7 +460,7 @@ nv50_draw_elements_instanced(struct pipe_context *pipe,
 
 void
 nv50_draw_elements(struct pipe_context *pipe,
-		   struct pipe_buffer *indexBuffer, unsigned indexSize,
+		   struct pipe_resource *indexBuffer, unsigned indexSize,
 		   unsigned mode, unsigned start, unsigned count)
 {
 	nv50_draw_elements_instanced(pipe, indexBuffer, indexSize,
@@ -473,7 +476,7 @@ nv50_vbo_static_attrib(struct nv50_context *nv50, unsigned attrib,
 {
 	struct nouveau_stateobj *so;
 	struct nouveau_grobj *tesla = nv50->screen->tesla;
-	struct nouveau_bo *bo = nouveau_bo(vb->buffer);
+	struct nouveau_bo *bo = nv50_resource(vb->buffer)->bo;
 	float v[4];
 	int ret;
 	unsigned nr_components = util_format_get_nr_components(ve->src_format);
@@ -556,7 +559,7 @@ nv50_vbo_validate(struct nv50_context *nv50)
 
 	for (i = 0; i < nv50->vtxbuf_nr; i++) {
 		if (nv50->vtxbuf[i].stride &&
-		    !(nv50->vtxbuf[i].buffer->usage & PIPE_BUFFER_USAGE_VERTEX))
+		    !(nv50->vtxbuf[i].buffer->bind & PIPE_BIND_VERTEX_BUFFER))
 			nv50->vbo_fifo = 0xffff;
 	}
 
@@ -571,7 +574,7 @@ nv50_vbo_validate(struct nv50_context *nv50)
 		struct pipe_vertex_element *ve = &nv50->vtxelt->pipe[i];
 		struct pipe_vertex_buffer *vb =
 			&nv50->vtxbuf[ve->vertex_buffer_index];
-		struct nouveau_bo *bo = nouveau_bo(vb->buffer);
+		struct nouveau_bo *bo = nv50_resource(vb->buffer)->bo;
 		uint32_t hw = nv50->vtxelt->hw[i];
 
 		if (!vb->stride &&
@@ -608,10 +611,10 @@ nv50_vbo_validate(struct nv50_context *nv50)
 
 		/* vertex array limits */
 		so_method(vtxbuf, tesla, NV50TCL_VERTEX_ARRAY_LIMIT_HIGH(i), 2);
-		so_reloc (vtxbuf, bo, vb->buffer->size - 1,
+		so_reloc (vtxbuf, bo, vb->buffer->width0 - 1,
 			  NOUVEAU_BO_VRAM | NOUVEAU_BO_GART | NOUVEAU_BO_RD |
 			  NOUVEAU_BO_HIGH, 0, 0);
-		so_reloc (vtxbuf, bo, vb->buffer->size - 1,
+		so_reloc (vtxbuf, bo, vb->buffer->width0 - 1,
 			  NOUVEAU_BO_VRAM | NOUVEAU_BO_GART | NOUVEAU_BO_RD |
 			  NOUVEAU_BO_LOW, 0, 0);
 	}
diff --git a/src/gallium/drivers/nvfx/Makefile b/src/gallium/drivers/nvfx/Makefile
index dfe97e6ed5f..c1d57ca3969 100644
--- a/src/gallium/drivers/nvfx/Makefile
+++ b/src/gallium/drivers/nvfx/Makefile
@@ -5,6 +5,7 @@ LIBNAME = nvfx
 
 C_SOURCES = \
 	nv04_surface_2d.c \
+	nvfx_buffer.c \
 	nvfx_context.c \
 	nvfx_clear.c \
 	nvfx_draw.c \
@@ -14,6 +15,7 @@ C_SOURCES = \
 	nv40_fragtex.c \
 	nvfx_miptree.c \
 	nvfx_query.c \
+	nvfx_resource.c \
 	nvfx_screen.c \
 	nvfx_state.c \
 	nvfx_state_blend.c \
@@ -29,4 +31,7 @@ C_SOURCES = \
 	nvfx_vbo.c \
 	nvfx_vertprog.c
 
+LIBRARY_INCLUDES = \
+	-I$(TOP)/src/gallium/drivers/nouveau/include
+
 include ../../Makefile.template
diff --git a/src/gallium/drivers/nvfx/nv04_surface_2d.c b/src/gallium/drivers/nvfx/nv04_surface_2d.c
index 6784170c00e..22cfa0ecefa 100644
--- a/src/gallium/drivers/nvfx/nv04_surface_2d.c
+++ b/src/gallium/drivers/nvfx/nv04_surface_2d.c
@@ -125,8 +125,8 @@ nv04_surface_copy_swizzle(struct nv04_surface_2d *ctx,
 	struct nouveau_channel *chan = ctx->swzsurf->channel;
 	struct nouveau_grobj *swzsurf = ctx->swzsurf;
 	struct nouveau_grobj *sifm = ctx->sifm;
-	struct nouveau_bo *src_bo = nouveau_bo(ctx->buf(src));
-	struct nouveau_bo *dst_bo = nouveau_bo(ctx->buf(dst));
+	struct nouveau_bo *src_bo = ctx->buf(src);
+	struct nouveau_bo *dst_bo = ctx->buf(dst);
 	const unsigned src_pitch = ((struct nv04_surface *)src)->pitch;
         /* Max width & height may not be the same on all HW, but must be POT */
 	const unsigned max_w = 1024;
@@ -148,7 +148,7 @@ nv04_surface_copy_swizzle(struct nv04_surface_2d *ctx,
 
 	BEGIN_RING(chan, swzsurf, NV04_SWIZZLED_SURFACE_DMA_IMAGE, 1);
 	OUT_RELOCo(chan, dst_bo,
-	                 NOUVEAU_BO_GART | NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
+	                 NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 
 	BEGIN_RING(chan, swzsurf, NV04_SWIZZLED_SURFACE_FORMAT, 1);
 	OUT_RING  (chan, nv04_surface_format(dst->format) |
@@ -171,7 +171,7 @@ nv04_surface_copy_swizzle(struct nv04_surface_2d *ctx,
 
 	    BEGIN_RING(chan, swzsurf, NV04_SWIZZLED_SURFACE_OFFSET, 1);
 	    OUT_RELOCl(chan, dst_bo, dst->offset,
-                             NOUVEAU_BO_GART | NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
+                             NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
 
 	    BEGIN_RING(chan, sifm, NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION, 9);
 	    OUT_RING  (chan, NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_TRUNCATE);
@@ -205,8 +205,8 @@ nv04_surface_copy_m2mf(struct nv04_surface_2d *ctx,
 {
 	struct nouveau_channel *chan = ctx->m2mf->channel;
 	struct nouveau_grobj *m2mf = ctx->m2mf;
-	struct nouveau_bo *src_bo = nouveau_bo(ctx->buf(src));
-	struct nouveau_bo *dst_bo = nouveau_bo(ctx->buf(dst));
+	struct nouveau_bo *src_bo = ctx->buf(src);
+	struct nouveau_bo *dst_bo = ctx->buf(dst);
 	unsigned src_pitch = ((struct nv04_surface *)src)->pitch;
 	unsigned dst_pitch = ((struct nv04_surface *)dst)->pitch;
 	unsigned dst_offset = dst->offset + dy * dst_pitch +
@@ -252,8 +252,8 @@ nv04_surface_copy_blit(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
 	struct nouveau_channel *chan = ctx->surf2d->channel;
 	struct nouveau_grobj *surf2d = ctx->surf2d;
 	struct nouveau_grobj *blit = ctx->blit;
-	struct nouveau_bo *src_bo = nouveau_bo(ctx->buf(src));
-	struct nouveau_bo *dst_bo = nouveau_bo(ctx->buf(dst));
+	struct nouveau_bo *src_bo = ctx->buf(src);
+	struct nouveau_bo *dst_bo = ctx->buf(dst);
 	unsigned src_pitch = ((struct nv04_surface *)src)->pitch;
 	unsigned dst_pitch = ((struct nv04_surface *)dst)->pitch;
 	int format;
@@ -287,8 +287,8 @@ nv04_surface_copy(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
 {
 	unsigned src_pitch = ((struct nv04_surface *)src)->pitch;
 	unsigned dst_pitch = ((struct nv04_surface *)dst)->pitch;
-	int src_linear = src->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR;
-	int dst_linear = dst->texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR;
+	int src_linear = src->texture->flags & NVFX_RESOURCE_FLAG_LINEAR;
+	int dst_linear = dst->texture->flags & NVFX_RESOURCE_FLAG_LINEAR;
 
 	assert(src->format == dst->format);
 
@@ -298,16 +298,11 @@ nv04_surface_copy(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
            return;
         }
 
-	/* NV_CONTEXT_SURFACES_2D has buffer alignment restrictions, fallback
-	 * to NV_MEMORY_TO_MEMORY_FORMAT in this case.
-	 */
-	if ((src->offset & 63) || (dst->offset & 63) ||
-	    (src_pitch & 63) || (dst_pitch & 63)) {
-		nv04_surface_copy_m2mf(ctx, dst, dx, dy, src, sx, sy, w, h);
-		return;
-	}
-
-	nv04_surface_copy_blit(ctx, dst, dx, dy, src, sx, sy, w, h);
+        /* Use M2MF instead of the blitter since it always works
+         * Any possible performance drop is likely to be not very significant
+         * and dwarfed anyway by the current buffer management problems
+         */
+        nv04_surface_copy_m2mf(ctx, dst, dx, dy, src, sx, sy, w, h);
 }
 
 static void
@@ -317,7 +312,7 @@ nv04_surface_fill(struct nv04_surface_2d *ctx, struct pipe_surface *dst,
 	struct nouveau_channel *chan = ctx->surf2d->channel;
 	struct nouveau_grobj *surf2d = ctx->surf2d;
 	struct nouveau_grobj *rect = ctx->rect;
-	struct nouveau_bo *dst_bo = nouveau_bo(ctx->buf(dst));
+	struct nouveau_bo *dst_bo = ctx->buf(dst);
 	unsigned dst_pitch = ((struct nv04_surface *)dst)->pitch;
 	int cs2d_format, gdirect_format;
 
@@ -501,26 +496,19 @@ nv04_surface_2d_init(struct nouveau_screen *screen)
 }
 
 struct nv04_surface*
-nv04_surface_wrap_for_render(struct pipe_screen *pscreen, struct nv04_surface_2d* eng2d, struct nv04_surface* ns)
+nv04_surface_wrap_for_render(struct pipe_screen *pscreen,
+			     struct nv04_surface_2d* eng2d, struct nv04_surface* ns)
 {
 	int temp_flags;
 
-	// printf("creating temp, flags is %i!\n", flags);
-
-	if(ns->base.usage & PIPE_BUFFER_USAGE_DISCARD)
-	{
-		temp_flags = ns->base.usage | PIPE_BUFFER_USAGE_GPU_READ;
-		ns->base.usage = PIPE_BUFFER_USAGE_GPU_WRITE | NOUVEAU_BUFFER_USAGE_NO_RENDER | PIPE_BUFFER_USAGE_DISCARD;
-	}
-	else
-	{
-		temp_flags = ns->base.usage | PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE;
-		ns->base.usage = PIPE_BUFFER_USAGE_GPU_WRITE | NOUVEAU_BUFFER_USAGE_NO_RENDER | PIPE_BUFFER_USAGE_GPU_READ;
-	}
+	temp_flags = (ns->base.usage |
+		      PIPE_BIND_BLIT_SOURCE |
+		      PIPE_BIND_BLIT_DESTINATION);
 
-	ns->base.usage = PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE;
+	ns->base.usage = (PIPE_BIND_BLIT_SOURCE |
+			 PIPE_BIND_BLIT_DESTINATION);
 
-	struct pipe_texture templ;
+	struct pipe_resource templ;
 	memset(&templ, 0, sizeof(templ));
 	templ.format = ns->base.texture->format;
 	templ.target = PIPE_TEXTURE_2D;
@@ -532,14 +520,16 @@ nv04_surface_wrap_for_render(struct pipe_screen *pscreen, struct nv04_surface_2d
 	// TODO: this is probably wrong and we should specifically handle multisampling somehow once it is implemented
 	templ.nr_samples = ns->base.texture->nr_samples;
 
-	templ.tex_usage = ns->base.texture->tex_usage | PIPE_TEXTURE_USAGE_RENDER_TARGET;
+	templ.bind = ns->base.texture->bind | PIPE_BIND_RENDER_TARGET;
 
-	struct pipe_texture* temp_tex = pscreen->texture_create(pscreen, &templ);
+	struct pipe_resource* temp_tex = pscreen->resource_create(pscreen, &templ);
 	struct nv04_surface* temp_ns = (struct nv04_surface*)pscreen->get_tex_surface(pscreen, temp_tex, 0, 0, 0, temp_flags);
 	temp_ns->backing = ns;
 
-	if(ns->base.usage & PIPE_BUFFER_USAGE_GPU_READ)
-		eng2d->copy(eng2d, &temp_ns->backing->base, 0, 0, &ns->base, 0, 0, ns->base.width, ns->base.height);
+	if(ns->base.usage & PIPE_BIND_BLIT_SOURCE)
+		eng2d->copy(eng2d, &temp_ns->backing->base,
+			    0, 0, &ns->base,
+			    0, 0, ns->base.width, ns->base.height);
 
 	return temp_ns;
 }
diff --git a/src/gallium/drivers/nvfx/nv04_surface_2d.h b/src/gallium/drivers/nvfx/nv04_surface_2d.h
index ce696a11a39..b2b237b9dfa 100644
--- a/src/gallium/drivers/nvfx/nv04_surface_2d.h
+++ b/src/gallium/drivers/nvfx/nv04_surface_2d.h
@@ -16,7 +16,7 @@ struct nv04_surface_2d {
 	struct nouveau_grobj *blit;
 	struct nouveau_grobj *sifm;
 
-	struct pipe_buffer *(*buf)(struct pipe_surface *);
+	struct nouveau_bo *(*buf)(struct pipe_surface *);
 
 	void (*copy)(struct nv04_surface_2d *, struct pipe_surface *dst,
 		     int dx, int dy, struct pipe_surface *src, int sx, int sy,
@@ -34,4 +34,6 @@ nv04_surface_2d_takedown(struct nv04_surface_2d **);
 struct nv04_surface*
 nv04_surface_wrap_for_render(struct pipe_screen *pscreen, struct nv04_surface_2d* eng2d, struct nv04_surface* ns);
 
+#define NVFX_RESOURCE_FLAG_LINEAR (PIPE_RESOURCE_FLAG_DRV_PRIV << 0)
+
 #endif
diff --git a/src/gallium/drivers/nvfx/nv30_fragtex.c b/src/gallium/drivers/nvfx/nv30_fragtex.c
index d3f3edb3278..dec073ac900 100644
--- a/src/gallium/drivers/nvfx/nv30_fragtex.c
+++ b/src/gallium/drivers/nvfx/nv30_fragtex.c
@@ -3,6 +3,7 @@
 #include "nvfx_context.h"
 #include "nouveau/nouveau_util.h"
 #include "nvfx_tex.h"
+#include "nvfx_resource.h"
 
 void
 nv30_sampler_state_init(struct pipe_context *pipe,
@@ -87,21 +88,21 @@ nv30_fragtex_format(uint pipe_format)
 }
 
 
-struct nouveau_stateobj *
-nv30_fragtex_build(struct nvfx_context *nvfx, int unit)
+void
+nv30_fragtex_set(struct nvfx_context *nvfx, int unit)
 {
 	struct nvfx_sampler_state *ps = nvfx->tex_sampler[unit];
 	struct nvfx_miptree *nv30mt = (struct nvfx_miptree *)nvfx->fragment_sampler_views[unit]->texture;
-	struct pipe_texture *pt = &nv30mt->base;
-	struct nouveau_bo *bo = nouveau_bo(nv30mt->buffer);
+	struct pipe_resource *pt = &nv30mt->base.base;
+	struct nouveau_bo *bo = nv30mt->base.bo;
 	struct nv30_texture_format *tf;
-	struct nouveau_stateobj *so;
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
 	uint32_t txf, txs;
 	unsigned tex_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART | NOUVEAU_BO_RD;
 
 	tf = nv30_fragtex_format(pt->format);
 	if (!tf)
-		return NULL;
+		return;
 
 	txf  = tf->format;
 	txf |= ((pt->last_level>0) ? NV34TCL_TX_FORMAT_MIPMAP : 0);
@@ -125,23 +126,24 @@ nv30_fragtex_build(struct nvfx_context *nvfx, int unit)
 		break;
 	default:
 		NOUVEAU_ERR("Unknown target %d\n", pt->target);
-		return NULL;
+		return;
 	}
 
 	txs = tf->swizzle;
 
-	so = so_new(1, 8, 2);
-	so_method(so, nvfx->screen->eng3d, NV34TCL_TX_OFFSET(unit), 8);
-	so_reloc (so, bo, 0, tex_flags | NOUVEAU_BO_LOW, 0, 0);
-	so_reloc (so, bo, txf, tex_flags | NOUVEAU_BO_OR,
+	MARK_RING(chan, 9, 2);
+	OUT_RING(chan, RING_3D(NV34TCL_TX_OFFSET(unit), 8));
+	OUT_RELOC(chan, bo, 0, tex_flags | NOUVEAU_BO_LOW, 0, 0);
+	OUT_RELOC(chan, bo, txf, tex_flags | NOUVEAU_BO_OR,
 		      NV34TCL_TX_FORMAT_DMA0, NV34TCL_TX_FORMAT_DMA1);
-	so_data  (so, ps->wrap);
-	so_data  (so, NV34TCL_TX_ENABLE_ENABLE | ps->en);
-	so_data  (so, txs);
-	so_data  (so, ps->filt | 0x2000 /*voodoo*/);
-	so_data  (so, (pt->width0 << NV34TCL_TX_NPOT_SIZE_W_SHIFT) |
+	OUT_RING(chan, ps->wrap);
+	OUT_RING(chan, NV34TCL_TX_ENABLE_ENABLE | ps->en);
+	OUT_RING(chan, txs);
+	OUT_RING(chan, ps->filt | 0x2000 /*voodoo*/);
+	OUT_RING(chan, (pt->width0 << NV34TCL_TX_NPOT_SIZE_W_SHIFT) |
 		       pt->height0);
-	so_data  (so, ps->bcol);
+	OUT_RING(chan, ps->bcol);
 
-	return so;
+	nvfx->hw_txf[unit] = txf;
+	nvfx->hw_samplers |= (1 << unit);
 }
diff --git a/src/gallium/drivers/nvfx/nv40_fragtex.c b/src/gallium/drivers/nvfx/nv40_fragtex.c
index fe87cebbb68..0068b1ba54a 100644
--- a/src/gallium/drivers/nvfx/nv40_fragtex.c
+++ b/src/gallium/drivers/nvfx/nv40_fragtex.c
@@ -1,6 +1,7 @@
 #include "util/u_format.h"
 #include "nvfx_context.h"
 #include "nvfx_tex.h"
+#include "nvfx_resource.h"
 
 void
 nv40_sampler_state_init(struct pipe_context *pipe,
@@ -105,15 +106,16 @@ nv40_fragtex_format(uint pipe_format)
 }
 
 
-struct nouveau_stateobj *
-nv40_fragtex_build(struct nvfx_context *nvfx, int unit)
+void
+nv40_fragtex_set(struct nvfx_context *nvfx, int unit)
 {
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
 	struct nvfx_sampler_state *ps = nvfx->tex_sampler[unit];
 	struct nvfx_miptree *nv40mt = (struct nvfx_miptree *)nvfx->fragment_sampler_views[unit]->texture;
-	struct nouveau_bo *bo = nouveau_bo(nv40mt->buffer);
-	struct pipe_texture *pt = &nv40mt->base;
+	struct nouveau_bo *bo = nv40mt->base.bo;
+	struct pipe_resource *pt = &nv40mt->base.base;
 	struct nv40_texture_format *tf;
-	struct nouveau_stateobj *so;
+
 	uint32_t txf, txs, txp;
 	unsigned tex_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART | NOUVEAU_BO_RD;
 
@@ -143,10 +145,10 @@ nv40_fragtex_build(struct nvfx_context *nvfx, int unit)
 		break;
 	default:
 		NOUVEAU_ERR("Unknown target %d\n", pt->target);
-		return NULL;
+		return;
 	}
 
-	if (!(pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
+	if (!(pt->flags & NVFX_RESOURCE_FLAG_LINEAR)) {
 		txp = 0;
 	} else {
 		txp  = nv40mt->level[0].pitch;
@@ -155,20 +157,20 @@ nv40_fragtex_build(struct nvfx_context *nvfx, int unit)
 
 	txs = tf->swizzle;
 
-	so = so_new(2, 9, 2);
-	so_method(so, nvfx->screen->eng3d, NV34TCL_TX_OFFSET(unit), 8);
-	so_reloc (so, bo, 0, tex_flags | NOUVEAU_BO_LOW, 0, 0);
-	so_reloc (so, bo, txf, tex_flags | NOUVEAU_BO_OR,
-		      NV34TCL_TX_FORMAT_DMA0, NV34TCL_TX_FORMAT_DMA1);
-	so_data  (so, ps->wrap);
-	so_data  (so, NV40TCL_TEX_ENABLE_ENABLE | ps->en);
-	so_data  (so, txs);
-	so_data  (so, ps->filt | tf->sign | 0x2000 /*voodoo*/);
-	so_data  (so, (pt->width0 << NV34TCL_TX_NPOT_SIZE_W_SHIFT) |
-		       pt->height0);
-	so_data  (so, ps->bcol);
-	so_method(so, nvfx->screen->eng3d, NV40TCL_TEX_SIZE1(unit), 1);
-	so_data  (so, (pt->depth0 << NV40TCL_TEX_SIZE1_DEPTH_SHIFT) | txp);
-
-	return so;
+	MARK_RING(chan, 11 + 2 * !unit, 2);
+	OUT_RING(chan, RING_3D(NV34TCL_TX_OFFSET(unit), 8));
+	OUT_RELOC(chan, bo, 0, tex_flags | NOUVEAU_BO_LOW, 0, 0);
+	OUT_RELOC(chan, bo, txf, tex_flags | NOUVEAU_BO_OR,
+			NV34TCL_TX_FORMAT_DMA0, NV34TCL_TX_FORMAT_DMA1);
+	OUT_RING(chan, ps->wrap);
+	OUT_RING(chan, NV40TCL_TEX_ENABLE_ENABLE | ps->en);
+	OUT_RING(chan, txs);
+	OUT_RING(chan, ps->filt | tf->sign | 0x2000 /*voodoo*/);
+	OUT_RING(chan, (pt->width0 << NV34TCL_TX_NPOT_SIZE_W_SHIFT) | pt->height0);
+	OUT_RING(chan, ps->bcol);
+	OUT_RING(chan, RING_3D(NV40TCL_TEX_SIZE1(unit), 1));
+	OUT_RING(chan, (pt->depth0 << NV40TCL_TEX_SIZE1_DEPTH_SHIFT) | txp);
+
+	nvfx->hw_txf[unit] = txf;
+	nvfx->hw_samplers |= (1 << unit);
 }
diff --git a/src/gallium/drivers/nvfx/nvfx_buffer.c b/src/gallium/drivers/nvfx/nvfx_buffer.c
new file mode 100644
index 00000000000..24e0a0c7f65
--- /dev/null
+++ b/src/gallium/drivers/nvfx/nvfx_buffer.c
@@ -0,0 +1,153 @@
+
+#include "util/u_inlines.h"
+#include "util/u_memory.h"
+#include "util/u_math.h"
+
+#include "nouveau/nouveau_screen.h"
+#include "nouveau/nouveau_winsys.h"
+#include "nvfx_resource.h"
+
+
+/* Currently using separate implementations for buffers and textures,
+ * even though gallium has a unified abstraction of these objects.
+ * Eventually these should be combined, and mechanisms like transfers
+ * be adapted to work for both buffer and texture uploads.
+ */
+static void nvfx_buffer_destroy(struct pipe_screen *pscreen,
+				struct pipe_resource *presource)
+{
+	struct nvfx_resource *buffer = nvfx_resource(presource);
+
+	nouveau_screen_bo_release(pscreen, buffer->bo);
+	FREE(buffer);
+}
+
+
+
+
+/* Utility functions for transfer create/destroy are hooked in and
+ * just record the arguments to those functions.
+ */
+static void *
+nvfx_buffer_transfer_map( struct pipe_context *pipe,
+			  struct pipe_transfer *transfer )
+{
+	struct nvfx_resource *buffer = nvfx_resource(transfer->resource);
+	uint8_t *map;
+
+	map = nouveau_screen_bo_map_range( pipe->screen,
+					   buffer->bo,
+					   transfer->box.x,
+					   transfer->box.width,
+					   nouveau_screen_transfer_flags(transfer->usage) );
+	if (map == NULL)
+		return NULL;
+	
+	return map + transfer->box.x;
+}
+
+
+
+static void nvfx_buffer_transfer_flush_region( struct pipe_context *pipe,
+					       struct pipe_transfer *transfer,
+					       const struct pipe_box *box)
+{
+	struct nvfx_resource *buffer = nvfx_resource(transfer->resource);
+
+	nouveau_screen_bo_map_flush_range(pipe->screen,
+					  buffer->bo,
+					  transfer->box.x + box->x,
+					  box->width);
+}
+
+static void nvfx_buffer_transfer_unmap( struct pipe_context *pipe,
+					struct pipe_transfer *transfer )
+{
+	struct nvfx_resource *buffer = nvfx_resource(transfer->resource);
+
+	nouveau_screen_bo_unmap(pipe->screen, buffer->bo);
+}
+
+
+
+
+struct u_resource_vtbl nvfx_buffer_vtbl = 
+{
+	u_default_resource_get_handle,      /* get_handle */
+	nvfx_buffer_destroy,		     /* resource_destroy */
+	NULL,			    /* is_resource_referenced */
+	u_default_get_transfer,	     /* get_transfer */
+	u_default_transfer_destroy,	     /* transfer_destroy */
+	nvfx_buffer_transfer_map,	     /* transfer_map */
+	nvfx_buffer_transfer_flush_region,  /* transfer_flush_region */
+	nvfx_buffer_transfer_unmap,	     /* transfer_unmap */
+	u_default_transfer_inline_write   /* transfer_inline_write */
+};
+
+
+
+struct pipe_resource *
+nvfx_buffer_create(struct pipe_screen *pscreen,
+		   const struct pipe_resource *template)
+{
+	struct nvfx_resource *buffer;
+
+	buffer = CALLOC_STRUCT(nvfx_resource);
+	if (!buffer)
+		return NULL;
+
+	buffer->base = *template;
+	buffer->vtbl = &nvfx_buffer_vtbl;
+	pipe_reference_init(&buffer->base.reference, 1);
+	buffer->base.screen = pscreen;
+
+	buffer->bo = nouveau_screen_bo_new(pscreen,
+					   16,
+					   buffer->base._usage,
+					   buffer->base.bind,
+					   buffer->base.width0);
+
+	if (buffer->bo == NULL)
+		goto fail;
+
+	return &buffer->base;
+
+fail:
+	FREE(buffer);
+	return NULL;
+}
+
+
+struct pipe_resource *
+nvfx_user_buffer_create(struct pipe_screen *pscreen,
+			void *ptr,
+			unsigned bytes,
+			unsigned usage)
+{
+	struct nvfx_resource *buffer;
+
+	buffer = CALLOC_STRUCT(nvfx_resource);
+	if (!buffer)
+		return NULL;
+
+	pipe_reference_init(&buffer->base.reference, 1);
+	buffer->vtbl = &nvfx_buffer_vtbl;
+	buffer->base.screen = pscreen;
+	buffer->base.format = PIPE_FORMAT_R8_UNORM;
+	buffer->base._usage = PIPE_USAGE_IMMUTABLE;
+	buffer->base.bind = usage;
+	buffer->base.width0 = bytes;
+	buffer->base.height0 = 1;
+	buffer->base.depth0 = 1;
+
+	buffer->bo = nouveau_screen_bo_user(pscreen, ptr, bytes);
+	if (!buffer->bo)
+		goto fail;
+	
+	return &buffer->base;
+
+fail:
+	FREE(buffer);
+	return NULL;
+}
+
diff --git a/src/gallium/drivers/nvfx/nvfx_context.c b/src/gallium/drivers/nvfx/nvfx_context.c
index fc3cbdb558f..1faa0af31fb 100644
--- a/src/gallium/drivers/nvfx/nvfx_context.c
+++ b/src/gallium/drivers/nvfx/nvfx_context.c
@@ -3,6 +3,7 @@
 
 #include "nvfx_context.h"
 #include "nvfx_screen.h"
+#include "nvfx_resource.h"
 
 static void
 nvfx_flush(struct pipe_context *pipe, unsigned flags,
@@ -29,12 +30,6 @@ static void
 nvfx_destroy(struct pipe_context *pipe)
 {
 	struct nvfx_context *nvfx = nvfx_context(pipe);
-	unsigned i;
-
-	for (i = 0; i < NVFX_STATE_MAX; i++) {
-		if (nvfx->state.hw[i])
-			so_ref(NULL, &nvfx->state.hw[i]);
-	}
 
 	if (nvfx->draw)
 		draw_destroy(nvfx->draw);
@@ -65,18 +60,14 @@ nvfx_create(struct pipe_screen *pscreen, void *priv)
 	nvfx->pipe.clear = nvfx_clear;
 	nvfx->pipe.flush = nvfx_flush;
 
-	nvfx->pipe.is_texture_referenced = nouveau_is_texture_referenced;
-	nvfx->pipe.is_buffer_referenced = nouveau_is_buffer_referenced;
-
 	screen->base.channel->user_private = nvfx;
-	screen->base.channel->flush_notify = nvfx_state_flush_notify;
 
 	nvfx->is_nv4x = screen->is_nv4x;
 
 	nvfx_init_query_functions(nvfx);
 	nvfx_init_surface_functions(nvfx);
 	nvfx_init_state_functions(nvfx);
-	nvfx_init_transfer_functions(nvfx);
+	nvfx_init_resource_functions(&nvfx->pipe);
 
 	/* Create, configure, and install fallback swtnl path */
 	nvfx->draw = draw_create();
@@ -86,5 +77,8 @@ nvfx_create(struct pipe_screen *pscreen, void *priv)
 	draw_enable_point_sprites(nvfx->draw, FALSE);
 	draw_set_rasterize_stage(nvfx->draw, nvfx_draw_render_stage(nvfx));
 
+	/* set these to that we init them on first validation */
+	nvfx->state.scissor_enabled = ~0;
+	nvfx->state.stipple_enabled = ~0;
 	return &nvfx->pipe;
 }
diff --git a/src/gallium/drivers/nvfx/nvfx_context.h b/src/gallium/drivers/nvfx/nvfx_context.h
index ab7225cf6c3..e2c6d09fa19 100644
--- a/src/gallium/drivers/nvfx/nvfx_context.h
+++ b/src/gallium/drivers/nvfx/nvfx_context.h
@@ -16,8 +16,6 @@
 
 #include "nouveau/nouveau_winsys.h"
 #include "nouveau/nouveau_gldefs.h"
-#include "nouveau/nouveau_context.h"
-#include "nouveau/nouveau_stateobj.h"
 
 #include "nvfx_state.h"
 
@@ -26,45 +24,6 @@
 #define NOUVEAU_MSG(fmt, args...) \
 	fprintf(stderr, "nouveau: "fmt, ##args);
 
-enum nvfx_state_index {
-	NVFX_STATE_FB = 0,
-	NVFX_STATE_VIEWPORT = 1,
-	NVFX_STATE_BLEND = 2,
-	NVFX_STATE_RAST = 3,
-	NVFX_STATE_ZSA = 4,
-	NVFX_STATE_BCOL = 5,
-	NVFX_STATE_CLIP = 6,
-	NVFX_STATE_SCISSOR = 7,
-	NVFX_STATE_STIPPLE = 8,
-	NVFX_STATE_FRAGPROG = 9,
-	NVFX_STATE_VERTPROG = 10,
-	NVFX_STATE_FRAGTEX0 = 11,
-	NVFX_STATE_FRAGTEX1 = 12,
-	NVFX_STATE_FRAGTEX2 = 13,
-	NVFX_STATE_FRAGTEX3 = 14,
-	NVFX_STATE_FRAGTEX4 = 15,
-	NVFX_STATE_FRAGTEX5 = 16,
-	NVFX_STATE_FRAGTEX6 = 17,
-	NVFX_STATE_FRAGTEX7 = 18,
-	NVFX_STATE_FRAGTEX8 = 19,
-	NVFX_STATE_FRAGTEX9 = 20,
-	NVFX_STATE_FRAGTEX10 = 21,
-	NVFX_STATE_FRAGTEX11 = 22,
-	NVFX_STATE_FRAGTEX12 = 23,
-	NVFX_STATE_FRAGTEX13 = 24,
-	NVFX_STATE_FRAGTEX14 = 25,
-	NVFX_STATE_FRAGTEX15 = 26,
-	NVFX_STATE_VERTTEX0 = 27,
-	NVFX_STATE_VERTTEX1 = 28,
-	NVFX_STATE_VERTTEX2 = 29,
-	NVFX_STATE_VERTTEX3 = 30,
-	NVFX_STATE_VTXBUF = 31,
-	NVFX_STATE_VTXFMT = 32,
-	NVFX_STATE_VTXATTR = 33,
-	NVFX_STATE_SR = 34,
-	NVFX_STATE_MAX = 35
-};
-
 #include "nvfx_screen.h"
 
 #define NVFX_NEW_BLEND		(1 <<  0)
@@ -81,20 +40,25 @@ enum nvfx_state_index {
 #define NVFX_NEW_ARRAYS		(1 << 11)
 #define NVFX_NEW_UCP		(1 << 12)
 #define NVFX_NEW_SR		(1 << 13)
+#define NVFX_NEW_VERTCONST	(1 << 14)
+#define NVFX_NEW_FRAGCONST	(1 << 15)
 
 struct nvfx_rasterizer_state {
 	struct pipe_rasterizer_state pipe;
-	struct nouveau_stateobj *so;
+	unsigned sb_len;
+	uint32_t sb[32];
 };
 
 struct nvfx_zsa_state {
 	struct pipe_depth_stencil_alpha_state pipe;
-	struct nouveau_stateobj *so;
+	unsigned sb_len;
+	uint32_t sb[26];
 };
 
 struct nvfx_blend_state {
 	struct pipe_blend_state pipe;
-	struct nouveau_stateobj *so;
+	unsigned sb_len;
+	uint32_t sb[13];
 };
 
 
@@ -102,9 +66,6 @@ struct nvfx_state {
 	unsigned scissor_enabled;
 	unsigned stipple_enabled;
 	unsigned fp_samplers;
-
-	uint64_t dirty;
-	struct nouveau_stateobj *hw[NVFX_STATE_MAX];
 };
 
 struct nvfx_vtxelt_state {
@@ -112,6 +73,12 @@ struct nvfx_vtxelt_state {
 	unsigned num_elements;
 };
 
+struct nvfx_render_target {
+	struct nouveau_bo* bo;
+	unsigned offset;
+	unsigned pitch;
+};
+
 struct nvfx_context {
 	struct pipe_context pipe;
 
@@ -137,7 +104,6 @@ struct nvfx_context {
 		HW, SWTNL, SWRAST
 	} render_mode;
 	unsigned fallback_swtnl;
-	unsigned fallback_swrast;
 
 	/* Context state */
 	unsigned dirty, draw_dirty;
@@ -146,7 +112,7 @@ struct nvfx_context {
 	struct pipe_clip_state clip;
 	struct nvfx_vertex_program *vertprog;
 	struct nvfx_fragment_program *fragprog;
-	struct pipe_buffer *constbuf[PIPE_SHADER_TYPES];
+	struct pipe_resource *constbuf[PIPE_SHADER_TYPES];
 	unsigned constbuf_nr[PIPE_SHADER_TYPES];
 	struct nvfx_rasterizer_state *rasterizer;
 	struct nvfx_zsa_state *zsa;
@@ -155,7 +121,7 @@ struct nvfx_context {
 	struct pipe_stencil_ref stencil_ref;
 	struct pipe_viewport_state viewport;
 	struct pipe_framebuffer_state framebuffer;
-	struct pipe_buffer *idxbuf;
+	struct pipe_resource *idxbuf;
 	unsigned idxbuf_format;
 	struct nvfx_sampler_state *tex_sampler[PIPE_MAX_SAMPLERS];
 	struct pipe_sampler_view *fragment_sampler_views[PIPE_MAX_SAMPLERS];
@@ -165,6 +131,13 @@ struct nvfx_context {
 	struct pipe_vertex_buffer vtxbuf[PIPE_MAX_ATTRIBS];
 	unsigned vtxbuf_nr;
 	struct nvfx_vtxelt_state *vtxelt;
+
+	unsigned vbo_bo;
+	unsigned hw_vtxelt_nr;
+	uint8_t hw_samplers;
+	uint32_t hw_txf[8];
+	struct nvfx_render_target hw_rt[4];
+	struct nvfx_render_target hw_zeta;
 };
 
 static INLINE struct nvfx_context *
@@ -173,14 +146,6 @@ nvfx_context(struct pipe_context *pipe)
 	return (struct nvfx_context *)pipe;
 }
 
-struct nvfx_state_entry {
-	boolean (*validate)(struct nvfx_context *nvfx);
-	struct {
-		unsigned pipe;
-		unsigned hw;
-	} dirty;
-};
-
 extern struct nvfx_state_entry nvfx_state_blend;
 extern struct nvfx_state_entry nvfx_state_blend_colour;
 extern struct nvfx_state_entry nvfx_state_fragprog;
@@ -210,37 +175,55 @@ extern void nvfx_clear(struct pipe_context *pipe, unsigned buffers,
 /* nvfx_draw.c */
 extern struct draw_stage *nvfx_draw_render_stage(struct nvfx_context *nvfx);
 extern void nvfx_draw_elements_swtnl(struct pipe_context *pipe,
-					struct pipe_buffer *idxbuf,
+					struct pipe_resource *idxbuf,
 					unsigned ib_size, unsigned mode,
 					unsigned start, unsigned count);
+extern void nvfx_vtxfmt_validate(struct nvfx_context *nvfx);
+
+/* nvfx_fb.c */
+extern void nvfx_state_framebuffer_validate(struct nvfx_context *nvfx);
+void
+nvfx_framebuffer_relocate(struct nvfx_context *nvfx);
 
 /* nvfx_fragprog.c */
 extern void nvfx_fragprog_destroy(struct nvfx_context *,
 				    struct nvfx_fragment_program *);
+extern void nvfx_fragprog_validate(struct nvfx_context *nvfx);
+extern void
+nvfx_fragprog_relocate(struct nvfx_context *nvfx);
+
+/* nvfx_fragtex.c */
+extern void nvfx_fragtex_validate(struct nvfx_context *nvfx);
+extern void
+nvfx_fragtex_relocate(struct nvfx_context *nvfx);
 
 /* nv30_fragtex.c */
 extern void
 nv30_sampler_state_init(struct pipe_context *pipe,
 			  struct nvfx_sampler_state *ps,
 			  const struct pipe_sampler_state *cso);
-extern void nv30_fragtex_bind(struct nvfx_context *);
-extern struct nouveau_stateobj *
-nv30_fragtex_build(struct nvfx_context *nvfx, int unit);
+extern void nv30_fragtex_set(struct nvfx_context *nvfx, int unit);
 
 /* nv40_fragtex.c */
 extern void
 nv40_sampler_state_init(struct pipe_context *pipe,
 			  struct nvfx_sampler_state *ps,
 			  const struct pipe_sampler_state *cso);
-extern void nv40_fragtex_bind(struct nvfx_context *);
-extern struct nouveau_stateobj *
-nv40_fragtex_build(struct nvfx_context *nvfx, int unit);
+extern void nv40_fragtex_set(struct nvfx_context *nvfx, int unit);
 
 /* nvfx_state.c */
 extern void nvfx_init_state_functions(struct nvfx_context *nvfx);
+extern void nvfx_state_scissor_validate(struct nvfx_context *nvfx);
+extern void nvfx_state_stipple_validate(struct nvfx_context *nvfx);
+extern void nvfx_state_blend_validate(struct nvfx_context *nvfx);
+extern void nvfx_state_blend_colour_validate(struct nvfx_context *nvfx);
+extern void nvfx_state_viewport_validate(struct nvfx_context *nvfx);
+extern void nvfx_state_rasterizer_validate(struct nvfx_context *nvfx);
+extern void nvfx_state_sr_validate(struct nvfx_context *nvfx);
+extern void nvfx_state_zsa_validate(struct nvfx_context *nvfx);
 
 /* nvfx_state_emit.c */
-extern void nvfx_state_flush_notify(struct nouveau_channel *chan);
+extern void nvfx_state_relocate(struct nvfx_context *nvfx);
 extern boolean nvfx_state_validate(struct nvfx_context *nvfx);
 extern boolean nvfx_state_validate_swtnl(struct nvfx_context *nvfx);
 extern void nvfx_state_emit(struct nvfx_context *nvfx);
@@ -249,15 +232,18 @@ extern void nvfx_state_emit(struct nvfx_context *nvfx);
 extern void nvfx_init_transfer_functions(struct nvfx_context *nvfx);
 
 /* nvfx_vbo.c */
+extern boolean nvfx_vbo_validate(struct nvfx_context *nvfx);
+extern void nvfx_vbo_relocate(struct nvfx_context *nvfx);
 extern void nvfx_draw_arrays(struct pipe_context *, unsigned mode,
 				unsigned start, unsigned count);
 extern void nvfx_draw_elements(struct pipe_context *pipe,
-				  struct pipe_buffer *indexBuffer,
+				  struct pipe_resource *indexBuffer,
 				  unsigned indexSize,
 				  unsigned mode, unsigned start,
 				  unsigned count);
 
 /* nvfx_vertprog.c */
+extern boolean nvfx_vertprog_validate(struct nvfx_context *nvfx);
 extern void nvfx_vertprog_destroy(struct nvfx_context *,
 				  struct nvfx_vertex_program *);
 
diff --git a/src/gallium/drivers/nvfx/nvfx_draw.c b/src/gallium/drivers/nvfx/nvfx_draw.c
index 68e50a36479..2003be10204 100644
--- a/src/gallium/drivers/nvfx/nvfx_draw.c
+++ b/src/gallium/drivers/nvfx/nvfx_draw.c
@@ -234,28 +234,31 @@ nvfx_draw_render_stage(struct nvfx_context *nvfx)
 
 void
 nvfx_draw_elements_swtnl(struct pipe_context *pipe,
-			 struct pipe_buffer *idxbuf, unsigned idxbuf_size,
+			 struct pipe_resource *idxbuf, unsigned idxbuf_size,
 			 unsigned mode, unsigned start, unsigned count)
 {
 	struct nvfx_context *nvfx = nvfx_context(pipe);
-	struct pipe_screen *pscreen = pipe->screen;
+	struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
+	struct pipe_transfer *ib_transfer = NULL;
+	struct pipe_transfer *cb_transfer = NULL;
 	unsigned i;
 	void *map;
 
 	if (!nvfx_state_validate_swtnl(nvfx))
 		return;
-	nvfx->state.dirty &= ~(1ULL << NVFX_STATE_VTXBUF);
 	nvfx_state_emit(nvfx);
 
 	for (i = 0; i < nvfx->vtxbuf_nr; i++) {
-		map = pipe_buffer_map(pscreen, nvfx->vtxbuf[i].buffer,
-                                      PIPE_BUFFER_USAGE_CPU_READ);
+		map = pipe_buffer_map(pipe, nvfx->vtxbuf[i].buffer,
+                                      PIPE_TRANSFER_READ,
+				      &vb_transfer[i]);
 		draw_set_mapped_vertex_buffer(nvfx->draw, i, map);
 	}
 
 	if (idxbuf) {
-		map = pipe_buffer_map(pscreen, idxbuf,
-				      PIPE_BUFFER_USAGE_CPU_READ);
+		map = pipe_buffer_map(pipe, idxbuf,
+				      PIPE_TRANSFER_READ,
+				      &ib_transfer);
 		draw_set_mapped_element_buffer(nvfx->draw, idxbuf_size, map);
 	} else {
 		draw_set_mapped_element_buffer(nvfx->draw, 0, NULL);
@@ -264,9 +267,10 @@ nvfx_draw_elements_swtnl(struct pipe_context *pipe,
 	if (nvfx->constbuf[PIPE_SHADER_VERTEX]) {
 		const unsigned nr = nvfx->constbuf_nr[PIPE_SHADER_VERTEX];
 
-		map = pipe_buffer_map(pscreen,
+		map = pipe_buffer_map(pipe,
 				      nvfx->constbuf[PIPE_SHADER_VERTEX],
-				      PIPE_BUFFER_USAGE_CPU_READ);
+				      PIPE_TRANSFER_READ,
+				      &cb_transfer);
 		draw_set_mapped_constant_buffer(nvfx->draw, PIPE_SHADER_VERTEX, 0,
                                                 map, nr);
 	}
@@ -274,13 +278,14 @@ nvfx_draw_elements_swtnl(struct pipe_context *pipe,
 	draw_arrays(nvfx->draw, mode, start, count);
 
 	for (i = 0; i < nvfx->vtxbuf_nr; i++)
-		pipe_buffer_unmap(pscreen, nvfx->vtxbuf[i].buffer);
+		pipe_buffer_unmap(pipe, nvfx->vtxbuf[i].buffer, vb_transfer[i]);
 
 	if (idxbuf)
-		pipe_buffer_unmap(pscreen, idxbuf);
+		pipe_buffer_unmap(pipe, idxbuf, ib_transfer);
 
 	if (nvfx->constbuf[PIPE_SHADER_VERTEX])
-		pipe_buffer_unmap(pscreen, nvfx->constbuf[PIPE_SHADER_VERTEX]);
+		pipe_buffer_unmap(pipe, nvfx->constbuf[PIPE_SHADER_VERTEX],
+				  cb_transfer);
 
 	draw_flush(nvfx->draw);
 	pipe->flush(pipe, 0, NULL);
@@ -298,8 +303,8 @@ emit_attrib(struct nvfx_context *nvfx, unsigned hw, unsigned emit,
 	nvfx->swtnl.draw[a] = draw_out;
 }
 
-static boolean
-nvfx_state_vtxfmt_validate(struct nvfx_context *nvfx)
+void
+nvfx_vtxfmt_validate(struct nvfx_context *nvfx)
 {
 	struct nvfx_fragment_program *fp = nvfx->fragprog;
 	unsigned colour = 0, texcoords = 0, fog = 0, i;
@@ -343,14 +348,4 @@ nvfx_state_vtxfmt_validate(struct nvfx_context *nvfx)
 	}
 
 	emit_attrib(nvfx, 0, 0xff, TGSI_SEMANTIC_POSITION, 0);
-
-	return FALSE;
 }
-
-struct nvfx_state_entry nvfx_state_vtxfmt = {
-	.validate = nvfx_state_vtxfmt_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_ARRAYS | NVFX_NEW_FRAGPROG,
-		.hw = 0
-	}
-};
diff --git a/src/gallium/drivers/nvfx/nvfx_fragprog.c b/src/gallium/drivers/nvfx/nvfx_fragprog.c
index b9c91cec8ce..5fa825ad05d 100644
--- a/src/gallium/drivers/nvfx/nvfx_fragprog.c
+++ b/src/gallium/drivers/nvfx/nvfx_fragprog.c
@@ -9,6 +9,7 @@
 
 #include "nvfx_context.h"
 #include "nvfx_shader.h"
+#include "nvfx_resource.h"
 
 #define MAX_CONSTS 128
 #define MAX_IMM 32
@@ -822,130 +823,175 @@ out_err:
 	FREE(fpc);
 }
 
-static void
-nvfx_fragprog_upload(struct nvfx_context *nvfx,
-		     struct nvfx_fragment_program *fp)
+static inline void
+nvfx_fp_memcpy(void* dst, const void* src, size_t len)
 {
-	struct pipe_screen *pscreen = nvfx->pipe.screen;
-	const uint32_t le = 1;
-	uint32_t *map;
-	int i;
-
-	map = pipe_buffer_map(pscreen, fp->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
-
-#if 0
-	for (i = 0; i < fp->insn_len; i++) {
-		fflush(stdout); fflush(stderr);
-		NOUVEAU_ERR("%d 0x%08x\n", i, fp->insn[i]);
-		fflush(stdout); fflush(stderr);
+#ifndef WORDS_BIGENDIAN
+	memcpy(dst, src, len);
+#else
+	size_t i;
+	for(i = 0; i < len; i += 4) {
+		uint32_t v = (uint32_t*)((char*)src + i);
+		*(uint32_t*)((char*)dst + i) = (v >> 16) | (v << 16);
 	}
 #endif
-
-	if ((*(const uint8_t *)&le)) {
-		for (i = 0; i < fp->insn_len; i++) {
-			map[i] = fp->insn[i];
-		}
-	} else {
-		/* Weird swapping for big-endian chips */
-		for (i = 0; i < fp->insn_len; i++) {
-			map[i] = ((fp->insn[i] & 0xffff) << 16) |
-				  ((fp->insn[i] >> 16) & 0xffff);
-		}
-	}
-
-	pipe_buffer_unmap(pscreen, fp->buffer);
 }
 
-static boolean
+void
 nvfx_fragprog_validate(struct nvfx_context *nvfx)
 {
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
 	struct nvfx_fragment_program *fp = nvfx->fragprog;
-	struct pipe_buffer *constbuf =
-		nvfx->constbuf[PIPE_SHADER_FRAGMENT];
-	struct pipe_screen *pscreen = nvfx->pipe.screen;
-	struct nouveau_stateobj *so;
-	boolean new_consts = FALSE;
+	int update = 0;
 	int i;
 
-	if (fp->translated)
-		goto update_constants;
+	if (!fp->translated)
+	{
+		nvfx_fragprog_translate(nvfx, fp);
+		if (!fp->translated) {
+			static unsigned dummy[8] = {1, 0, 0, 0, 1, 0, 0, 0};
+			static int warned = 0;
+			if(!warned)
+			{
+				fprintf(stderr, "nvfx: failed to translate fragment program!\n");
+				warned = 1;
+			}
 
-	nvfx->fallback_swrast &= ~NVFX_NEW_FRAGPROG;
-	nvfx_fragprog_translate(nvfx, fp);
-	if (!fp->translated) {
-		nvfx->fallback_swrast |= NVFX_NEW_FRAGPROG;
-		return FALSE;
-	}
+			/* use dummy program: we cannot fail here */
+			fp->translated = TRUE;
+			fp->insn = malloc(sizeof(dummy));
+			memcpy(fp->insn, dummy, sizeof(dummy));
+			fp->insn_len = sizeof(dummy) / sizeof(dummy[0]);
+		}
+		update = TRUE;
 
-	fp->buffer = pscreen->buffer_create(pscreen, 0x100, 0, fp->insn_len * 4);
-	nvfx_fragprog_upload(nvfx, fp);
+		fp->prog_size = (fp->insn_len * 4 + 63) & ~63;
 
-	so = so_new(4, 4, 1);
-	so_method(so, nvfx->screen->eng3d, NV34TCL_FP_ACTIVE_PROGRAM, 1);
-	so_reloc (so, nouveau_bo(fp->buffer), 0, NOUVEAU_BO_VRAM |
-		      NOUVEAU_BO_GART | NOUVEAU_BO_RD | NOUVEAU_BO_LOW |
-		      NOUVEAU_BO_OR, NV34TCL_FP_ACTIVE_PROGRAM_DMA0,
-		      NV34TCL_FP_ACTIVE_PROGRAM_DMA1);
-	so_method(so, nvfx->screen->eng3d, NV34TCL_FP_CONTROL, 1);
-	so_data  (so, fp->fp_control);
-	if(!nvfx->is_nv4x) {
-		so_method(so, nvfx->screen->eng3d, NV34TCL_FP_REG_CONTROL, 1);
-		so_data  (so, (1<<16)|0x4);
-		so_method(so, nvfx->screen->eng3d, NV34TCL_TX_UNITS_ENABLE, 1);
-		so_data  (so, fp->samplers);
+		int min_size = 4096;
+		if(fp->prog_size >= min_size)
+			fp->progs_per_bo = 1;
+		else
+			fp->progs_per_bo = min_size / fp->prog_size;
+		fp->bo_prog_idx = fp->progs_per_bo - 1;
 	}
 
-	so_ref(so, &fp->so);
-	so_ref(NULL, &so);
-
-update_constants:
-	if (fp->nr_consts) {
-		float *map;
-
-		map = pipe_buffer_map(pscreen, constbuf,
-				      PIPE_BUFFER_USAGE_CPU_READ);
-		for (i = 0; i < fp->nr_consts; i++) {
-			struct nvfx_fragment_program_data *fpd = &fp->consts[i];
-			uint32_t *p = &fp->insn[fpd->offset];
-			uint32_t *cb = (uint32_t *)&map[fpd->index * 4];
+	if (nvfx->dirty & NVFX_NEW_FRAGCONST)
+		update = TRUE;
 
-			if (!memcmp(p, cb, 4 * sizeof(float)))
-				continue;
-			memcpy(p, cb, 4 * sizeof(float));
-			new_consts = TRUE;
+	if(update) {
+		++fp->bo_prog_idx;
+		if(fp->bo_prog_idx >= fp->progs_per_bo)
+		{
+			if(fp->fpbo && !nouveau_bo_busy(fp->fpbo->next->bo, NOUVEAU_BO_WR))
+			{
+				fp->fpbo = fp->fpbo->next;
+			}
+			else
+			{
+				struct nvfx_fragment_program_bo* fpbo = os_malloc_aligned(sizeof(struct nvfx_fragment_program) + fp->prog_size * fp->progs_per_bo, 16);
+				if(fp->fpbo)
+				{
+					fpbo->next = fp->fpbo->next;
+					fp->fpbo->next = fpbo;
+				}
+				else
+					fpbo->next = fpbo;
+				fp->fpbo = fpbo;
+				fpbo->bo = 0;
+				nouveau_bo_new(nvfx->screen->base.device, NOUVEAU_BO_VRAM | NOUVEAU_BO_MAP, 64, fp->prog_size * fp->progs_per_bo, &fpbo->bo);
+				nouveau_bo_map(fpbo->bo, NOUVEAU_BO_NOSYNC);
+
+				char* map = fpbo->bo->map;
+				char* buf = fpbo->insn;
+				for(int i = 0; i < fp->progs_per_bo; ++i)
+				{
+					memcpy(buf, fp->insn, fp->insn_len * 4);
+					nvfx_fp_memcpy(map, fp->insn, fp->insn_len * 4);
+					map += fp->prog_size;
+					buf += fp->prog_size;
+				}
+			}
+			fp->bo_prog_idx = 0;
 		}
-		pipe_buffer_unmap(pscreen, constbuf);
 
-		if (new_consts)
-			nvfx_fragprog_upload(nvfx, fp);
+		int offset = fp->bo_prog_idx * fp->prog_size;
+
+		if(nvfx->constbuf[PIPE_SHADER_FRAGMENT]) {
+			struct pipe_resource* constbuf = nvfx->constbuf[PIPE_SHADER_FRAGMENT];
+			// TODO: avoid using transfers, just directly the buffer
+			struct pipe_transfer* transfer;
+			// TODO: does this check make any sense, or should we do this unconditionally?
+			uint32_t* map = pipe_buffer_map(&nvfx->pipe, constbuf, PIPE_TRANSFER_READ, &transfer);
+			uint32_t* fpmap = (uint32_t*)((char*)fp->fpbo->bo->map + offset);
+			uint32_t* buf = (uint32_t*)((char*)fp->fpbo->insn + offset);
+			for (i = 0; i < fp->nr_consts; ++i) {
+				unsigned off = fp->consts[i].offset;
+				unsigned idx = fp->consts[i].index * 4;
+
+				/* TODO: is checking a good idea? */
+				if(memcmp(&buf[off], &map[idx], 4 * sizeof(uint32_t))) {
+					memcpy(&buf[off], &map[idx], 4 * sizeof(uint32_t));
+					nvfx_fp_memcpy(&fpmap[off], &map[idx], 4 * sizeof(uint32_t));
+				}
+			}
+			pipe_buffer_unmap(&nvfx->pipe, constbuf, transfer);
+		}
 	}
 
-	if (new_consts || fp->so != nvfx->state.hw[NVFX_STATE_FRAGPROG]) {
-		so_ref(fp->so, &nvfx->state.hw[NVFX_STATE_FRAGPROG]);
-		return TRUE;
+	if(update || (nvfx->dirty & NVFX_NEW_FRAGPROG)) {
+		int offset = fp->bo_prog_idx * fp->prog_size;
+		MARK_RING(chan, 8, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_FP_ACTIVE_PROGRAM, 1));
+		OUT_RELOC(chan, fp->fpbo->bo, offset, NOUVEAU_BO_VRAM |
+			      NOUVEAU_BO_GART | NOUVEAU_BO_RD | NOUVEAU_BO_LOW |
+			      NOUVEAU_BO_OR, NV34TCL_FP_ACTIVE_PROGRAM_DMA0,
+			      NV34TCL_FP_ACTIVE_PROGRAM_DMA1);
+		OUT_RING(chan, RING_3D(NV34TCL_FP_CONTROL, 1));
+		OUT_RING(chan, fp->fp_control);
+		if(!nvfx->is_nv4x) {
+			OUT_RING(chan, RING_3D(NV34TCL_FP_REG_CONTROL, 1));
+			OUT_RING(chan, (1<<16)|0x4);
+			OUT_RING(chan, RING_3D(NV34TCL_TX_UNITS_ENABLE, 1));
+			OUT_RING(chan, fp->samplers);
+		}
 	}
+}
 
-	return FALSE;
+void
+nvfx_fragprog_relocate(struct nvfx_context *nvfx)
+{
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
+	struct nvfx_fragment_program *fp = nvfx->fragprog;
+	struct nouveau_bo* bo = fp->fpbo->bo;
+	int offset = fp->bo_prog_idx * fp->prog_size;
+	unsigned fp_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_RD; // TODO: GART?
+	fp_flags |= NOUVEAU_BO_DUMMY;
+	MARK_RING(chan, 2, 2);
+	OUT_RELOC(chan, bo, RING_3D(NV34TCL_FP_ACTIVE_PROGRAM, 1), fp_flags, 0, 0);
+	OUT_RELOC(chan, bo, offset, fp_flags | NOUVEAU_BO_LOW |
+		      NOUVEAU_BO_OR, NV34TCL_FP_ACTIVE_PROGRAM_DMA0,
+		      NV34TCL_FP_ACTIVE_PROGRAM_DMA1);
 }
 
 void
 nvfx_fragprog_destroy(struct nvfx_context *nvfx,
 		      struct nvfx_fragment_program *fp)
 {
-	if (fp->buffer)
-		pipe_buffer_reference(&fp->buffer, NULL);
-
-	if (fp->so)
-		so_ref(NULL, &fp->so);
+	struct nvfx_fragment_program_bo* fpbo = fp->fpbo;
+	if(fpbo)
+	{
+		do
+		{
+			struct nvfx_fragment_program_bo* next = fpbo->next;
+			nouveau_bo_unmap(fpbo->bo);
+			nouveau_bo_ref(0, &fpbo->bo);
+			free(fpbo);
+			fpbo = next;
+		}
+		while(fpbo != fp->fpbo);
+	}
 
 	if (fp->insn_len)
 		FREE(fp->insn);
 }
 
-struct nvfx_state_entry nvfx_state_fragprog = {
-	.validate = nvfx_fragprog_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_FRAGPROG,
-		.hw = NVFX_STATE_FRAGPROG
-	}
-};
diff --git a/src/gallium/drivers/nvfx/nvfx_fragtex.c b/src/gallium/drivers/nvfx/nvfx_fragtex.c
index 84e4eb10042..f5f6b0c0cbd 100644
--- a/src/gallium/drivers/nvfx/nvfx_fragtex.c
+++ b/src/gallium/drivers/nvfx/nvfx_fragtex.c
@@ -1,49 +1,55 @@
 #include "nvfx_context.h"
+#include "nvfx_resource.h"
 
-static boolean
+void
 nvfx_fragtex_validate(struct nvfx_context *nvfx)
 {
-	struct nvfx_fragment_program *fp = nvfx->fragprog;
-	struct nvfx_state *state = &nvfx->state;
-	struct nouveau_stateobj *so;
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
 	unsigned samplers, unit;
 
-	samplers = state->fp_samplers & ~fp->samplers;
+	samplers = nvfx->dirty_samplers;
+	if(!samplers)
+		return;
+
 	while (samplers) {
 		unit = ffs(samplers) - 1;
 		samplers &= ~(1 << unit);
 
-		so = so_new(1, 1, 0);
-		so_method(so, nvfx->screen->eng3d, NV34TCL_TX_ENABLE(unit), 1);
-		so_data  (so, 0);
-		so_ref(so, &nvfx->state.hw[NVFX_STATE_FRAGTEX0 + unit]);
-		so_ref(NULL, &so);
-		state->dirty |= (1ULL << (NVFX_STATE_FRAGTEX0 + unit));
+		if(nvfx->fragment_sampler_views[unit] && nvfx->tex_sampler[unit]) {
+			if(!nvfx->is_nv4x)
+				nv30_fragtex_set(nvfx, unit);
+			else
+				nv40_fragtex_set(nvfx, unit);
+		} else {
+			WAIT_RING(chan, 2);
+			/* this is OK for nv40 too */
+			OUT_RING(chan, RING_3D(NV34TCL_TX_ENABLE(unit), 1));
+			OUT_RING(chan, 0);
+			nvfx->hw_samplers &= ~(1 << unit);
+		}
 	}
+	nvfx->dirty_samplers = 0;
+}
+
+void
+nvfx_fragtex_relocate(struct nvfx_context *nvfx)
+{
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
+	unsigned samplers, unit;
+	unsigned tex_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART | NOUVEAU_BO_RD;
 
-	samplers = nvfx->dirty_samplers & fp->samplers;
+	samplers = nvfx->hw_samplers;
 	while (samplers) {
 		unit = ffs(samplers) - 1;
 		samplers &= ~(1 << unit);
 
-		if(!nvfx->is_nv4x)
-			so = nv30_fragtex_build(nvfx, unit);
-		else
-			so = nv40_fragtex_build(nvfx, unit);
+		struct nvfx_miptree* mt = (struct nvfx_miptree*)nvfx->fragment_sampler_views[unit]->texture;
+		struct nouveau_bo *bo = mt->base.bo;
 
-		so_ref(so, &nvfx->state.hw[NVFX_STATE_FRAGTEX0 + unit]);
-		so_ref(NULL, &so);
-		state->dirty |= (1ULL << (NVFX_STATE_FRAGTEX0 + unit));
+		MARK_RING(chan, 3, 3);
+		OUT_RELOC(chan, bo, RING_3D(NV34TCL_TX_OFFSET(unit), 2), tex_flags | NOUVEAU_BO_DUMMY, 0, 0);
+		OUT_RELOC(chan, bo, 0, tex_flags | NOUVEAU_BO_LOW | NOUVEAU_BO_DUMMY, 0, 0);
+		OUT_RELOC(chan, bo, nvfx->hw_txf[unit], tex_flags | NOUVEAU_BO_OR | NOUVEAU_BO_DUMMY,
+				NV34TCL_TX_FORMAT_DMA0, NV34TCL_TX_FORMAT_DMA1);
 	}
-
-	nvfx->state.fp_samplers = fp->samplers;
-	return FALSE;
 }
-
-struct nvfx_state_entry nvfx_state_fragtex = {
-	.validate = nvfx_fragtex_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_SAMPLER | NVFX_NEW_FRAGPROG,
-		.hw = 0
-	}
-};
diff --git a/src/gallium/drivers/nvfx/nvfx_miptree.c b/src/gallium/drivers/nvfx/nvfx_miptree.c
index 9de25175e78..602a4768d4e 100644
--- a/src/gallium/drivers/nvfx/nvfx_miptree.c
+++ b/src/gallium/drivers/nvfx/nvfx_miptree.c
@@ -5,22 +5,30 @@
 #include "util/u_math.h"
 
 #include "nvfx_context.h"
+#include "nvfx_resource.h"
+#include "nvfx_transfer.h"
 #include "nv04_surface_2d.h"
 
+#include "nouveau/nouveau_util.h"
 
+/* Currently using separate implementations for buffers and textures,
+ * even though gallium has a unified abstraction of these objects.
+ * Eventually these should be combined, and mechanisms like transfers
+ * be adapted to work for both buffer and texture uploads.
+ */
 
 static void
 nvfx_miptree_layout(struct nvfx_miptree *mt)
 {
-	struct pipe_texture *pt = &mt->base;
+	struct pipe_resource *pt = &mt->base.base;
 	uint width = pt->width0;
 	uint offset = 0;
 	int nr_faces, l, f;
-	uint wide_pitch = pt->tex_usage & (PIPE_TEXTURE_USAGE_SAMPLER |
-		                           PIPE_TEXTURE_USAGE_DEPTH_STENCIL |
-		                           PIPE_TEXTURE_USAGE_RENDER_TARGET |
-		                           PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-		                           PIPE_TEXTURE_USAGE_SCANOUT);
+	uint wide_pitch = pt->bind & (PIPE_BIND_SAMPLER_VIEW |
+				      PIPE_BIND_DEPTH_STENCIL |
+				      PIPE_BIND_RENDER_TARGET |
+				      PIPE_BIND_DISPLAY_TARGET |
+				      PIPE_BIND_SCANOUT);
 
 	if (pt->target == PIPE_TEXTURE_CUBE) {
 		nr_faces = 6;
@@ -32,7 +40,7 @@ nvfx_miptree_layout(struct nvfx_miptree *mt)
 	}
 
 	for (l = 0; l <= pt->last_level; l++) {
-		if (wide_pitch && (pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR))
+		if (wide_pitch && (pt->flags & NVFX_RESOURCE_FLAG_LINEAR))
 			mt->level[l].pitch = align(util_format_get_stride(pt->format, pt->width0), 64);
 		else
 			mt->level[l].pitch = util_format_get_stride(pt->format, width);
@@ -47,7 +55,7 @@ nvfx_miptree_layout(struct nvfx_miptree *mt)
 		for (l = 0; l < pt->last_level; l++) {
 			mt->level[l].image_offset[f] = offset;
 
-			if (!(pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR) &&
+			if (!(pt->flags & NVFX_RESOURCE_FLAG_LINEAR) &&
 			    u_minify(pt->width0, l + 1) > 1 && u_minify(pt->height0, l + 1) > 1)
 				offset += align(mt->level[l].pitch * u_minify(pt->height0, l), 64);
 			else
@@ -61,35 +69,86 @@ nvfx_miptree_layout(struct nvfx_miptree *mt)
 	mt->total_size = offset;
 }
 
-static struct pipe_texture *
-nvfx_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
+static boolean
+nvfx_miptree_get_handle(struct pipe_screen *pscreen,
+			struct pipe_resource *ptexture,
+			struct winsys_handle *whandle)
+{
+	struct nvfx_miptree* mt = (struct nvfx_miptree*)ptexture;
+
+	if (!mt || !mt->base.bo)
+		return FALSE;
+
+	return nouveau_screen_bo_get_handle(pscreen,
+					    mt->base.bo,
+					    mt->level[0].pitch,
+					    whandle);
+}
+
+
+static void
+nvfx_miptree_destroy(struct pipe_screen *screen, struct pipe_resource *pt)
+{
+	struct nvfx_miptree *mt = (struct nvfx_miptree *)pt;
+	int l;
+
+	nouveau_screen_bo_release(screen, mt->base.bo);
+
+	for (l = 0; l <= pt->last_level; l++) {
+		if (mt->level[l].image_offset)
+			FREE(mt->level[l].image_offset);
+	}
+
+	FREE(mt);
+}
+
+
+
+
+struct u_resource_vtbl nvfx_miptree_vtbl = 
+{
+   nvfx_miptree_get_handle,	      /* get_handle */
+   nvfx_miptree_destroy,	      /* resource_destroy */
+   NULL,			      /* is_resource_referenced */
+   nvfx_miptree_transfer_new,	      /* get_transfer */
+   nvfx_miptree_transfer_del,     /* transfer_destroy */
+   nvfx_miptree_transfer_map,	      /* transfer_map */
+   u_default_transfer_flush_region,   /* transfer_flush_region */
+   nvfx_miptree_transfer_unmap,	      /* transfer_unmap */
+   u_default_transfer_inline_write    /* transfer_inline_write */
+};
+
+
+
+struct pipe_resource *
+nvfx_miptree_create(struct pipe_screen *pscreen, const struct pipe_resource *pt)
 {
 	struct nvfx_miptree *mt;
-	unsigned buf_usage = PIPE_BUFFER_USAGE_PIXEL |
-	                     NOUVEAU_BUFFER_USAGE_TEXTURE;
 	static int no_swizzle = -1;
 	if(no_swizzle < 0)
 		no_swizzle = debug_get_bool_option("NOUVEAU_NO_SWIZZLE", FALSE);
 
-	mt = MALLOC(sizeof(struct nvfx_miptree));
+	mt = CALLOC_STRUCT(nvfx_miptree);
 	if (!mt)
 		return NULL;
-	mt->base = *pt;
-	pipe_reference_init(&mt->base.reference, 1);
-	mt->base.screen = pscreen;
+
+	mt->base.base = *pt;
+	mt->base.vtbl = &nvfx_miptree_vtbl;
+	pipe_reference_init(&mt->base.base.reference, 1);
+	mt->base.base.screen = pscreen;
 
 	/* Swizzled textures must be POT */
 	if (pt->width0 & (pt->width0 - 1) ||
 	    pt->height0 & (pt->height0 - 1))
-		mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
+		mt->base.base.flags |= NVFX_RESOURCE_FLAG_LINEAR;
 	else
-	if (pt->tex_usage & (PIPE_TEXTURE_USAGE_SCANOUT |
-	                     PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-	                     PIPE_TEXTURE_USAGE_DEPTH_STENCIL))
-		mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
+	if (pt->bind & (PIPE_BIND_SCANOUT |
+			PIPE_BIND_DISPLAY_TARGET |
+			PIPE_BIND_DEPTH_STENCIL))
+		mt->base.base.flags |= NVFX_RESOURCE_FLAG_LINEAR;
 	else
-	if (pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC)
-		mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
+	if (pt->_usage == PIPE_USAGE_DYNAMIC)
+		mt->base.base.flags |= NVFX_RESOURCE_FLAG_LINEAR;
 	else {
 		switch (pt->format) {
 		case PIPE_FORMAT_B5G6R5_UNORM:
@@ -101,7 +160,7 @@ nvfx_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 				are just preserving the pre-unification behavior.
 				The whole 2D code is going to be rewritten anyway. */
 			if(nvfx_screen(pscreen)->is_nv4x) {
-				mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
+				mt->base.base.flags |= NVFX_RESOURCE_FLAG_LINEAR;
 				break;
 			}
 		/* TODO: Figure out which formats can be swizzled */
@@ -110,80 +169,83 @@ nvfx_miptree_create(struct pipe_screen *pscreen, const struct pipe_texture *pt)
 		case PIPE_FORMAT_R16_SNORM:
 		{
 			if (no_swizzle)
-				mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
+				mt->base.base.flags |= NVFX_RESOURCE_FLAG_LINEAR;
 			break;
 		}
 		default:
-			mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
+			mt->base.base.flags |= NVFX_RESOURCE_FLAG_LINEAR;
 		}
 	}
 
-	if (pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC)
-		buf_usage |= PIPE_BUFFER_USAGE_CPU_READ_WRITE;
-
 	/* apparently we can't render to swizzled surfaces smaller than 64 bytes, so make them linear.
 	 * If the user did not ask for a render target, they can still render to it, but it will cost them an extra copy.
 	 * This also happens for small mipmaps of large textures. */
-	if (pt->tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET && util_format_get_stride(pt->format, pt->width0) < 64)
-		mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
+	if (pt->bind & PIPE_BIND_RENDER_TARGET &&
+	    util_format_get_stride(pt->format, pt->width0) < 64)
+		mt->base.base.flags |= NVFX_RESOURCE_FLAG_LINEAR;
 
 	nvfx_miptree_layout(mt);
 
-	mt->buffer = pscreen->buffer_create(pscreen, 256, buf_usage, mt->total_size);
-	if (!mt->buffer) {
+	mt->base.bo = nouveau_screen_bo_new(pscreen, 256,
+            pt->_usage, pt->bind, mt->total_size);
+	if (!mt->base.bo) {
 		FREE(mt);
 		return NULL;
 	}
-	mt->bo = nouveau_bo(mt->buffer);
-	return &mt->base;
+	return &mt->base.base;
 }
 
-static struct pipe_texture *
-nvfx_miptree_blanket(struct pipe_screen *pscreen, const struct pipe_texture *pt,
-		     const unsigned *stride, struct pipe_buffer *pb)
+
+
+
+struct pipe_resource *
+nvfx_miptree_from_handle(struct pipe_screen *pscreen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle)
 {
 	struct nvfx_miptree *mt;
+	unsigned stride;
 
 	/* Only supports 2D, non-mipmapped textures for the moment */
-	if (pt->target != PIPE_TEXTURE_2D || pt->last_level != 0 ||
-	    pt->depth0 != 1)
+	if (template->target != PIPE_TEXTURE_2D ||
+	    template->last_level != 0 ||
+	    template->depth0 != 1)
 		return NULL;
 
 	mt = CALLOC_STRUCT(nvfx_miptree);
 	if (!mt)
 		return NULL;
 
-	mt->base = *pt;
-	pipe_reference_init(&mt->base.reference, 1);
-	mt->base.screen = pscreen;
-	mt->level[0].pitch = stride[0];
+	mt->base.bo = nouveau_screen_bo_from_handle(pscreen, whandle, &stride);
+	if (mt->base.bo == NULL) {
+		FREE(mt);
+		return NULL;
+	}
+
+	mt->base.base = *template;
+	mt->base.vtbl = &nvfx_miptree_vtbl;
+	pipe_reference_init(&mt->base.base.reference, 1);
+	mt->base.base.screen = pscreen;
+	mt->level[0].pitch = stride;
 	mt->level[0].image_offset = CALLOC(1, sizeof(unsigned));
 
 	/* Assume whoever created this buffer expects it to be linear for now */
-	mt->base.tex_usage |= NOUVEAU_TEXTURE_USAGE_LINEAR;
+	mt->base.base.flags |= NVFX_RESOURCE_FLAG_LINEAR;
 
-	pipe_buffer_reference(&mt->buffer, pb);
-	mt->bo = nouveau_bo(mt->buffer);
-	return &mt->base;
+	/* XXX: Need to adjust bo refcount??
+	 */
+	/* nouveau_bo_ref(bo, &mt->base.bo); */
+	return &mt->base.base;
 }
 
-static void
-nvfx_miptree_destroy(struct pipe_texture *pt)
-{
-	struct nvfx_miptree *mt = (struct nvfx_miptree *)pt;
-	int l;
 
-	pipe_buffer_reference(&mt->buffer, NULL);
-	for (l = 0; l <= pt->last_level; l++) {
-		if (mt->level[l].image_offset)
-			FREE(mt->level[l].image_offset);
-	}
 
-	FREE(mt);
-}
 
-static struct pipe_surface *
-nvfx_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
+
+/* Surface helpers, not strictly required to implement the resource vtbl:
+ */
+struct pipe_surface *
+nvfx_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_resource *pt,
 			 unsigned face, unsigned level, unsigned zslice,
 			 unsigned flags)
 {
@@ -193,7 +255,7 @@ nvfx_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
 	ns = CALLOC_STRUCT(nv04_surface);
 	if (!ns)
 		return NULL;
-	pipe_texture_reference(&ns->base.texture, pt);
+	pipe_resource_reference(&ns->base.texture, pt);
 	ns->base.format = pt->format;
 	ns->base.width = u_minify(pt->width0, level);
 	ns->base.height = u_minify(pt->height0, level);
@@ -213,38 +275,38 @@ nvfx_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_texture *pt,
 		ns->base.offset = mt->level[level].image_offset[0];
 	}
 
-	/* create a linear temporary that we can render into if necessary.
-	 * Note that ns->pitch is always a multiple of 64 for linear surfaces and swizzled surfaces are POT, so
-	 * ns->pitch & 63 is equivalent to (ns->pitch < 64 && swizzled)*/
-	if((ns->pitch & 63) && (ns->base.usage & (PIPE_BUFFER_USAGE_GPU_WRITE | NOUVEAU_BUFFER_USAGE_NO_RENDER)) == PIPE_BUFFER_USAGE_GPU_WRITE)
-		return &nv04_surface_wrap_for_render(pscreen, ((struct nvfx_screen*)pscreen)->eng2d, ns)->base;
+	/* create a linear temporary that we can render into if
+	 * necessary.
+	 *
+	 * Note that ns->pitch is always a multiple of 64 for linear
+	 * surfaces and swizzled surfaces are POT, so ns->pitch & 63
+	 * is equivalent to (ns->pitch < 64 && swizzled)
+	 */
+
+	if ((ns->pitch & 63) && 
+	    (ns->base.usage & PIPE_BIND_RENDER_TARGET))
+	{
+		struct nv04_surface_2d* eng2d  =
+			((struct nvfx_screen*)pscreen)->eng2d;
+
+		ns = nv04_surface_wrap_for_render(pscreen, eng2d, ns);
+	}
 
 	return &ns->base;
 }
 
-static void
+void
 nvfx_miptree_surface_del(struct pipe_surface *ps)
 {
 	struct nv04_surface* ns = (struct nv04_surface*)ps;
 	if(ns->backing)
 	{
 		struct nvfx_screen* screen = (struct nvfx_screen*)ps->texture->screen;
-		if(ns->backing->base.usage & PIPE_BUFFER_USAGE_GPU_WRITE)
+		if(ns->backing->base.usage & PIPE_BIND_BLIT_DESTINATION)
 			screen->eng2d->copy(screen->eng2d, &ns->backing->base, 0, 0, ps, 0, 0, ns->base.width, ns->base.height);
 		nvfx_miptree_surface_del(&ns->backing->base);
 	}
 
-	pipe_texture_reference(&ps->texture, NULL);
+	pipe_resource_reference(&ps->texture, NULL);
 	FREE(ps);
 }
-
-void
-nvfx_screen_init_miptree_functions(struct pipe_screen *pscreen)
-{
-	pscreen->texture_create = nvfx_miptree_create;
-	pscreen->texture_destroy = nvfx_miptree_destroy;
-	pscreen->get_tex_surface = nvfx_miptree_surface_new;
-	pscreen->tex_surface_destroy = nvfx_miptree_surface_del;
-
-	nouveau_screen(pscreen)->texture_blanket = nvfx_miptree_blanket;
-}
diff --git a/src/gallium/drivers/nvfx/nvfx_query.c b/src/gallium/drivers/nvfx/nvfx_query.c
index acbaf75a236..1b20b5245d7 100644
--- a/src/gallium/drivers/nvfx/nvfx_query.c
+++ b/src/gallium/drivers/nvfx/nvfx_query.c
@@ -3,6 +3,7 @@
 #include "nvfx_context.h"
 
 struct nvfx_query {
+	struct list_head list;
 	struct nouveau_resource *object;
 	unsigned type;
 	boolean ready;
@@ -23,6 +24,8 @@ nvfx_query_create(struct pipe_context *pipe, unsigned query_type)
 	q = CALLOC(1, sizeof(struct nvfx_query));
 	q->type = query_type;
 
+	assert(q->type == PIPE_QUERY_OCCLUSION_COUNTER);
+
 	return (struct pipe_query *)q;
 }
 
@@ -32,7 +35,10 @@ nvfx_query_destroy(struct pipe_context *pipe, struct pipe_query *pq)
 	struct nvfx_query *q = nvfx_query(pq);
 
 	if (q->object)
+	{
 		nouveau_resource_free(&q->object);
+		LIST_DEL(&q->list);
+	}
 	FREE(q);
 }
 
@@ -44,20 +50,25 @@ nvfx_query_begin(struct pipe_context *pipe, struct pipe_query *pq)
 	struct nvfx_screen *screen = nvfx->screen;
 	struct nouveau_channel *chan = screen->base.channel;
 	struct nouveau_grobj *eng3d = screen->eng3d;
-
-	assert(q->type == PIPE_QUERY_OCCLUSION_COUNTER);
+	uint64_t tmp;
 
 	/* Happens when end_query() is called, then another begin_query()
 	 * without querying the result in-between.  For now we'll wait for
 	 * the existing query to notify completion, but it could be better.
 	 */
-	if (q->object) {
-		uint64_t tmp;
+	if (q->object)
 		pipe->get_query_result(pipe, pq, 1, &tmp);
+
+	while (nouveau_resource_alloc(nvfx->screen->query_heap, 1, NULL, &q->object))
+	{
+		struct nvfx_query* oldestq;
+		assert(!LIST_IS_EMPTY(&nvfx->screen->query_list));
+		oldestq = LIST_ENTRY(struct nvfx_query, nvfx->screen->query_list.next, list);
+		pipe->get_query_result(pipe, (struct pipe_query*)oldestq, 1, &tmp);
 	}
 
-	if (nouveau_resource_alloc(nvfx->screen->query_heap, 1, NULL, &q->object))
-		assert(0);
+	LIST_ADDTAIL(&q->list, &nvfx->screen->query_list);
+
 	nouveau_notifier_reset(nvfx->screen->query, q->object->start);
 
 	BEGIN_RING(chan, eng3d, NV34TCL_QUERY_RESET, 1);
@@ -90,8 +101,6 @@ nvfx_query_result(struct pipe_context *pipe, struct pipe_query *pq,
 	struct nvfx_context *nvfx = nvfx_context(pipe);
 	struct nvfx_query *q = nvfx_query(pq);
 
-	assert(q->object && q->type == PIPE_QUERY_OCCLUSION_COUNTER);
-
 	if (!q->ready) {
 		unsigned status;
 
@@ -110,6 +119,7 @@ nvfx_query_result(struct pipe_context *pipe, struct pipe_query *pq,
 							q->object->start);
 		q->ready = TRUE;
 		nouveau_resource_free(&q->object);
+		LIST_DEL(&q->list);
 	}
 
 	*result = q->result;
diff --git a/src/gallium/drivers/nvfx/nvfx_resource.c b/src/gallium/drivers/nvfx/nvfx_resource.c
new file mode 100644
index 00000000000..10cdeed2a37
--- /dev/null
+++ b/src/gallium/drivers/nvfx/nvfx_resource.c
@@ -0,0 +1,67 @@
+
+#include "pipe/p_context.h"
+#include "nvfx_resource.h"
+#include "nouveau/nouveau_screen.h"
+
+
+/* This doesn't look quite right - this query is supposed to ask
+ * whether the particular context has references to the resource in
+ * any unflushed rendering command buffer, and hence requires a
+ * pipe->flush() for serializing some modification to that resource.
+ *
+ * This seems to be answering the question of whether the resource is
+ * currently on hardware.
+ */
+static unsigned int
+nvfx_resource_is_referenced(struct pipe_context *pipe,
+			    struct pipe_resource *resource,
+			    unsigned face, unsigned level)
+{
+	return nouveau_reference_flags(nvfx_resource(resource)->bo);
+}
+
+static struct pipe_resource *
+nvfx_resource_create(struct pipe_screen *screen,
+		     const struct pipe_resource *template)
+{
+	if (template->target == PIPE_BUFFER)
+		return nvfx_buffer_create(screen, template);
+	else
+		return nvfx_miptree_create(screen, template);
+}
+
+static struct pipe_resource *
+nvfx_resource_from_handle(struct pipe_screen * screen,
+			  const struct pipe_resource *template,
+			  struct winsys_handle *whandle)
+{
+	if (template->target == PIPE_BUFFER)
+		return NULL;
+	else
+		return nvfx_miptree_from_handle(screen, template, whandle);
+}
+
+void
+nvfx_init_resource_functions(struct pipe_context *pipe)
+{
+	pipe->get_transfer = u_get_transfer_vtbl;
+	pipe->transfer_map = u_transfer_map_vtbl;
+	pipe->transfer_flush_region = u_transfer_flush_region_vtbl;
+	pipe->transfer_unmap = u_transfer_unmap_vtbl;
+	pipe->transfer_destroy = u_transfer_destroy_vtbl;
+	pipe->transfer_inline_write = u_transfer_inline_write_vtbl;
+	pipe->is_resource_referenced = nvfx_resource_is_referenced;
+}
+
+void
+nvfx_screen_init_resource_functions(struct pipe_screen *pscreen)
+{
+	pscreen->resource_create = nvfx_resource_create;
+	pscreen->resource_from_handle = nvfx_resource_from_handle;
+	pscreen->resource_get_handle = u_resource_get_handle_vtbl;
+	pscreen->resource_destroy = u_resource_destroy_vtbl;
+	pscreen->user_buffer_create = nvfx_user_buffer_create;
+   
+	pscreen->get_tex_surface = nvfx_miptree_surface_new;
+	pscreen->tex_surface_destroy = nvfx_miptree_surface_del;
+}
diff --git a/src/gallium/drivers/nvfx/nvfx_resource.h b/src/gallium/drivers/nvfx/nvfx_resource.h
new file mode 100644
index 00000000000..a68c14cf3fb
--- /dev/null
+++ b/src/gallium/drivers/nvfx/nvfx_resource.h
@@ -0,0 +1,91 @@
+
+#ifndef NVFX_RESOURCE_H
+#define NVFX_RESOURCE_H
+
+#include "util/u_transfer.h"
+
+struct pipe_resource;
+struct nouveau_bo;
+
+
+/* This gets further specialized into either buffer or texture
+ * structures.  In the future we'll want to remove much of that
+ * distinction, but for now try to keep as close to the existing code
+ * as possible and use the vtbl struct to choose between the two
+ * underlying implementations.
+ */
+struct nvfx_resource {
+	struct pipe_resource base;
+	struct u_resource_vtbl *vtbl;
+	struct nouveau_bo *bo;
+};
+
+#define NVFX_MAX_TEXTURE_LEVELS  16
+
+struct nvfx_miptree {
+	struct nvfx_resource base;
+	uint total_size;
+
+	struct {
+		uint pitch;
+		uint *image_offset;
+	} level[NVFX_MAX_TEXTURE_LEVELS];
+
+	unsigned image_nr;
+};
+
+static INLINE 
+struct nvfx_resource *nvfx_resource(struct pipe_resource *resource)
+{
+	return (struct nvfx_resource *)resource;
+}
+
+static INLINE struct nouveau_bo *
+nvfx_surface_buffer(struct pipe_surface *surf)
+{
+	struct nvfx_resource *mt = nvfx_resource(surf->texture);
+
+	return mt->bo;
+}
+
+
+void
+nvfx_init_resource_functions(struct pipe_context *pipe);
+
+void
+nvfx_screen_init_resource_functions(struct pipe_screen *pscreen);
+
+
+/* Internal:
+ */
+
+struct pipe_resource *
+nvfx_miptree_create(struct pipe_screen *pscreen, const struct pipe_resource *pt);
+
+struct pipe_resource *
+nvfx_miptree_from_handle(struct pipe_screen *pscreen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle);
+
+struct pipe_resource *
+nvfx_buffer_create(struct pipe_screen *pscreen,
+		   const struct pipe_resource *template);
+
+struct pipe_resource *
+nvfx_user_buffer_create(struct pipe_screen *screen,
+			void *ptr,
+			unsigned bytes,
+			unsigned usage);
+
+
+
+void
+nvfx_miptree_surface_del(struct pipe_surface *ps);
+
+struct pipe_surface *
+nvfx_miptree_surface_new(struct pipe_screen *pscreen, struct pipe_resource *pt,
+			 unsigned face, unsigned level, unsigned zslice,
+			 unsigned flags);
+
+
+#endif
diff --git a/src/gallium/drivers/nvfx/nvfx_screen.c b/src/gallium/drivers/nvfx/nvfx_screen.c
index 1a103520a3c..04b456d4087 100644
--- a/src/gallium/drivers/nvfx/nvfx_screen.c
+++ b/src/gallium/drivers/nvfx/nvfx_screen.c
@@ -1,10 +1,12 @@
 #include "pipe/p_screen.h"
 #include "pipe/p_state.h"
+#include "util/u_simple_screen.h"
 
 #include "nouveau/nouveau_screen.h"
 
 #include "nvfx_context.h"
 #include "nvfx_screen.h"
+#include "nvfx_resource.h"
 
 #define NV30TCL_CHIPSET_3X_MASK 0x00000003
 #define NV34TCL_CHIPSET_3X_MASK 0x00000010
@@ -67,10 +69,6 @@ nvfx_screen_get_param(struct pipe_screen *pscreen, int param)
 		return 0;
 	case PIPE_CAP_BLEND_EQUATION_SEPARATE:
 		return !!screen->is_nv4x;
-	case NOUVEAU_CAP_HW_VTXBUF:
-		return 0;
-	case NOUVEAU_CAP_HW_IDXBUF:
-		return 0;
 	case PIPE_CAP_MAX_COMBINED_SAMPLERS:
 		return 16;
 	case PIPE_CAP_INDEP_BLEND_ENABLE:
@@ -122,16 +120,17 @@ nvfx_screen_surface_format_supported(struct pipe_screen *pscreen,
 	struct nvfx_screen *screen = nvfx_screen(pscreen);
 	struct pipe_surface *front = ((struct nouveau_winsys *) pscreen->winsys)->front;
 
-	if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET) {
+	if (tex_usage & PIPE_BIND_RENDER_TARGET) {
 		switch (format) {
 		case PIPE_FORMAT_B8G8R8A8_UNORM:
+		case PIPE_FORMAT_B8G8R8X8_UNORM:
 		case PIPE_FORMAT_B5G6R5_UNORM:
 			return TRUE;
 		default:
 			break;
 		}
 	} else
-	if (tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL) {
+	if (tex_usage & PIPE_BIND_DEPTH_STENCIL) {
 		switch (format) {
 		case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 		case PIPE_FORMAT_X8Z24_UNORM:
@@ -147,6 +146,7 @@ nvfx_screen_surface_format_supported(struct pipe_screen *pscreen,
 	} else {
 		switch (format) {
 		case PIPE_FORMAT_B8G8R8A8_UNORM:
+		case PIPE_FORMAT_B8G8R8X8_UNORM:
 		case PIPE_FORMAT_B5G5R5A1_UNORM:
 		case PIPE_FORMAT_B4G4R4A4_UNORM:
 		case PIPE_FORMAT_B5G6R5_UNORM:
@@ -172,24 +172,11 @@ nvfx_screen_surface_format_supported(struct pipe_screen *pscreen,
 	return FALSE;
 }
 
-static struct pipe_buffer *
-nvfx_surface_buffer(struct pipe_surface *surf)
-{
-	struct nvfx_miptree *mt = (struct nvfx_miptree *)surf->texture;
-
-	return mt->buffer;
-}
 
 static void
 nvfx_screen_destroy(struct pipe_screen *pscreen)
 {
 	struct nvfx_screen *screen = nvfx_screen(pscreen);
-	unsigned i;
-
-	for (i = 0; i < NVFX_STATE_MAX; i++) {
-		if (screen->state[i])
-			so_ref(NULL, &screen->state[i]);
-	}
 
 	nouveau_resource_destroy(&screen->vp_exec_heap);
 	nouveau_resource_destroy(&screen->vp_data_heap);
@@ -204,97 +191,100 @@ nvfx_screen_destroy(struct pipe_screen *pscreen)
 	FREE(pscreen);
 }
 
-static void nv30_screen_init(struct nvfx_screen *screen, struct nouveau_stateobj* so)
+static void nv30_screen_init(struct nvfx_screen *screen)
 {
+	struct nouveau_channel *chan = screen->base.channel;
 	int i;
 
 	/* TODO: perhaps we should do some of this on nv40 too? */
 	for (i=1; i<8; i++) {
-		so_method(so, screen->eng3d, NV34TCL_VIEWPORT_CLIP_HORIZ(i), 1);
-		so_data  (so, 0);
-		so_method(so, screen->eng3d, NV34TCL_VIEWPORT_CLIP_VERT(i), 1);
-		so_data  (so, 0);
+		OUT_RING(chan, RING_3D(NV34TCL_VIEWPORT_CLIP_HORIZ(i), 1));
+		OUT_RING(chan, 0);
+		OUT_RING(chan, RING_3D(NV34TCL_VIEWPORT_CLIP_VERT(i), 1));
+		OUT_RING(chan, 0);
 	}
 
-	so_method(so, screen->eng3d, 0x220, 1);
-	so_data  (so, 1);
+	OUT_RING(chan, RING_3D(0x220, 1));
+	OUT_RING(chan, 1);
 
-	so_method(so, screen->eng3d, 0x03b0, 1);
-	so_data  (so, 0x00100000);
-	so_method(so, screen->eng3d, 0x1454, 1);
-	so_data  (so, 0);
-	so_method(so, screen->eng3d, 0x1d80, 1);
-	so_data  (so, 3);
-	so_method(so, screen->eng3d, 0x1450, 1);
-	so_data  (so, 0x00030004);
+	OUT_RING(chan, RING_3D(0x03b0, 1));
+	OUT_RING(chan, 0x00100000);
+	OUT_RING(chan, RING_3D(0x1454, 1));
+	OUT_RING(chan, 0);
+	OUT_RING(chan, RING_3D(0x1d80, 1));
+	OUT_RING(chan, 3);
+	OUT_RING(chan, RING_3D(0x1450, 1));
+	OUT_RING(chan, 0x00030004);
 
 	/* NEW */
-	so_method(so, screen->eng3d, 0x1e98, 1);
-	so_data  (so, 0);
-	so_method(so, screen->eng3d, 0x17e0, 3);
-	so_data  (so, fui(0.0));
-	so_data  (so, fui(0.0));
-	so_data  (so, fui(1.0));
-	so_method(so, screen->eng3d, 0x1f80, 16);
+	OUT_RING(chan, RING_3D(0x1e98, 1));
+	OUT_RING(chan, 0);
+	OUT_RING(chan, RING_3D(0x17e0, 3));
+	OUT_RING(chan, fui(0.0));
+	OUT_RING(chan, fui(0.0));
+	OUT_RING(chan, fui(1.0));
+	OUT_RING(chan, RING_3D(0x1f80, 16));
 	for (i=0; i<16; i++) {
-		so_data  (so, (i==8) ? 0x0000ffff : 0);
+		OUT_RING(chan, (i==8) ? 0x0000ffff : 0);
 	}
 
-	so_method(so, screen->eng3d, 0x120, 3);
-	so_data  (so, 0);
-	so_data  (so, 1);
-	so_data  (so, 2);
+	OUT_RING(chan, RING_3D(0x120, 3));
+	OUT_RING(chan, 0);
+	OUT_RING(chan, 1);
+	OUT_RING(chan, 2);
 
-	so_method(so, screen->eng3d, 0x1d88, 1);
-	so_data  (so, 0x00001200);
+	OUT_RING(chan, RING_3D(0x1d88, 1));
+	OUT_RING(chan, 0x00001200);
 
-	so_method(so, screen->eng3d, NV34TCL_RC_ENABLE, 1);
-	so_data  (so, 0);
+	OUT_RING(chan, RING_3D(NV34TCL_RC_ENABLE, 1));
+	OUT_RING(chan, 0);
 
-	so_method(so, screen->eng3d, NV34TCL_DEPTH_RANGE_NEAR, 2);
-	so_data  (so, fui(0.0));
-	so_data  (so, fui(1.0));
+	OUT_RING(chan, RING_3D(NV34TCL_DEPTH_RANGE_NEAR, 2));
+	OUT_RING(chan, fui(0.0));
+	OUT_RING(chan, fui(1.0));
 
-	so_method(so, screen->eng3d, NV34TCL_MULTISAMPLE_CONTROL, 1);
-	so_data  (so, 0xffff0000);
+	OUT_RING(chan, RING_3D(NV34TCL_MULTISAMPLE_CONTROL, 1));
+	OUT_RING(chan, 0xffff0000);
 
 	/* enables use of vp rather than fixed-function somehow */
-	so_method(so, screen->eng3d, 0x1e94, 1);
-	so_data  (so, 0x13);
+	OUT_RING(chan, RING_3D(0x1e94, 1));
+	OUT_RING(chan, 0x13);
 }
 
-static void nv40_screen_init(struct nvfx_screen *screen, struct nouveau_stateobj* so)
+static void nv40_screen_init(struct nvfx_screen *screen)
 {
-	so_method(so, screen->eng3d, NV40TCL_DMA_COLOR2, 2);
-	so_data  (so, screen->base.channel->vram->handle);
-	so_data  (so, screen->base.channel->vram->handle);
+	struct nouveau_channel *chan = screen->base.channel;
+
+	OUT_RING(chan, RING_3D(NV40TCL_DMA_COLOR2, 2));
+	OUT_RING(chan, screen->base.channel->vram->handle);
+	OUT_RING(chan, screen->base.channel->vram->handle);
 
-	so_method(so, screen->eng3d, 0x1ea4, 3);
-	so_data  (so, 0x00000010);
-	so_data  (so, 0x01000100);
-	so_data  (so, 0xff800006);
+	OUT_RING(chan, RING_3D(0x1ea4, 3));
+	OUT_RING(chan, 0x00000010);
+	OUT_RING(chan, 0x01000100);
+	OUT_RING(chan, 0xff800006);
 
 	/* vtxprog output routing */
-	so_method(so, screen->eng3d, 0x1fc4, 1);
-	so_data  (so, 0x06144321);
-	so_method(so, screen->eng3d, 0x1fc8, 2);
-	so_data  (so, 0xedcba987);
-	so_data  (so, 0x00000021);
-	so_method(so, screen->eng3d, 0x1fd0, 1);
-	so_data  (so, 0x00171615);
-	so_method(so, screen->eng3d, 0x1fd4, 1);
-	so_data  (so, 0x001b1a19);
-
-	so_method(so, screen->eng3d, 0x1ef8, 1);
-	so_data  (so, 0x0020ffff);
-	so_method(so, screen->eng3d, 0x1d64, 1);
-	so_data  (so, 0x00d30000);
-	so_method(so, screen->eng3d, 0x1e94, 1);
-	so_data  (so, 0x00000001);
+	OUT_RING(chan, RING_3D(0x1fc4, 1));
+	OUT_RING(chan, 0x06144321);
+	OUT_RING(chan, RING_3D(0x1fc8, 2));
+	OUT_RING(chan, 0xedcba987);
+	OUT_RING(chan, 0x00000021);
+	OUT_RING(chan, RING_3D(0x1fd0, 1));
+	OUT_RING(chan, 0x00171615);
+	OUT_RING(chan, RING_3D(0x1fd4, 1));
+	OUT_RING(chan, 0x001b1a19);
+
+	OUT_RING(chan, RING_3D(0x1ef8, 1));
+	OUT_RING(chan, 0x0020ffff);
+	OUT_RING(chan, RING_3D(0x1d64, 1));
+	OUT_RING(chan, 0x00d30000);
+	OUT_RING(chan, RING_3D(0x1e94, 1));
+	OUT_RING(chan, 0x00000001);
 }
 
-static void
-nvfx_screen_init_buffer_functions(struct nvfx_screen* screen)
+static unsigned
+nvfx_screen_get_vertex_buffer_flags(struct nvfx_screen* screen)
 {
 	int vram_hack_default = 0;
 	int vram_hack;
@@ -320,7 +310,7 @@ nvfx_screen_init_buffer_functions(struct nvfx_screen* screen)
 	}
 #endif
 
-	screen->vertex_buffer_flags = vram_hack ? NOUVEAU_BO_VRAM : NOUVEAU_BO_GART;
+	return vram_hack ? NOUVEAU_BO_VRAM : NOUVEAU_BO_GART;
 }
 
 struct pipe_screen *
@@ -329,9 +319,8 @@ nvfx_screen_create(struct pipe_winsys *ws, struct nouveau_device *dev)
 	struct nvfx_screen *screen = CALLOC_STRUCT(nvfx_screen);
 	struct nouveau_channel *chan;
 	struct pipe_screen *pscreen;
-	struct nouveau_stateobj *so;
 	unsigned eng3d_class = 0;
-	int ret;
+	int ret, i;
 
 	if (!screen)
 		return NULL;
@@ -380,8 +369,18 @@ nvfx_screen_create(struct pipe_winsys *ws, struct nouveau_device *dev)
 		return NULL;
 	}
 
-	nvfx_screen_init_buffer_functions(screen);
-	nvfx_screen_init_miptree_functions(pscreen);
+	screen->force_swtnl = debug_get_bool_option("NOUVEAU_SWTNL", FALSE);
+
+	screen->vertex_buffer_reloc_flags = nvfx_screen_get_vertex_buffer_flags(screen);
+
+	/* surely both nv3x and nv44 support index buffers too: find out how and test that */
+	if(eng3d_class == NV40TCL)
+		screen->index_buffer_reloc_flags = screen->vertex_buffer_reloc_flags;
+
+	if(!screen->force_swtnl && screen->vertex_buffer_reloc_flags == screen->index_buffer_reloc_flags)
+		screen->base.vertex_buffer_flags = screen->base.index_buffer_flags = screen->vertex_buffer_reloc_flags;
+
+	nvfx_screen_init_resource_functions(pscreen);
 
 	ret = nouveau_grobj_alloc(chan, 0xbeef3097, eng3d_class, &screen->eng3d);
 	if (ret) {
@@ -402,20 +401,29 @@ nvfx_screen_create(struct pipe_winsys *ws, struct nouveau_device *dev)
 	}
 
 	/* Query objects */
-	ret = nouveau_notifier_alloc(chan, 0xbeef0302, 32, &screen->query);
+	unsigned query_sizes[] = {(4096 - 4 * 32) / 32, 3 * 1024 / 32, 2 * 1024 / 32, 1024 / 32};
+	for(i = 0; i < sizeof(query_sizes) / sizeof(query_sizes[0]); ++i)
+	{
+		ret = nouveau_notifier_alloc(chan, 0xbeef0302, query_sizes[i], &screen->query);
+		if(!ret)
+			break;
+	}
+
 	if (ret) {
 		NOUVEAU_ERR("Error initialising query objects: %d\n", ret);
 		nvfx_screen_destroy(pscreen);
 		return NULL;
 	}
 
-	ret = nouveau_resource_init(&screen->query_heap, 0, 32);
+	ret = nouveau_resource_init(&screen->query_heap, 0, query_sizes[i]);
 	if (ret) {
 		NOUVEAU_ERR("Error initialising query object heap: %d\n", ret);
 		nvfx_screen_destroy(pscreen);
 		return NULL;
 	}
 
+	LIST_INITHEAD(&screen->query_list);
+
 	/* Vtxprog resources */
 	if (nouveau_resource_init(&screen->vp_exec_heap, 0, screen->is_nv4x ? 512 : 256) ||
 	    nouveau_resource_init(&screen->vp_data_heap, 0, 256)) {
@@ -423,40 +431,36 @@ nvfx_screen_create(struct pipe_winsys *ws, struct nouveau_device *dev)
 		return NULL;
 	}
 
+	BIND_RING(chan, screen->eng3d, 7);
+
 	/* Static eng3d initialisation */
-	/* make the so big and don't worry about exact values
-	   since we it will be thrown away immediately after use */
-	so = so_new(256, 256, 0);
-	so_method(so, screen->eng3d, NV34TCL_DMA_NOTIFY, 1);
-	so_data  (so, screen->sync->handle);
-	so_method(so, screen->eng3d, NV34TCL_DMA_TEXTURE0, 2);
-	so_data  (so, chan->vram->handle);
-	so_data  (so, chan->gart->handle);
-	so_method(so, screen->eng3d, NV34TCL_DMA_COLOR1, 1);
-	so_data  (so, chan->vram->handle);
-	so_method(so, screen->eng3d, NV34TCL_DMA_COLOR0, 2);
-	so_data  (so, chan->vram->handle);
-	so_data  (so, chan->vram->handle);
-	so_method(so, screen->eng3d, NV34TCL_DMA_VTXBUF0, 2);
-	so_data  (so, chan->vram->handle);
-	so_data  (so, chan->gart->handle);
-
-	so_method(so, screen->eng3d, NV34TCL_DMA_FENCE, 2);
-	so_data  (so, 0);
-	so_data  (so, screen->query->handle);
-
-	so_method(so, screen->eng3d, NV34TCL_DMA_IN_MEMORY7, 2);
-	so_data  (so, chan->vram->handle);
-	so_data  (so, chan->vram->handle);
+	/* note that we just started using the channel, so we must have space in the pushbuffer */
+	OUT_RING(chan, RING_3D(NV34TCL_DMA_NOTIFY, 1));
+	OUT_RING(chan, screen->sync->handle);
+	OUT_RING(chan, RING_3D(NV34TCL_DMA_TEXTURE0, 2));
+	OUT_RING(chan, chan->vram->handle);
+	OUT_RING(chan, chan->gart->handle);
+	OUT_RING(chan, RING_3D(NV34TCL_DMA_COLOR1, 1));
+	OUT_RING(chan, chan->vram->handle);
+	OUT_RING(chan, RING_3D(NV34TCL_DMA_COLOR0, 2));
+	OUT_RING(chan, chan->vram->handle);
+	OUT_RING(chan, chan->vram->handle);
+	OUT_RING(chan, RING_3D(NV34TCL_DMA_VTXBUF0, 2));
+	OUT_RING(chan, chan->vram->handle);
+	OUT_RING(chan, chan->gart->handle);
+
+	OUT_RING(chan, RING_3D(NV34TCL_DMA_FENCE, 2));
+	OUT_RING(chan, 0);
+	OUT_RING(chan, screen->query->handle);
+
+	OUT_RING(chan, RING_3D(NV34TCL_DMA_IN_MEMORY7, 2));
+	OUT_RING(chan, chan->vram->handle);
+	OUT_RING(chan, chan->vram->handle);
 
 	if(!screen->is_nv4x)
-		nv30_screen_init(screen, so);
+		nv30_screen_init(screen);
 	else
-		nv40_screen_init(screen, so);
-
-	so_emit(chan, so);
-	so_ref(NULL, &so);
-	nouveau_pushbuf_flush(chan, 0);
+		nv40_screen_init(screen);
 
 	return pscreen;
 }
diff --git a/src/gallium/drivers/nvfx/nvfx_screen.h b/src/gallium/drivers/nvfx/nvfx_screen.h
index baa848c47aa..127d8919af4 100644
--- a/src/gallium/drivers/nvfx/nvfx_screen.h
+++ b/src/gallium/drivers/nvfx/nvfx_screen.h
@@ -1,8 +1,10 @@
 #ifndef __NVFX_SCREEN_H__
 #define __NVFX_SCREEN_H__
 
+#include "util/u_double_list.h"
 #include "nouveau/nouveau_screen.h"
 #include "nv04_surface_2d.h"
+#include "nvfx_context.h"
 
 struct nvfx_screen {
 	struct nouveau_screen base;
@@ -12,7 +14,9 @@ struct nvfx_screen {
 	struct nvfx_context *cur_ctx;
 
 	unsigned is_nv4x; /* either 0 or ~0 */
-	int vertex_buffer_flags;
+	boolean force_swtnl;
+	unsigned vertex_buffer_reloc_flags;
+	unsigned index_buffer_reloc_flags;
 
 	/* HW graphics objects */
 	struct nv04_surface_2d *eng2d;
@@ -22,13 +26,11 @@ struct nvfx_screen {
 	/* Query object resources */
 	struct nouveau_notifier *query;
 	struct nouveau_resource *query_heap;
+	struct list_head query_list;
 
 	/* Vtxprog resources */
 	struct nouveau_resource *vp_exec_heap;
 	struct nouveau_resource *vp_data_heap;
-
-	/* Current 3D state of channel */
-	struct nouveau_stateobj *state[NVFX_STATE_MAX];
 };
 
 static INLINE struct nvfx_screen *
diff --git a/src/gallium/drivers/nvfx/nvfx_shader.h b/src/gallium/drivers/nvfx/nvfx_shader.h
index 0b2f044f7fe..50830b39164 100644
--- a/src/gallium/drivers/nvfx/nvfx_shader.h
+++ b/src/gallium/drivers/nvfx/nvfx_shader.h
@@ -209,7 +209,7 @@
 #define NVFX_FP_OP_OPCODE_RFL_NV30 0x36
 
 /* NV40 only fragment program opcodes */
-#define NVFX_FP_OP_OPCODE_TXL_NV40 0x31
+#define NVFX_FP_OP_OPCODE_TXL_NV40 0x2F
 /* The use of these instructions appears to be indicated by bit 31 of DWORD 2.*/
 #define NV40_FP_OP_BRA_OPCODE_BRK                                    0x0
 #define NV40_FP_OP_BRA_OPCODE_CAL                                    0x1
diff --git a/src/gallium/drivers/nvfx/nvfx_state.c b/src/gallium/drivers/nvfx/nvfx_state.c
index ecaa0dcb16a..315de492dab 100644
--- a/src/gallium/drivers/nvfx/nvfx_state.c
+++ b/src/gallium/drivers/nvfx/nvfx_state.c
@@ -15,32 +15,31 @@ nvfx_blend_state_create(struct pipe_context *pipe,
 			const struct pipe_blend_state *cso)
 {
 	struct nvfx_context *nvfx = nvfx_context(pipe);
-	struct nouveau_grobj *eng3d = nvfx->screen->eng3d;
 	struct nvfx_blend_state *bso = CALLOC(1, sizeof(*bso));
-	struct nouveau_stateobj *so = so_new(5, 8, 0);
+	struct nouveau_statebuf_builder sb = sb_init(bso->sb);
 
 	if (cso->rt[0].blend_enable) {
-		so_method(so, eng3d, NV34TCL_BLEND_FUNC_ENABLE, 3);
-		so_data  (so, 1);
-		so_data  (so, (nvgl_blend_func(cso->rt[0].alpha_src_factor) << 16) |
+		sb_method(sb, NV34TCL_BLEND_FUNC_ENABLE, 3);
+		sb_data(sb, 1);
+		sb_data(sb, (nvgl_blend_func(cso->rt[0].alpha_src_factor) << 16) |
 			       nvgl_blend_func(cso->rt[0].rgb_src_factor));
-		so_data  (so, nvgl_blend_func(cso->rt[0].alpha_dst_factor) << 16 |
+		sb_data(sb, nvgl_blend_func(cso->rt[0].alpha_dst_factor) << 16 |
 			      nvgl_blend_func(cso->rt[0].rgb_dst_factor));
 		if(nvfx->screen->base.device->chipset < 0x40) {
-			so_method(so, eng3d, NV34TCL_BLEND_EQUATION, 1);
-			so_data  (so, nvgl_blend_eqn(cso->rt[0].rgb_func));
+			sb_method(sb, NV34TCL_BLEND_EQUATION, 1);
+			sb_data(sb, nvgl_blend_eqn(cso->rt[0].rgb_func));
 		} else {
-			so_method(so, eng3d, NV40TCL_BLEND_EQUATION, 1);
-			so_data  (so, nvgl_blend_eqn(cso->rt[0].alpha_func) << 16 |
+			sb_method(sb, NV40TCL_BLEND_EQUATION, 1);
+			sb_data(sb, nvgl_blend_eqn(cso->rt[0].alpha_func) << 16 |
 			      nvgl_blend_eqn(cso->rt[0].rgb_func));
 		}
 	} else {
-		so_method(so, eng3d, NV34TCL_BLEND_FUNC_ENABLE, 1);
-		so_data  (so, 0);
+		sb_method(sb, NV34TCL_BLEND_FUNC_ENABLE, 1);
+		sb_data(sb, 0);
 	}
 
-	so_method(so, eng3d, NV34TCL_COLOR_MASK, 1);
-	so_data  (so, (((cso->rt[0].colormask & PIPE_MASK_A) ? (0x01 << 24) : 0) |
+	sb_method(sb, NV34TCL_COLOR_MASK, 1);
+	sb_data(sb, (((cso->rt[0].colormask & PIPE_MASK_A) ? (0x01 << 24) : 0) |
 	       ((cso->rt[0].colormask & PIPE_MASK_R) ? (0x01 << 16) : 0) |
 	       ((cso->rt[0].colormask & PIPE_MASK_G) ? (0x01 <<  8) : 0) |
 	       ((cso->rt[0].colormask & PIPE_MASK_B) ? (0x01 <<  0) : 0)));
@@ -48,19 +47,18 @@ nvfx_blend_state_create(struct pipe_context *pipe,
 	/* TODO: add NV40 MRT color mask */
 
 	if (cso->logicop_enable) {
-		so_method(so, eng3d, NV34TCL_COLOR_LOGIC_OP_ENABLE, 2);
-		so_data  (so, 1);
-		so_data  (so, nvgl_logicop_func(cso->logicop_func));
+		sb_method(sb, NV34TCL_COLOR_LOGIC_OP_ENABLE, 2);
+		sb_data(sb, 1);
+		sb_data(sb, nvgl_logicop_func(cso->logicop_func));
 	} else {
-		so_method(so, eng3d, NV34TCL_COLOR_LOGIC_OP_ENABLE, 1);
-		so_data  (so, 0);
+		sb_method(sb, NV34TCL_COLOR_LOGIC_OP_ENABLE, 1);
+		sb_data(sb, 0);
 	}
 
-	so_method(so, eng3d, NV34TCL_DITHER_ENABLE, 1);
-	so_data  (so, cso->dither ? 1 : 0);
+	sb_method(sb, NV34TCL_DITHER_ENABLE, 1);
+	sb_data(sb, cso->dither ? 1 : 0);
 
-	so_ref(so, &bso->so);
-	so_ref(NULL, &so);
+	bso->sb_len = sb_len(sb, bso->sb);
 	bso->pipe = *cso;
 	return (void *)bso;
 }
@@ -79,7 +77,6 @@ nvfx_blend_state_delete(struct pipe_context *pipe, void *hwcso)
 {
 	struct nvfx_blend_state *bso = hwcso;
 
-	so_ref(NULL, &bso->so);
 	FREE(bso);
 }
 
@@ -163,7 +160,7 @@ nvfx_set_fragment_sampler_views(struct pipe_context *pipe,
 
 static struct pipe_sampler_view *
 nvfx_create_sampler_view(struct pipe_context *pipe,
-			 struct pipe_texture *texture,
+			 struct pipe_resource *texture,
 			 const struct pipe_sampler_view *templ)
 {
 	struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
@@ -172,7 +169,7 @@ nvfx_create_sampler_view(struct pipe_context *pipe,
 		*view = *templ;
 		view->reference.count = 1;
 		view->texture = NULL;
-		pipe_texture_reference(&view->texture, texture);
+		pipe_resource_reference(&view->texture, texture);
 		view->context = pipe;
 	}
 
@@ -184,7 +181,7 @@ static void
 nvfx_sampler_view_destroy(struct pipe_context *pipe,
 			  struct pipe_sampler_view *view)
 {
-	pipe_texture_reference(&view->texture, NULL);
+	pipe_resource_reference(&view->texture, NULL);
 	FREE(view);
 }
 
@@ -192,99 +189,99 @@ static void *
 nvfx_rasterizer_state_create(struct pipe_context *pipe,
 			     const struct pipe_rasterizer_state *cso)
 {
-	struct nvfx_context *nvfx = nvfx_context(pipe);
 	struct nvfx_rasterizer_state *rsso = CALLOC(1, sizeof(*rsso));
-	struct nouveau_stateobj *so = so_new(9, 19, 0);
-	struct nouveau_grobj *eng3d = nvfx->screen->eng3d;
+	struct nouveau_statebuf_builder sb = sb_init(rsso->sb);
 
 	/*XXX: ignored:
-	 * 	light_twoside
 	 * 	point_smooth -nohw
 	 * 	multisample
 	 */
 
-	so_method(so, eng3d, NV34TCL_SHADE_MODEL, 1);
-	so_data  (so, cso->flatshade ? NV34TCL_SHADE_MODEL_FLAT :
+	sb_method(sb, NV34TCL_SHADE_MODEL, 1);
+	sb_data(sb, cso->flatshade ? NV34TCL_SHADE_MODEL_FLAT :
 				       NV34TCL_SHADE_MODEL_SMOOTH);
 
-	so_method(so, eng3d, NV34TCL_LINE_WIDTH, 2);
-	so_data  (so, (unsigned char)(cso->line_width * 8.0) & 0xff);
-	so_data  (so, cso->line_smooth ? 1 : 0);
-	so_method(so, eng3d, NV34TCL_LINE_STIPPLE_ENABLE, 2);
-	so_data  (so, cso->line_stipple_enable ? 1 : 0);
-	so_data  (so, (cso->line_stipple_pattern << 16) |
+	sb_method(sb, NV34TCL_VERTEX_TWO_SIDE_ENABLE, 1);
+	sb_data(sb, cso->light_twoside);
+
+	sb_method(sb, NV34TCL_LINE_WIDTH, 2);
+	sb_data(sb, (unsigned char)(cso->line_width * 8.0) & 0xff);
+	sb_data(sb, cso->line_smooth ? 1 : 0);
+	sb_method(sb, NV34TCL_LINE_STIPPLE_ENABLE, 2);
+	sb_data(sb, cso->line_stipple_enable ? 1 : 0);
+	sb_data(sb, (cso->line_stipple_pattern << 16) |
 		       cso->line_stipple_factor);
 
-	so_method(so, eng3d, NV34TCL_POINT_SIZE, 1);
-	so_data  (so, fui(cso->point_size));
+	sb_method(sb, NV34TCL_POINT_SIZE, 1);
+	sb_data(sb, fui(cso->point_size));
 
-	so_method(so, eng3d, NV34TCL_POLYGON_MODE_FRONT, 6);
+	sb_method(sb, NV34TCL_POLYGON_MODE_FRONT, 6);
 	if (cso->front_winding == PIPE_WINDING_CCW) {
-		so_data(so, nvgl_polygon_mode(cso->fill_ccw));
-		so_data(so, nvgl_polygon_mode(cso->fill_cw));
+		sb_data(sb, nvgl_polygon_mode(cso->fill_ccw));
+		sb_data(sb, nvgl_polygon_mode(cso->fill_cw));
 		switch (cso->cull_mode) {
 		case PIPE_WINDING_CCW:
-			so_data(so, NV34TCL_CULL_FACE_FRONT);
+			sb_data(sb, NV34TCL_CULL_FACE_FRONT);
 			break;
 		case PIPE_WINDING_CW:
-			so_data(so, NV34TCL_CULL_FACE_BACK);
+			sb_data(sb, NV34TCL_CULL_FACE_BACK);
 			break;
 		case PIPE_WINDING_BOTH:
-			so_data(so, NV34TCL_CULL_FACE_FRONT_AND_BACK);
+			sb_data(sb, NV34TCL_CULL_FACE_FRONT_AND_BACK);
 			break;
 		default:
-			so_data(so, NV34TCL_CULL_FACE_BACK);
+			sb_data(sb, NV34TCL_CULL_FACE_BACK);
 			break;
 		}
-		so_data(so, NV34TCL_FRONT_FACE_CCW);
+		sb_data(sb, NV34TCL_FRONT_FACE_CCW);
 	} else {
-		so_data(so, nvgl_polygon_mode(cso->fill_cw));
-		so_data(so, nvgl_polygon_mode(cso->fill_ccw));
+		sb_data(sb, nvgl_polygon_mode(cso->fill_cw));
+		sb_data(sb, nvgl_polygon_mode(cso->fill_ccw));
 		switch (cso->cull_mode) {
 		case PIPE_WINDING_CCW:
-			so_data(so, NV34TCL_CULL_FACE_BACK);
+			sb_data(sb, NV34TCL_CULL_FACE_BACK);
 			break;
 		case PIPE_WINDING_CW:
-			so_data(so, NV34TCL_CULL_FACE_FRONT);
+			sb_data(sb, NV34TCL_CULL_FACE_FRONT);
 			break;
 		case PIPE_WINDING_BOTH:
-			so_data(so, NV34TCL_CULL_FACE_FRONT_AND_BACK);
+			sb_data(sb, NV34TCL_CULL_FACE_FRONT_AND_BACK);
 			break;
 		default:
-			so_data(so, NV34TCL_CULL_FACE_BACK);
+			sb_data(sb, NV34TCL_CULL_FACE_BACK);
 			break;
 		}
-		so_data(so, NV34TCL_FRONT_FACE_CW);
+		sb_data(sb, NV34TCL_FRONT_FACE_CW);
 	}
-	so_data(so, cso->poly_smooth ? 1 : 0);
-	so_data(so, (cso->cull_mode != PIPE_WINDING_NONE) ? 1 : 0);
+	sb_data(sb, cso->poly_smooth ? 1 : 0);
+	sb_data(sb, (cso->cull_mode != PIPE_WINDING_NONE) ? 1 : 0);
 
-	so_method(so, eng3d, NV34TCL_POLYGON_STIPPLE_ENABLE, 1);
-	so_data  (so, cso->poly_stipple_enable ? 1 : 0);
+	sb_method(sb, NV34TCL_POLYGON_STIPPLE_ENABLE, 1);
+	sb_data(sb, cso->poly_stipple_enable ? 1 : 0);
 
-	so_method(so, eng3d, NV34TCL_POLYGON_OFFSET_POINT_ENABLE, 3);
+	sb_method(sb, NV34TCL_POLYGON_OFFSET_POINT_ENABLE, 3);
 	if ((cso->offset_cw && cso->fill_cw == PIPE_POLYGON_MODE_POINT) ||
 	    (cso->offset_ccw && cso->fill_ccw == PIPE_POLYGON_MODE_POINT))
-		so_data(so, 1);
+		sb_data(sb, 1);
 	else
-		so_data(so, 0);
+		sb_data(sb, 0);
 	if ((cso->offset_cw && cso->fill_cw == PIPE_POLYGON_MODE_LINE) ||
 	    (cso->offset_ccw && cso->fill_ccw == PIPE_POLYGON_MODE_LINE))
-		so_data(so, 1);
+		sb_data(sb, 1);
 	else
-		so_data(so, 0);
+		sb_data(sb, 0);
 	if ((cso->offset_cw && cso->fill_cw == PIPE_POLYGON_MODE_FILL) ||
 	    (cso->offset_ccw && cso->fill_ccw == PIPE_POLYGON_MODE_FILL))
-		so_data(so, 1);
+		sb_data(sb, 1);
 	else
-		so_data(so, 0);
+		sb_data(sb, 0);
 	if (cso->offset_cw || cso->offset_ccw) {
-		so_method(so, eng3d, NV34TCL_POLYGON_OFFSET_FACTOR, 2);
-		so_data  (so, fui(cso->offset_scale));
-		so_data  (so, fui(cso->offset_units * 2));
+		sb_method(sb, NV34TCL_POLYGON_OFFSET_FACTOR, 2);
+		sb_data(sb, fui(cso->offset_scale));
+		sb_data(sb, fui(cso->offset_units * 2));
 	}
 
-	so_method(so, eng3d, NV34TCL_POINT_SPRITE, 1);
+	sb_method(sb, NV34TCL_POINT_SPRITE, 1);
 	if (cso->point_quad_rasterization) {
 		unsigned psctl = (1 << 0), i;
 
@@ -293,14 +290,13 @@ nvfx_rasterizer_state_create(struct pipe_context *pipe,
 				psctl |= (1 << (8 + i));
 		}
 
-		so_data(so, psctl);
+		sb_data(sb, psctl);
 	} else {
-		so_data(so, 0);
+		sb_data(sb, 0);
 	}
 
-	so_ref(so, &rsso->so);
-	so_ref(NULL, &so);
 	rsso->pipe = *cso;
+	rsso->sb_len = sb_len(sb, rsso->sb);
 	return (void *)rsso;
 }
 
@@ -309,6 +305,23 @@ nvfx_rasterizer_state_bind(struct pipe_context *pipe, void *hwcso)
 {
 	struct nvfx_context *nvfx = nvfx_context(pipe);
 
+	if(nvfx->rasterizer && hwcso)
+	{
+		if(!nvfx->rasterizer || ((struct nvfx_rasterizer_state*)hwcso)->pipe.scissor
+					!= nvfx->rasterizer->pipe.scissor)
+		{
+			nvfx->dirty |= NVFX_NEW_SCISSOR;
+			nvfx->draw_dirty |= NVFX_NEW_SCISSOR;
+		}
+
+		if(((struct nvfx_rasterizer_state*)hwcso)->pipe.poly_stipple_enable
+					!= nvfx->rasterizer->pipe.poly_stipple_enable)
+		{
+			nvfx->dirty |= NVFX_NEW_STIPPLE;
+			nvfx->draw_dirty |= NVFX_NEW_STIPPLE;
+		}
+	}
+
 	nvfx->rasterizer = hwcso;
 	nvfx->dirty |= NVFX_NEW_RAST;
 	nvfx->draw_dirty |= NVFX_NEW_RAST;
@@ -319,7 +332,6 @@ nvfx_rasterizer_state_delete(struct pipe_context *pipe, void *hwcso)
 {
 	struct nvfx_rasterizer_state *rsso = hwcso;
 
-	so_ref(NULL, &rsso->so);
 	FREE(rsso);
 }
 
@@ -327,54 +339,51 @@ static void *
 nvfx_depth_stencil_alpha_state_create(struct pipe_context *pipe,
 			const struct pipe_depth_stencil_alpha_state *cso)
 {
-	struct nvfx_context *nvfx = nvfx_context(pipe);
 	struct nvfx_zsa_state *zsaso = CALLOC(1, sizeof(*zsaso));
-	struct nouveau_stateobj *so = so_new(6, 20, 0);
-	struct nouveau_grobj *eng3d = nvfx->screen->eng3d;
+	struct nouveau_statebuf_builder sb = sb_init(zsaso->sb);
 
-	so_method(so, eng3d, NV34TCL_DEPTH_FUNC, 3);
-	so_data  (so, nvgl_comparison_op(cso->depth.func));
-	so_data  (so, cso->depth.writemask ? 1 : 0);
-	so_data  (so, cso->depth.enabled ? 1 : 0);
+	sb_method(sb, NV34TCL_DEPTH_FUNC, 3);
+	sb_data  (sb, nvgl_comparison_op(cso->depth.func));
+	sb_data  (sb, cso->depth.writemask ? 1 : 0);
+	sb_data  (sb, cso->depth.enabled ? 1 : 0);
 
-	so_method(so, eng3d, NV34TCL_ALPHA_FUNC_ENABLE, 3);
-	so_data  (so, cso->alpha.enabled ? 1 : 0);
-	so_data  (so, nvgl_comparison_op(cso->alpha.func));
-	so_data  (so, float_to_ubyte(cso->alpha.ref_value));
+	sb_method(sb, NV34TCL_ALPHA_FUNC_ENABLE, 3);
+	sb_data  (sb, cso->alpha.enabled ? 1 : 0);
+	sb_data  (sb, nvgl_comparison_op(cso->alpha.func));
+	sb_data  (sb, float_to_ubyte(cso->alpha.ref_value));
 
 	if (cso->stencil[0].enabled) {
-		so_method(so, eng3d, NV34TCL_STENCIL_FRONT_ENABLE, 3);
-		so_data  (so, cso->stencil[0].enabled ? 1 : 0);
-		so_data  (so, cso->stencil[0].writemask);
-		so_data  (so, nvgl_comparison_op(cso->stencil[0].func));
-		so_method(so, eng3d, NV34TCL_STENCIL_FRONT_FUNC_MASK, 4);
-		so_data  (so, cso->stencil[0].valuemask);
-		so_data  (so, nvgl_stencil_op(cso->stencil[0].fail_op));
-		so_data  (so, nvgl_stencil_op(cso->stencil[0].zfail_op));
-		so_data  (so, nvgl_stencil_op(cso->stencil[0].zpass_op));
+		sb_method(sb, NV34TCL_STENCIL_FRONT_ENABLE, 3);
+		sb_data  (sb, cso->stencil[0].enabled ? 1 : 0);
+		sb_data  (sb, cso->stencil[0].writemask);
+		sb_data  (sb, nvgl_comparison_op(cso->stencil[0].func));
+		sb_method(sb, NV34TCL_STENCIL_FRONT_FUNC_MASK, 4);
+		sb_data  (sb, cso->stencil[0].valuemask);
+		sb_data  (sb, nvgl_stencil_op(cso->stencil[0].fail_op));
+		sb_data  (sb, nvgl_stencil_op(cso->stencil[0].zfail_op));
+		sb_data  (sb, nvgl_stencil_op(cso->stencil[0].zpass_op));
 	} else {
-		so_method(so, eng3d, NV34TCL_STENCIL_FRONT_ENABLE, 1);
-		so_data  (so, 0);
+		sb_method(sb, NV34TCL_STENCIL_FRONT_ENABLE, 1);
+		sb_data  (sb, 0);
 	}
 
 	if (cso->stencil[1].enabled) {
-		so_method(so, eng3d, NV34TCL_STENCIL_BACK_ENABLE, 3);
-		so_data  (so, cso->stencil[1].enabled ? 1 : 0);
-		so_data  (so, cso->stencil[1].writemask);
-		so_data  (so, nvgl_comparison_op(cso->stencil[1].func));
-		so_method(so, eng3d, NV34TCL_STENCIL_BACK_FUNC_MASK, 4);
-		so_data  (so, cso->stencil[1].valuemask);
-		so_data  (so, nvgl_stencil_op(cso->stencil[1].fail_op));
-		so_data  (so, nvgl_stencil_op(cso->stencil[1].zfail_op));
-		so_data  (so, nvgl_stencil_op(cso->stencil[1].zpass_op));
+		sb_method(sb, NV34TCL_STENCIL_BACK_ENABLE, 3);
+		sb_data  (sb, cso->stencil[1].enabled ? 1 : 0);
+		sb_data  (sb, cso->stencil[1].writemask);
+		sb_data  (sb, nvgl_comparison_op(cso->stencil[1].func));
+		sb_method(sb, NV34TCL_STENCIL_BACK_FUNC_MASK, 4);
+		sb_data  (sb, cso->stencil[1].valuemask);
+		sb_data  (sb, nvgl_stencil_op(cso->stencil[1].fail_op));
+		sb_data  (sb, nvgl_stencil_op(cso->stencil[1].zfail_op));
+		sb_data  (sb, nvgl_stencil_op(cso->stencil[1].zpass_op));
 	} else {
-		so_method(so, eng3d, NV34TCL_STENCIL_BACK_ENABLE, 1);
-		so_data  (so, 0);
+		sb_method(sb, NV34TCL_STENCIL_BACK_ENABLE, 1);
+		sb_data  (sb, 0);
 	}
 
-	so_ref(so, &zsaso->so);
-	so_ref(NULL, &so);
 	zsaso->pipe = *cso;
+	zsaso->sb_len = sb_len(sb, zsaso->sb);
 	return (void *)zsaso;
 }
 
@@ -392,7 +401,6 @@ nvfx_depth_stencil_alpha_state_delete(struct pipe_context *pipe, void *hwcso)
 {
 	struct nvfx_zsa_state *zsaso = hwcso;
 
-	so_ref(NULL, &zsaso->so);
 	FREE(zsaso);
 }
 
@@ -499,18 +507,18 @@ nvfx_set_clip_state(struct pipe_context *pipe,
 
 static void
 nvfx_set_constant_buffer(struct pipe_context *pipe, uint shader, uint index,
-			 struct pipe_buffer *buf )
+			 struct pipe_resource *buf )
 {
 	struct nvfx_context *nvfx = nvfx_context(pipe);
 
 	nvfx->constbuf[shader] = buf;
-	nvfx->constbuf_nr[shader] = buf->size / (4 * sizeof(float));
+	nvfx->constbuf_nr[shader] = buf->width0 / (4 * sizeof(float));
 
 	if (shader == PIPE_SHADER_VERTEX) {
-		nvfx->dirty |= NVFX_NEW_VERTPROG;
+		nvfx->dirty |= NVFX_NEW_VERTCONST;
 	} else
 	if (shader == PIPE_SHADER_FRAGMENT) {
-		nvfx->dirty |= NVFX_NEW_FRAGPROG;
+		nvfx->dirty |= NVFX_NEW_FRAGCONST;
 	}
 }
 
diff --git a/src/gallium/drivers/nvfx/nvfx_state.h b/src/gallium/drivers/nvfx/nvfx_state.h
index e585246879b..9ceb2577ecc 100644
--- a/src/gallium/drivers/nvfx/nvfx_state.h
+++ b/src/gallium/drivers/nvfx/nvfx_state.h
@@ -3,6 +3,7 @@
 
 #include "pipe/p_state.h"
 #include "tgsi/tgsi_scan.h"
+#include "nouveau/nouveau_statebuf.h"
 
 struct nvfx_vertex_program_exec {
 	uint32_t data[4];
@@ -38,7 +39,6 @@ struct nvfx_vertex_program {
 	uint32_t ir;
 	uint32_t or;
 	uint32_t clip_ctrl;
-	struct nouveau_stateobj *so;
 };
 
 struct nvfx_fragment_program_data {
@@ -46,6 +46,12 @@ struct nvfx_fragment_program_data {
 	unsigned index;
 };
 
+struct nvfx_fragment_program_bo {
+	struct nvfx_fragment_program_bo* next;
+	struct nouveau_bo* bo;
+	char insn[] __attribute__((aligned(16)));
+};
+
 struct nvfx_fragment_program {
 	struct pipe_shader_state pipe;
 	struct tgsi_shader_info info;
@@ -59,25 +65,13 @@ struct nvfx_fragment_program {
 	struct nvfx_fragment_program_data *consts;
 	unsigned nr_consts;
 
-	struct pipe_buffer *buffer;
-
 	uint32_t fp_control;
-	struct nouveau_stateobj *so;
-};
 
-#define NVFX_MAX_TEXTURE_LEVELS  16
-
-struct nvfx_miptree {
-	struct pipe_texture base;
-	struct nouveau_bo *bo;
-
-	struct pipe_buffer *buffer;
-	uint total_size;
-
-	struct {
-		uint pitch;
-		uint *image_offset;
-	} level[NVFX_MAX_TEXTURE_LEVELS];
+	unsigned bo_prog_idx;
+	unsigned prog_size;
+	unsigned progs_per_bo;
+	struct nvfx_fragment_program_bo* fpbo;
 };
 
+
 #endif
diff --git a/src/gallium/drivers/nvfx/nvfx_state_blend.c b/src/gallium/drivers/nvfx/nvfx_state_blend.c
index 03b6ef8117d..fe34e98364c 100644
--- a/src/gallium/drivers/nvfx/nvfx_state_blend.c
+++ b/src/gallium/drivers/nvfx/nvfx_state_blend.c
@@ -1,41 +1,22 @@
 #include "nvfx_context.h"
 
-static boolean
+void
 nvfx_state_blend_validate(struct nvfx_context *nvfx)
 {
-	so_ref(nvfx->blend->so, &nvfx->state.hw[NVFX_STATE_BLEND]);
-	return TRUE;
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
+	sb_emit(chan, nvfx->blend->sb, nvfx->blend->sb_len);
 }
 
-struct nvfx_state_entry nvfx_state_blend = {
-	.validate = nvfx_state_blend_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_BLEND,
-		.hw = NVFX_STATE_BLEND
-	}
-};
-
-static boolean
+void
 nvfx_state_blend_colour_validate(struct nvfx_context *nvfx)
 {
-	struct nouveau_stateobj *so = so_new(1, 1, 0);
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
 	struct pipe_blend_color *bcol = &nvfx->blend_colour;
 
-	so_method(so, nvfx->screen->eng3d, NV34TCL_BLEND_COLOR, 1);
-	so_data  (so, ((float_to_ubyte(bcol->color[3]) << 24) |
+	WAIT_RING(chan, 2);
+	OUT_RING(chan, RING_3D(NV34TCL_BLEND_COLOR, 1));
+	OUT_RING(chan, ((float_to_ubyte(bcol->color[3]) << 24) |
 		       (float_to_ubyte(bcol->color[0]) << 16) |
 		       (float_to_ubyte(bcol->color[1]) <<  8) |
 		       (float_to_ubyte(bcol->color[2]) <<  0)));
-
-	so_ref(so, &nvfx->state.hw[NVFX_STATE_BCOL]);
-	so_ref(NULL, &so);
-	return TRUE;
 }
-
-struct nvfx_state_entry nvfx_state_blend_colour = {
-	.validate = nvfx_state_blend_colour_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_BCOL,
-		.hw = NVFX_STATE_BCOL
-	}
-};
diff --git a/src/gallium/drivers/nvfx/nvfx_state_emit.c b/src/gallium/drivers/nvfx/nvfx_state_emit.c
index 72537388ea4..4137849bf0b 100644
--- a/src/gallium/drivers/nvfx/nvfx_state_emit.c
+++ b/src/gallium/drivers/nvfx/nvfx_state_emit.c
@@ -2,105 +2,113 @@
 #include "nvfx_state.h"
 #include "draw/draw_context.h"
 
-#define RENDER_STATES(name, vbo) \
-static struct nvfx_state_entry *name##render_states[] = { \
-	&nvfx_state_framebuffer, \
-	&nvfx_state_rasterizer, \
-	&nvfx_state_scissor, \
-	&nvfx_state_stipple, \
-	&nvfx_state_fragprog, \
-	&nvfx_state_fragtex, \
-	&nvfx_state_vertprog, \
-	&nvfx_state_blend, \
-	&nvfx_state_blend_colour, \
-	&nvfx_state_zsa, \
-	&nvfx_state_sr, \
-	&nvfx_state_viewport, \
-	&nvfx_state_##vbo, \
-	NULL \
-}
-
-RENDER_STATES(, vbo);
-RENDER_STATES(swtnl_, vtxfmt);
-
-static void
-nvfx_state_do_validate(struct nvfx_context *nvfx,
-		       struct nvfx_state_entry **states)
+static boolean
+nvfx_state_validate_common(struct nvfx_context *nvfx)
 {
-	while (*states) {
-		struct nvfx_state_entry *e = *states;
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
+	unsigned dirty = nvfx->dirty;
+
+	if(nvfx != nvfx->screen->cur_ctx)
+		dirty = ~0;
+
+	if(nvfx->render_mode == HW)
+	{
+		if(dirty & (NVFX_NEW_VERTPROG | NVFX_NEW_VERTCONST | NVFX_NEW_UCP))
+		{
+			if(!nvfx_vertprog_validate(nvfx))
+				return FALSE;
+		}
 
-		if (nvfx->dirty & e->dirty.pipe) {
-			if (e->validate(nvfx))
-				nvfx->state.dirty |= (1ULL << e->dirty.hw);
+		if(dirty & (NVFX_NEW_ARRAYS))
+		{
+			if(!nvfx_vbo_validate(nvfx))
+				return FALSE;
 		}
+	}
+	else
+	{
+		/* TODO: this looks a bit misdesigned */
+		if(dirty & (NVFX_NEW_VERTPROG | NVFX_NEW_UCP))
+			nvfx_vertprog_validate(nvfx);
+
+		if(dirty & (NVFX_NEW_ARRAYS | NVFX_NEW_FRAGPROG))
+			nvfx_vtxfmt_validate(nvfx);
+	}
+
+	if(dirty & NVFX_NEW_FB)
+		nvfx_state_framebuffer_validate(nvfx);
+
+	if(dirty & NVFX_NEW_RAST)
+		sb_emit(chan, nvfx->rasterizer->sb, nvfx->rasterizer->sb_len);
+
+	if(dirty & NVFX_NEW_SCISSOR)
+		nvfx_state_scissor_validate(nvfx);
+
+	if(dirty & NVFX_NEW_STIPPLE)
+		nvfx_state_stipple_validate(nvfx);
+
+	if(dirty & (NVFX_NEW_FRAGPROG | NVFX_NEW_FRAGCONST))
+		nvfx_fragprog_validate(nvfx);
+
+	if(dirty & NVFX_NEW_SAMPLER)
+		nvfx_fragtex_validate(nvfx);
+
+	if(dirty & NVFX_NEW_BLEND)
+		sb_emit(chan, nvfx->blend->sb, nvfx->blend->sb_len);
+
+	if(dirty & NVFX_NEW_BCOL)
+		nvfx_state_blend_colour_validate(nvfx);
+
+	if(dirty & NVFX_NEW_ZSA)
+		sb_emit(chan, nvfx->zsa->sb, nvfx->zsa->sb_len);
+
+	if(dirty & NVFX_NEW_SR)
+		nvfx_state_sr_validate(nvfx);
+
+/* Having this depend on FB looks wrong, but it seems
+   necessary to make this work on nv3x
+   TODO: find the right fix
+*/
+	if(dirty & (NVFX_NEW_VIEWPORT | NVFX_NEW_FB))
+		nvfx_state_viewport_validate(nvfx);
 
-		states++;
+	/* TODO: could nv30 need this or something similar too? */
+	if((dirty & (NVFX_NEW_FRAGPROG | NVFX_NEW_SAMPLER)) && nvfx->is_nv4x) {
+		WAIT_RING(chan, 4);
+		OUT_RING(chan, RING_3D(NV40TCL_TEX_CACHE_CTL, 1));
+		OUT_RING(chan, 2);
+		OUT_RING(chan, RING_3D(NV40TCL_TEX_CACHE_CTL, 1));
+		OUT_RING(chan, 1);
 	}
 	nvfx->dirty = 0;
+	return TRUE;
 }
 
 void
 nvfx_state_emit(struct nvfx_context *nvfx)
 {
-	struct nvfx_state *state = &nvfx->state;
-	struct nvfx_screen *screen = nvfx->screen;
-	struct nouveau_channel *chan = screen->base.channel;
-	struct nouveau_grobj *eng3d = screen->eng3d;
-	unsigned i;
-	uint64_t states;
-
-	/* XXX: race conditions
-	 */
-	if (nvfx != screen->cur_ctx) {
-		for (i = 0; i < NVFX_STATE_MAX; i++) {
-			if (state->hw[i] && screen->state[i] != state->hw[i])
-				state->dirty |= (1ULL << i);
-		}
-
-		screen->cur_ctx = nvfx;
-	}
-
-	for (i = 0, states = state->dirty; states; i++) {
-		if (!(states & (1ULL << i)))
-			continue;
-		so_ref (state->hw[i], &nvfx->screen->state[i]);
-		if (state->hw[i])
-			so_emit(chan, nvfx->screen->state[i]);
-		states &= ~(1ULL << i);
-	}
-
-	/* TODO: could nv30 need this or something similar too? */
-	if(nvfx->is_nv4x) {
-		if (state->dirty & ((1ULL << NVFX_STATE_FRAGPROG) |
-				    (1ULL << NVFX_STATE_FRAGTEX0))) {
-			BEGIN_RING(chan, eng3d, NV40TCL_TEX_CACHE_CTL, 1);
-			OUT_RING  (chan, 2);
-			BEGIN_RING(chan, eng3d, NV40TCL_TEX_CACHE_CTL, 1);
-			OUT_RING  (chan, 1);
-		}
-	}
-	state->dirty = 0;
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
+	/* we need to ensure there is enough space to output relocations in one go */
+	unsigned max_relocs = 0
+	      + 16 /* vertex buffers, incl. dma flag */
+	      + 2 /* index buffer plus format+dma flag */
+	      + 2 * 5 /* 4 cbufs + zsbuf, plus dma objects */
+	      + 2 * 16 /* fragment textures plus format+dma flag */
+	      + 2 * 4 /* vertex textures plus format+dma flag */
+	      + 1 /* fragprog incl dma flag */
+	      ;
+	MARK_RING(chan, max_relocs * 2, max_relocs * 2);
+	nvfx_state_relocate(nvfx);
 }
 
 void
-nvfx_state_flush_notify(struct nouveau_channel *chan)
+nvfx_state_relocate(struct nvfx_context *nvfx)
 {
-	struct nvfx_context *nvfx = chan->user_private;
-	struct nvfx_state *state = &nvfx->state;
-	unsigned i, samplers;
-
-	so_emit_reloc_markers(chan, state->hw[NVFX_STATE_FB]);
-	for (i = 0, samplers = state->fp_samplers; i < 16 && samplers; i++) {
-		if (!(samplers & (1 << i)))
-			continue;
-		so_emit_reloc_markers(chan,
-				      state->hw[NVFX_STATE_FRAGTEX0+i]);
-		samplers &= ~(1ULL << i);
-	}
-	so_emit_reloc_markers(chan, state->hw[NVFX_STATE_FRAGPROG]);
-	if (state->hw[NVFX_STATE_VTXBUF] && nvfx->render_mode == HW)
-		so_emit_reloc_markers(chan, state->hw[NVFX_STATE_VTXBUF]);
+	nvfx_framebuffer_relocate(nvfx);
+	nvfx_fragtex_relocate(nvfx);
+	nvfx_fragprog_relocate(nvfx);
+	if (nvfx->render_mode == HW)
+		nvfx_vbo_relocate(nvfx);
 }
 
 boolean
@@ -117,16 +125,13 @@ nvfx_state_validate(struct nvfx_context *nvfx)
 			return FALSE;
 
 		/* Attempt to go to hwtnl again */
-		nvfx->pipe.flush(&nvfx->pipe, 0, NULL);
 		nvfx->dirty |= (NVFX_NEW_VIEWPORT |
 				NVFX_NEW_VERTPROG |
 				NVFX_NEW_ARRAYS);
 		nvfx->render_mode = HW;
 	}
 
-	nvfx_state_do_validate(nvfx, render_states);
-
-	if (nvfx->fallback_swtnl || nvfx->fallback_swrast)
+	if(!nvfx_state_validate_common(nvfx))
 		return FALSE;
 
 	if (was_sw)
@@ -167,12 +172,7 @@ nvfx_state_validate_swtnl(struct nvfx_context *nvfx)
 		draw_set_vertex_elements(draw, nvfx->vtxelt->num_elements, nvfx->vtxelt->pipe);
 	}
 
-	nvfx_state_do_validate(nvfx, swtnl_render_states);
-
-	if (nvfx->fallback_swrast) {
-		NOUVEAU_ERR("swtnl->swrast 0x%08x\n", nvfx->fallback_swrast);
-		return FALSE;
-	}
+	nvfx_state_validate_common(nvfx);
 
 	nvfx->draw_dirty = 0;
 	return TRUE;
diff --git a/src/gallium/drivers/nvfx/nvfx_state_fb.c b/src/gallium/drivers/nvfx/nvfx_state_fb.c
index 1923184163b..8c215980e23 100644
--- a/src/gallium/drivers/nvfx/nvfx_state_fb.c
+++ b/src/gallium/drivers/nvfx/nvfx_state_fb.c
@@ -1,26 +1,17 @@
 #include "nvfx_context.h"
+#include "nvfx_resource.h"
 #include "nouveau/nouveau_util.h"
 
-static struct pipe_buffer *
-nvfx_do_surface_buffer(struct pipe_surface *surface)
-{
-	struct nvfx_miptree *mt = (struct nvfx_miptree *)surface->texture;
-	return mt->buffer;
-}
 
-#define nvfx_surface_buffer(ps) nouveau_bo(nvfx_do_surface_buffer(ps))
 
-static boolean
+void
 nvfx_state_framebuffer_validate(struct nvfx_context *nvfx)
 {
 	struct pipe_framebuffer_state *fb = &nvfx->framebuffer;
 	struct nouveau_channel *chan = nvfx->screen->base.channel;
-	struct nouveau_grobj *eng3d = nvfx->screen->eng3d;
-	struct nv04_surface *rt[4], *zeta = NULL;
 	uint32_t rt_enable = 0, rt_format = 0;
 	int i, colour_format = 0, zeta_format = 0;
 	int depth_only = 0;
-	struct nouveau_stateobj *so = so_new(18, 24, 10);
 	unsigned rt_flags = NOUVEAU_BO_RDWR | NOUVEAU_BO_VRAM;
 	unsigned w = fb->width;
 	unsigned h = fb->height;
@@ -32,14 +23,18 @@ nvfx_state_framebuffer_validate(struct nvfx_context *nvfx)
 		assert(fb->nr_cbufs <= 4);
 
 	for (i = 0; i < fb->nr_cbufs; i++) {
-		if (colour_format) {
+		if (colour_format)
 			assert(colour_format == fb->cbufs[i]->format);
-		} else {
+		else
 			colour_format = fb->cbufs[i]->format;
-			rt_enable |= (NV34TCL_RT_ENABLE_COLOR0 << i);
-			rt[i] = (struct nv04_surface *)fb->cbufs[i];
-		}
+
+		rt_enable |= (NV34TCL_RT_ENABLE_COLOR0 << i);
+		nvfx->hw_rt[i].bo = nvfx_surface_buffer(fb->cbufs[i]);
+		nvfx->hw_rt[i].offset = fb->cbufs[i]->offset;
+		nvfx->hw_rt[i].pitch = ((struct nv04_surface *)fb->cbufs[i])->pitch;
 	}
+	for(; i < 4; ++i)
+		nvfx->hw_rt[i].bo = 0;
 
 	if (rt_enable & (NV34TCL_RT_ENABLE_COLOR1 |
 			 NV40TCL_RT_ENABLE_COLOR2 | NV40TCL_RT_ENABLE_COLOR3))
@@ -47,20 +42,24 @@ nvfx_state_framebuffer_validate(struct nvfx_context *nvfx)
 
 	if (fb->zsbuf) {
 		zeta_format = fb->zsbuf->format;
-		zeta = (struct nv04_surface *)fb->zsbuf;
+		nvfx->hw_zeta.bo = nvfx_surface_buffer(fb->zsbuf);
+		nvfx->hw_zeta.offset = fb->zsbuf->offset;
+		nvfx->hw_zeta.pitch = ((struct nv04_surface *)fb->zsbuf)->pitch;
 	}
+	else
+		nvfx->hw_zeta.bo = 0;
 
 	if (rt_enable & (NV34TCL_RT_ENABLE_COLOR0 | NV34TCL_RT_ENABLE_COLOR1 |
 		NV40TCL_RT_ENABLE_COLOR2 | NV40TCL_RT_ENABLE_COLOR3)) {
 		/* Render to at least a colour buffer */
-		if (!(rt[0]->base.texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
+		if (!(fb->cbufs[0]->texture->flags & NVFX_RESOURCE_FLAG_LINEAR)) {
 			assert(!(fb->width & (fb->width - 1)) && !(fb->height & (fb->height - 1)));
 			for (i = 1; i < fb->nr_cbufs; i++)
-				assert(!(rt[i]->base.texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR));
+				assert(!(fb->cbufs[i]->texture->flags & NVFX_RESOURCE_FLAG_LINEAR));
 
 			rt_format = NV34TCL_RT_FORMAT_TYPE_SWIZZLED |
-				(log2i(rt[0]->base.width) << NV34TCL_RT_FORMAT_LOG2_WIDTH_SHIFT) |
-				(log2i(rt[0]->base.height) << NV34TCL_RT_FORMAT_LOG2_HEIGHT_SHIFT);
+				(log2i(fb->cbufs[0]->width) << NV34TCL_RT_FORMAT_LOG2_WIDTH_SHIFT) |
+				(log2i(fb->cbufs[0]->height) << NV34TCL_RT_FORMAT_LOG2_HEIGHT_SHIFT);
 		}
 		else
 			rt_format = NV34TCL_RT_FORMAT_TYPE_LINEAR;
@@ -68,17 +67,17 @@ nvfx_state_framebuffer_validate(struct nvfx_context *nvfx)
 		depth_only = 1;
 
 		/* Render to depth buffer only */
-		if (!(zeta->base.texture->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)) {
+		if (!(fb->zsbuf->texture->_usage & NVFX_RESOURCE_FLAG_LINEAR)) {
 			assert(!(fb->width & (fb->width - 1)) && !(fb->height & (fb->height - 1)));
 
 			rt_format = NV34TCL_RT_FORMAT_TYPE_SWIZZLED |
-				(log2i(zeta->base.width) << NV34TCL_RT_FORMAT_LOG2_WIDTH_SHIFT) |
-				(log2i(zeta->base.height) << NV34TCL_RT_FORMAT_LOG2_HEIGHT_SHIFT);
+				(log2i(fb->zsbuf->width) << NV34TCL_RT_FORMAT_LOG2_WIDTH_SHIFT) |
+				(log2i(fb->zsbuf->height) << NV34TCL_RT_FORMAT_LOG2_HEIGHT_SHIFT);
 		}
 		else
 			rt_format = NV34TCL_RT_FORMAT_TYPE_LINEAR;
 	} else {
-		return FALSE;
+		return;
 	}
 
 	switch (colour_format) {
@@ -114,121 +113,138 @@ nvfx_state_framebuffer_validate(struct nvfx_context *nvfx)
 	if ((!nvfx->is_nv4x) && colour_bits > zeta_bits) {
 		/* TODO: does this limitation really exist?
 		   TODO: can it be worked around somehow? */
-		return FALSE;
+		assert(0);
 	}
 
 	if ((rt_enable & NV34TCL_RT_ENABLE_COLOR0)
 		|| ((!nvfx->is_nv4x) && depth_only)) {
-		struct nv04_surface *rt0 = (depth_only ? zeta : rt[0]);
+		struct nvfx_render_target *rt0 = (depth_only ? &nvfx->hw_zeta : &nvfx->hw_rt[0]);
 		uint32_t pitch = rt0->pitch;
 
 		if(!nvfx->is_nv4x)
 		{
-			if (zeta) {
-				pitch |= (zeta->pitch << 16);
+			if (nvfx->hw_zeta.bo) {
+				pitch |= (nvfx->hw_zeta.pitch << 16);
 			} else {
 				pitch |= (pitch << 16);
 			}
 		}
 
-		so_method(so, eng3d, NV34TCL_DMA_COLOR0, 1);
-		so_reloc (so, nvfx_surface_buffer(&rt0->base), 0,
+		OUT_RING(chan, RING_3D(NV34TCL_DMA_COLOR0, 1));
+		OUT_RELOC(chan, rt0->bo, 0,
 			      rt_flags | NOUVEAU_BO_OR,
 			      chan->vram->handle, chan->gart->handle);
-		so_method(so, eng3d, NV34TCL_COLOR0_PITCH, 2);
-		so_data  (so, pitch);
-		so_reloc (so, nvfx_surface_buffer(&rt[0]->base),
-			      rt0->base.offset, rt_flags | NOUVEAU_BO_LOW,
+		OUT_RING(chan, RING_3D(NV34TCL_COLOR0_PITCH, 2));
+		OUT_RING(chan, pitch);
+		OUT_RELOC(chan, rt0->bo,
+			      rt0->offset, rt_flags | NOUVEAU_BO_LOW,
 			      0, 0);
 	}
 
 	if (rt_enable & NV34TCL_RT_ENABLE_COLOR1) {
-		so_method(so, eng3d, NV34TCL_DMA_COLOR1, 1);
-		so_reloc (so, nvfx_surface_buffer(&rt[1]->base), 0,
+		OUT_RING(chan, RING_3D(NV34TCL_DMA_COLOR1, 1));
+		OUT_RELOC(chan, nvfx->hw_rt[1].bo, 0,
 			      rt_flags | NOUVEAU_BO_OR,
 			      chan->vram->handle, chan->gart->handle);
-		so_method(so, eng3d, NV34TCL_COLOR1_OFFSET, 2);
-		so_reloc (so, nvfx_surface_buffer(&rt[1]->base),
-			      rt[1]->base.offset, rt_flags | NOUVEAU_BO_LOW,
+		OUT_RING(chan, RING_3D(NV34TCL_COLOR1_OFFSET, 2));
+		OUT_RELOC(chan, nvfx->hw_rt[1].bo,
+				nvfx->hw_rt[1].offset, rt_flags | NOUVEAU_BO_LOW,
 			      0, 0);
-		so_data  (so, rt[1]->pitch);
+		OUT_RING(chan, nvfx->hw_rt[1].pitch);
 	}
 
 	if(nvfx->is_nv4x)
 	{
 		if (rt_enable & NV40TCL_RT_ENABLE_COLOR2) {
-			so_method(so, eng3d, NV40TCL_DMA_COLOR2, 1);
-			so_reloc (so, nvfx_surface_buffer(&rt[2]->base), 0,
+			OUT_RING(chan, RING_3D(NV40TCL_DMA_COLOR2, 1));
+			OUT_RELOC(chan, nvfx->hw_rt[2].bo, 0,
 				      rt_flags | NOUVEAU_BO_OR,
 				      chan->vram->handle, chan->gart->handle);
-			so_method(so, eng3d, NV40TCL_COLOR2_OFFSET, 1);
-			so_reloc (so, nvfx_surface_buffer(&rt[2]->base),
-				      rt[2]->base.offset, rt_flags | NOUVEAU_BO_LOW,
+			OUT_RING(chan, RING_3D(NV40TCL_COLOR2_OFFSET, 1));
+			OUT_RELOC(chan, nvfx->hw_rt[2].bo,
+				      nvfx->hw_rt[2].offset, rt_flags | NOUVEAU_BO_LOW,
 				      0, 0);
-			so_method(so, eng3d, NV40TCL_COLOR2_PITCH, 1);
-			so_data  (so, rt[2]->pitch);
+			OUT_RING(chan, RING_3D(NV40TCL_COLOR2_PITCH, 1));
+			OUT_RING(chan, nvfx->hw_rt[2].pitch);
 		}
 
 		if (rt_enable & NV40TCL_RT_ENABLE_COLOR3) {
-			so_method(so, eng3d, NV40TCL_DMA_COLOR3, 1);
-			so_reloc (so, nvfx_surface_buffer(&rt[3]->base), 0,
+			OUT_RING(chan, RING_3D(NV40TCL_DMA_COLOR3, 1));
+			OUT_RELOC(chan, nvfx->hw_rt[3].bo, 0,
 				      rt_flags | NOUVEAU_BO_OR,
 				      chan->vram->handle, chan->gart->handle);
-			so_method(so, eng3d, NV40TCL_COLOR3_OFFSET, 1);
-			so_reloc (so, nvfx_surface_buffer(&rt[3]->base),
-				      rt[3]->base.offset, rt_flags | NOUVEAU_BO_LOW,
+			OUT_RING(chan, RING_3D(NV40TCL_COLOR3_OFFSET, 1));
+			OUT_RELOC(chan, nvfx->hw_rt[3].bo,
+					nvfx->hw_rt[3].offset, rt_flags | NOUVEAU_BO_LOW,
 				      0, 0);
-			so_method(so, eng3d, NV40TCL_COLOR3_PITCH, 1);
-			so_data  (so, rt[3]->pitch);
+			OUT_RING(chan, RING_3D(NV40TCL_COLOR3_PITCH, 1));
+			OUT_RING(chan, nvfx->hw_rt[3].pitch);
 		}
 	}
 
 	if (zeta_format) {
-		so_method(so, eng3d, NV34TCL_DMA_ZETA, 1);
-		so_reloc (so, nvfx_surface_buffer(&zeta->base), 0,
+		OUT_RING(chan, RING_3D(NV34TCL_DMA_ZETA, 1));
+		OUT_RELOC(chan, nvfx->hw_zeta.bo, 0,
 			      rt_flags | NOUVEAU_BO_OR,
 			      chan->vram->handle, chan->gart->handle);
-		so_method(so, eng3d, NV34TCL_ZETA_OFFSET, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_ZETA_OFFSET, 1));
 		/* TODO: reverse engineer LMA */
-		so_reloc (so, nvfx_surface_buffer(&zeta->base),
-			      zeta->base.offset, rt_flags | NOUVEAU_BO_LOW, 0, 0);
+		OUT_RELOC(chan, nvfx->hw_zeta.bo,
+			     nvfx->hw_zeta.offset, rt_flags | NOUVEAU_BO_LOW, 0, 0);
 	        if(nvfx->is_nv4x) {
-			so_method(so, eng3d, NV40TCL_ZETA_PITCH, 1);
-			so_data  (so, zeta->pitch);
+			OUT_RING(chan, RING_3D(NV40TCL_ZETA_PITCH, 1));
+			OUT_RING(chan, nvfx->hw_zeta.pitch);
 		}
 	}
 
-	so_method(so, eng3d, NV34TCL_RT_ENABLE, 1);
-	so_data  (so, rt_enable);
-	so_method(so, eng3d, NV34TCL_RT_HORIZ, 3);
-	so_data  (so, (w << 16) | 0);
-	so_data  (so, (h << 16) | 0);
-	so_data  (so, rt_format);
-	so_method(so, eng3d, NV34TCL_VIEWPORT_HORIZ, 2);
-	so_data  (so, (w << 16) | 0);
-	so_data  (so, (h << 16) | 0);
-	so_method(so, eng3d, NV34TCL_VIEWPORT_CLIP_HORIZ(0), 2);
-	so_data  (so, ((w - 1) << 16) | 0);
-	so_data  (so, ((h - 1) << 16) | 0);
-	so_method(so, eng3d, 0x1d88, 1);
-	so_data  (so, (1 << 12) | h);
+	OUT_RING(chan, RING_3D(NV34TCL_RT_ENABLE, 1));
+	OUT_RING(chan, rt_enable);
+	OUT_RING(chan, RING_3D(NV34TCL_RT_HORIZ, 3));
+	OUT_RING(chan, (w << 16) | 0);
+	OUT_RING(chan, (h << 16) | 0);
+	OUT_RING(chan, rt_format);
+	OUT_RING(chan, RING_3D(NV34TCL_VIEWPORT_HORIZ, 2));
+	OUT_RING(chan, (w << 16) | 0);
+	OUT_RING(chan, (h << 16) | 0);
+	OUT_RING(chan, RING_3D(NV34TCL_VIEWPORT_CLIP_HORIZ(0), 2));
+	OUT_RING(chan, ((w - 1) << 16) | 0);
+	OUT_RING(chan, ((h - 1) << 16) | 0);
+	OUT_RING(chan, RING_3D(0x1d88, 1));
+	OUT_RING(chan, (1 << 12) | h);
 
 	if(!nvfx->is_nv4x) {
 		/* Wonder why this is needed, context should all be set to zero on init */
 		/* TODO: we can most likely remove this, after putting it in context init */
-		so_method(so, eng3d, NV34TCL_VIEWPORT_TX_ORIGIN, 1);
-		so_data  (so, 0);
+		OUT_RING(chan, RING_3D(NV34TCL_VIEWPORT_TX_ORIGIN, 1));
+		OUT_RING(chan, 0);
 	}
-
-	so_ref(so, &nvfx->state.hw[NVFX_STATE_FB]);
-	so_ref(NULL, &so);
-	return TRUE;
 }
 
-struct nvfx_state_entry nvfx_state_framebuffer = {
-	.validate = nvfx_state_framebuffer_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_FB,
-		.hw = NVFX_STATE_FB
+void
+nvfx_framebuffer_relocate(struct nvfx_context *nvfx)
+{
+	struct nouveau_channel *chan = nvfx->screen->base.channel;
+	unsigned rt_flags = NOUVEAU_BO_RDWR | NOUVEAU_BO_VRAM;
+	rt_flags |= NOUVEAU_BO_DUMMY;
+	MARK_RING(chan, 20, 20);
+
+#define DO_(var, pfx, name) \
+	if(var.bo) { \
+		OUT_RELOC(chan, var.bo, RING_3D(pfx##TCL_DMA_##name, 1), rt_flags, 0, 0); \
+		OUT_RELOC(chan, var.bo, 0, \
+			rt_flags | NOUVEAU_BO_OR, \
+			chan->vram->handle, chan->gart->handle); \
+		OUT_RELOC(chan, var.bo, RING_3D(pfx##TCL_##name##_OFFSET, 1), rt_flags, 0, 0); \
+		OUT_RELOC(chan, var.bo, \
+			var.offset, rt_flags | NOUVEAU_BO_LOW, \
+			0, 0); \
 	}
-};
+
+#define DO(pfx, num) DO_(nvfx->hw_rt[num], pfx, COLOR##num)
+	DO(NV34, 0);
+	DO(NV34, 1);
+	DO(NV40, 2);
+	DO(NV40, 3);
+
+	DO_(nvfx->hw_zeta, NV34, ZETA);
+}
diff --git a/src/gallium/drivers/nvfx/nvfx_state_rasterizer.c b/src/gallium/drivers/nvfx/nvfx_state_rasterizer.c
index 0d35ecbf209..7f14ae85d5a 100644
--- a/src/gallium/drivers/nvfx/nvfx_state_rasterizer.c
+++ b/src/gallium/drivers/nvfx/nvfx_state_rasterizer.c
@@ -1,17 +1,9 @@
 #include "nvfx_context.h"
 
-static boolean
+void
 nvfx_state_rasterizer_validate(struct nvfx_context *nvfx)
 {
-	so_ref(nvfx->rasterizer->so,
-	       &nvfx->state.hw[NVFX_STATE_RAST]);
-	return TRUE;
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
+	sb_emit(chan, nvfx->rasterizer->sb, nvfx->rasterizer->sb_len);
 }
 
-struct nvfx_state_entry nvfx_state_rasterizer = {
-	.validate = nvfx_state_rasterizer_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_RAST,
-		.hw = NVFX_STATE_RAST
-	}
-};
diff --git a/src/gallium/drivers/nvfx/nvfx_state_scissor.c b/src/gallium/drivers/nvfx/nvfx_state_scissor.c
index 940d8cb5c0c..9077266120a 100644
--- a/src/gallium/drivers/nvfx/nvfx_state_scissor.c
+++ b/src/gallium/drivers/nvfx/nvfx_state_scissor.c
@@ -1,36 +1,23 @@
 #include "nvfx_context.h"
 
-static boolean
+void
 nvfx_state_scissor_validate(struct nvfx_context *nvfx)
 {
+	struct nouveau_channel *chan = nvfx->screen->base.channel;
 	struct pipe_rasterizer_state *rast = &nvfx->rasterizer->pipe;
 	struct pipe_scissor_state *s = &nvfx->scissor;
-	struct nouveau_stateobj *so;
 
-	if (nvfx->state.hw[NVFX_STATE_SCISSOR] &&
-	    (rast->scissor == 0 && nvfx->state.scissor_enabled == 0))
-		return FALSE;
+	if ((rast->scissor == 0 && nvfx->state.scissor_enabled == 0))
+		return;
 	nvfx->state.scissor_enabled = rast->scissor;
 
-	so = so_new(1, 2, 0);
-	so_method(so, nvfx->screen->eng3d, NV34TCL_SCISSOR_HORIZ, 2);
+	WAIT_RING(chan, 3);
+	OUT_RING(chan, RING_3D(NV34TCL_SCISSOR_HORIZ, 2));
 	if (nvfx->state.scissor_enabled) {
-		so_data  (so, ((s->maxx - s->minx) << 16) | s->minx);
-		so_data  (so, ((s->maxy - s->miny) << 16) | s->miny);
+		OUT_RING(chan, ((s->maxx - s->minx) << 16) | s->minx);
+		OUT_RING(chan, ((s->maxy - s->miny) << 16) | s->miny);
 	} else {
-		so_data  (so, 4096 << 16);
-		so_data  (so, 4096 << 16);
+		OUT_RING(chan, 4096 << 16);
+		OUT_RING(chan, 4096 << 16);
 	}
-
-	so_ref(so, &nvfx->state.hw[NVFX_STATE_SCISSOR]);
-	so_ref(NULL, &so);
-	return TRUE;
 }
-
-struct nvfx_state_entry nvfx_state_scissor = {
-	.validate = nvfx_state_scissor_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_SCISSOR | NVFX_NEW_RAST,
-		.hw = NVFX_STATE_SCISSOR
-	}
-};
diff --git a/src/gallium/drivers/nvfx/nvfx_state_stipple.c b/src/gallium/drivers/nvfx/nvfx_state_stipple.c
index 57cd3c936a7..4da968f093f 100644
--- a/src/gallium/drivers/nvfx/nvfx_state_stipple.c
+++ b/src/gallium/drivers/nvfx/nvfx_state_stipple.c
@@ -1,40 +1,26 @@
 #include "nvfx_context.h"
 
-static boolean
+void
 nvfx_state_stipple_validate(struct nvfx_context *nvfx)
 {
+	struct nouveau_channel *chan = nvfx->screen->base.channel;
 	struct pipe_rasterizer_state *rast = &nvfx->rasterizer->pipe;
-	struct nouveau_grobj *eng3d = nvfx->screen->eng3d;
-	struct nouveau_stateobj *so;
 
-	if (nvfx->state.hw[NVFX_STATE_STIPPLE] &&
-	   (rast->poly_stipple_enable == 0 && nvfx->state.stipple_enabled == 0))
-		return FALSE;
+	if ((rast->poly_stipple_enable == 0 && nvfx->state.stipple_enabled == 0))
+		return;
 
 	if (rast->poly_stipple_enable) {
 		unsigned i;
 
-		so = so_new(2, 33, 0);
-		so_method(so, eng3d, NV34TCL_POLYGON_STIPPLE_ENABLE, 1);
-		so_data  (so, 1);
-		so_method(so, eng3d, NV34TCL_POLYGON_STIPPLE_PATTERN(0), 32);
+		WAIT_RING(chan, 35);
+		OUT_RING(chan, RING_3D(NV34TCL_POLYGON_STIPPLE_ENABLE, 1));
+		OUT_RING(chan, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_POLYGON_STIPPLE_PATTERN(0), 32));
 		for (i = 0; i < 32; i++)
-			so_data(so, nvfx->stipple[i]);
+			OUT_RING(chan, nvfx->stipple[i]);
 	} else {
-		so = so_new(1, 1, 0);
-		so_method(so, eng3d, NV34TCL_POLYGON_STIPPLE_ENABLE, 1);
-		so_data  (so, 0);
+		WAIT_RING(chan, 2);
+		OUT_RING(chan, RING_3D(NV34TCL_POLYGON_STIPPLE_ENABLE, 1));
+		OUT_RING(chan, 0);
 	}
-
-	so_ref(so, &nvfx->state.hw[NVFX_STATE_STIPPLE]);
-	so_ref(NULL, &so);
-	return TRUE;
 }
-
-struct nvfx_state_entry nvfx_state_stipple = {
-	.validate = nvfx_state_stipple_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_STIPPLE | NVFX_NEW_RAST,
-		.hw = NVFX_STATE_STIPPLE,
-	}
-};
diff --git a/src/gallium/drivers/nvfx/nvfx_state_viewport.c b/src/gallium/drivers/nvfx/nvfx_state_viewport.c
index ec730e3a9e9..e983b16f321 100644
--- a/src/gallium/drivers/nvfx/nvfx_state_viewport.c
+++ b/src/gallium/drivers/nvfx/nvfx_state_viewport.c
@@ -1,52 +1,35 @@
 #include "nvfx_context.h"
 
-/* Having this depend on FB and RAST looks wrong, but it seems
-   necessary to make this work on nv3x
-   TODO: find the right fix
-*/
-
-static boolean
+void
 nvfx_state_viewport_validate(struct nvfx_context *nvfx)
 {
+	struct nouveau_channel *chan = nvfx->screen->base.channel;
 	struct pipe_viewport_state *vpt = &nvfx->viewport;
-	struct nouveau_stateobj *so;
 
-	so = so_new(2, 9, 0);
-	so_method(so, nvfx->screen->eng3d,
-		  NV34TCL_VIEWPORT_TRANSLATE_X, 8);
+	WAIT_RING(chan, 11);
 	if(nvfx->render_mode == HW) {
-		so_data  (so, fui(vpt->translate[0]));
-		so_data  (so, fui(vpt->translate[1]));
-		so_data  (so, fui(vpt->translate[2]));
-		so_data  (so, fui(vpt->translate[3]));
-		so_data  (so, fui(vpt->scale[0]));
-		so_data  (so, fui(vpt->scale[1]));
-		so_data  (so, fui(vpt->scale[2]));
-		so_data  (so, fui(vpt->scale[3]));
-		so_method(so, nvfx->screen->eng3d, 0x1d78, 1);
-		so_data  (so, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VIEWPORT_TRANSLATE_X, 8));
+		OUT_RINGf(chan, vpt->translate[0]);
+		OUT_RINGf(chan, vpt->translate[1]);
+		OUT_RINGf(chan, vpt->translate[2]);
+		OUT_RINGf(chan, vpt->translate[3]);
+		OUT_RINGf(chan, vpt->scale[0]);
+		OUT_RINGf(chan, vpt->scale[1]);
+		OUT_RINGf(chan, vpt->scale[2]);
+		OUT_RINGf(chan, vpt->scale[3]);
+		OUT_RING(chan, RING_3D(0x1d78, 1));
+		OUT_RING(chan, 1);
 	} else {
-		so_data  (so, fui(0.0f));
-		so_data  (so, fui(0.0f));
-		so_data  (so, fui(0.0f));
-		so_data  (so, fui(0.0f));
-		so_data  (so, fui(1.0f));
-		so_data  (so, fui(1.0f));
-		so_data  (so, fui(1.0f));
-		so_data  (so, fui(1.0f));
-		so_method(so, nvfx->screen->eng3d, 0x1d78, 1);
-		so_data  (so, nvfx->is_nv4x ? 0x110 : 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VIEWPORT_TRANSLATE_X, 8));
+		OUT_RINGf(chan, 0.0f);
+		OUT_RINGf(chan, 0.0f);
+		OUT_RINGf(chan, 0.0f);
+		OUT_RINGf(chan, 0.0f);
+		OUT_RINGf(chan, 1.0f);
+		OUT_RINGf(chan, 1.0f);
+		OUT_RINGf(chan, 1.0f);
+		OUT_RINGf(chan, 1.0f);
+		OUT_RING(chan, RING_3D(0x1d78, 1));
+		OUT_RING(chan, nvfx->is_nv4x ? 0x110 : 1);
 	}
-
-	so_ref(so, &nvfx->state.hw[NVFX_STATE_VIEWPORT]);
-	so_ref(NULL, &so);
-	return TRUE;
 }
-
-struct nvfx_state_entry nvfx_state_viewport = {
-	.validate = nvfx_state_viewport_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_VIEWPORT | NVFX_NEW_FB | NVFX_NEW_RAST,
-		.hw = NVFX_STATE_VIEWPORT
-	}
-};
diff --git a/src/gallium/drivers/nvfx/nvfx_state_zsa.c b/src/gallium/drivers/nvfx/nvfx_state_zsa.c
index c84fd041c1e..608605d32bd 100644
--- a/src/gallium/drivers/nvfx/nvfx_state_zsa.c
+++ b/src/gallium/drivers/nvfx/nvfx_state_zsa.c
@@ -1,41 +1,21 @@
 #include "nvfx_context.h"
 
-static boolean
+void
 nvfx_state_zsa_validate(struct nvfx_context *nvfx)
 {
-	so_ref(nvfx->zsa->so,
-	       &nvfx->state.hw[NVFX_STATE_ZSA]);
-	return TRUE;
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
+	sb_emit(chan, nvfx->zsa->sb, nvfx->zsa->sb_len);
 }
 
-struct nvfx_state_entry nvfx_state_zsa = {
-	.validate = nvfx_state_zsa_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_ZSA,
-		.hw = NVFX_STATE_ZSA
-	}
-};
-
-static boolean
+void
 nvfx_state_sr_validate(struct nvfx_context *nvfx)
 {
-	struct nouveau_stateobj *so = so_new(2, 2, 0);
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
 	struct pipe_stencil_ref *sr = &nvfx->stencil_ref;
 
-	so_method(so, nvfx->screen->eng3d, NV34TCL_STENCIL_FRONT_FUNC_REF, 1);
-	so_data  (so, sr->ref_value[0]);
-	so_method(so, nvfx->screen->eng3d, NV34TCL_STENCIL_BACK_FUNC_REF, 1);
-	so_data  (so, sr->ref_value[1]);
-
-	so_ref(so, &nvfx->state.hw[NVFX_STATE_SR]);
-	so_ref(NULL, &so);
-	return TRUE;
+	WAIT_RING(chan, 4);
+	OUT_RING(chan, RING_3D(NV34TCL_STENCIL_FRONT_FUNC_REF, 1));
+	OUT_RING(chan, sr->ref_value[0]);
+	OUT_RING(chan, RING_3D(NV34TCL_STENCIL_BACK_FUNC_REF, 1));
+	OUT_RING(chan, sr->ref_value[1]);
 }
-
-struct nvfx_state_entry nvfx_state_sr = {
-	.validate = nvfx_state_sr_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_SR,
-		.hw = NVFX_STATE_SR
-	}
-};
diff --git a/src/gallium/drivers/nvfx/nvfx_transfer.c b/src/gallium/drivers/nvfx/nvfx_transfer.c
index 1c250e9fe44..a776ab58311 100644
--- a/src/gallium/drivers/nvfx/nvfx_transfer.c
+++ b/src/gallium/drivers/nvfx/nvfx_transfer.c
@@ -8,6 +8,8 @@
 #include "nvfx_context.h"
 #include "nvfx_screen.h"
 #include "nvfx_state.h"
+#include "nvfx_resource.h"
+#include "nvfx_transfer.h"
 
 struct nvfx_transfer {
 	struct pipe_transfer base;
@@ -16,10 +18,11 @@ struct nvfx_transfer {
 };
 
 static void
-nvfx_compatible_transfer_tex(struct pipe_texture *pt, unsigned width, unsigned height,
-                             struct pipe_texture *template)
+nvfx_compatible_transfer_tex(struct pipe_resource *pt, unsigned width, unsigned height,
+			     unsigned bind,
+                             struct pipe_resource *template)
 {
-	memset(template, 0, sizeof(struct pipe_texture));
+	memset(template, 0, sizeof(struct pipe_resource));
 	template->target = pt->target;
 	template->format = pt->format;
 	template->width0 = width;
@@ -27,56 +30,77 @@ nvfx_compatible_transfer_tex(struct pipe_texture *pt, unsigned width, unsigned h
 	template->depth0 = 1;
 	template->last_level = 0;
 	template->nr_samples = pt->nr_samples;
+	template->bind = bind;
+	template->_usage = PIPE_USAGE_DYNAMIC;
+	template->flags = NVFX_RESOURCE_FLAG_LINEAR;
+}
+
+
+static unsigned nvfx_transfer_bind_flags( unsigned transfer_usage )
+{
+	unsigned bind = 0;
+
+	if (transfer_usage & PIPE_TRANSFER_WRITE)
+		bind |= PIPE_BIND_BLIT_SOURCE;
 
-	template->tex_usage = PIPE_TEXTURE_USAGE_DYNAMIC |
-	                      NOUVEAU_TEXTURE_USAGE_LINEAR;
+	if (transfer_usage & PIPE_TRANSFER_READ)
+		bind |= PIPE_BIND_BLIT_DESTINATION;
+
+	return bind;
 }
 
-static struct pipe_transfer *
-nvfx_transfer_new(struct pipe_context *pipe, struct pipe_texture *pt,
-		  unsigned face, unsigned level, unsigned zslice,
-		  enum pipe_transfer_usage usage,
-		  unsigned x, unsigned y, unsigned w, unsigned h)
+struct pipe_transfer *
+nvfx_miptree_transfer_new(struct pipe_context *pipe,
+			  struct pipe_resource *pt,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box)
 {
 	struct pipe_screen *pscreen = pipe->screen;
 	struct nvfx_miptree *mt = (struct nvfx_miptree *)pt;
 	struct nvfx_transfer *tx;
-	struct pipe_texture tx_tex_template, *tx_tex;
+	struct pipe_resource tx_tex_template, *tx_tex;
 	static int no_transfer = -1;
+	unsigned bind = nvfx_transfer_bind_flags(usage);
 	if(no_transfer < 0)
-		no_transfer = debug_get_bool_option("NOUVEAU_NO_TRANSFER", TRUE/*XXX:FALSE*/);
+		no_transfer = debug_get_bool_option("NOUVEAU_NO_TRANSFER", FALSE);
+
 
 	tx = CALLOC_STRUCT(nvfx_transfer);
 	if (!tx)
 		return NULL;
 
-	pipe_texture_reference(&tx->base.texture, pt);
-	tx->base.x = x;
-	tx->base.y = y;
-	tx->base.width = w;
-	tx->base.height = h;
-	tx->base.stride = mt->level[level].pitch;
+	/* Don't handle 3D transfers yet.
+	 */
+	assert(box->depth == 1);
+
+	pipe_resource_reference(&tx->base.resource, pt);
+	tx->base.sr = sr;
 	tx->base.usage = usage;
-	tx->base.face = face;
-	tx->base.level = level;
-	tx->base.zslice = zslice;
+	tx->base.box = *box;
+	tx->base.stride = mt->level[sr.level].pitch;
 
 	/* Direct access to texture */
-	if ((pt->tex_usage & PIPE_TEXTURE_USAGE_DYNAMIC || no_transfer) &&
-	    pt->tex_usage & NOUVEAU_TEXTURE_USAGE_LINEAR)
+	if ((pt->_usage == PIPE_USAGE_DYNAMIC ||
+	     no_transfer) &&
+	    pt->flags & NVFX_RESOURCE_FLAG_LINEAR)
 	{
 		tx->direct = true;
+
+		/* XXX: just call the internal nvfx function.  
+		 */
 		tx->surface = pscreen->get_tex_surface(pscreen, pt,
-	                                               face, level, zslice,
-	                                               pipe_transfer_buffer_flags(&tx->base));
+	                                               sr.face, sr.level,
+						       box->z,
+	                                               bind);
 		return &tx->base;
 	}
 
 	tx->direct = false;
 
-	nvfx_compatible_transfer_tex(pt, w, h, &tx_tex_template);
+	nvfx_compatible_transfer_tex(pt, box->width, box->height, bind, &tx_tex_template);
 
-	tx_tex = pscreen->texture_create(pscreen, &tx_tex_template);
+	tx_tex = pscreen->resource_create(pscreen, &tx_tex_template);
 	if (!tx_tex)
 	{
 		FREE(tx);
@@ -87,9 +111,9 @@ nvfx_transfer_new(struct pipe_context *pipe, struct pipe_texture *pt,
 
 	tx->surface = pscreen->get_tex_surface(pscreen, tx_tex,
 	                                       0, 0, 0,
-	                                       pipe_transfer_buffer_flags(&tx->base));
+	                                       bind);
 
-	pipe_texture_reference(&tx_tex, NULL);
+	pipe_resource_reference(&tx_tex, NULL);
 
 	if (!tx->surface)
 	{
@@ -103,15 +127,16 @@ nvfx_transfer_new(struct pipe_context *pipe, struct pipe_texture *pt,
 		struct pipe_surface *src;
 
 		src = pscreen->get_tex_surface(pscreen, pt,
-	                                       face, level, zslice,
-	                                       PIPE_BUFFER_USAGE_GPU_READ);
+	                                       sr.face, sr.level, box->z,
+	                                       PIPE_BIND_BLIT_SOURCE);
 
 		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
 		/* TODO: Check if SIFM can un-swizzle */
 		nvscreen->eng2d->copy(nvscreen->eng2d,
 		                      tx->surface, 0, 0,
-		                      src, x, y,
-		                      w, h);
+		                      src,
+				      box->x, box->y,
+		                      box->width, box->height);
 
 		pipe_surface_reference(&src, NULL);
 	}
@@ -119,9 +144,9 @@ nvfx_transfer_new(struct pipe_context *pipe, struct pipe_texture *pt,
 	return &tx->base;
 }
 
-static void
-nvfx_transfer_del(struct pipe_context *pipe,
-                  struct pipe_transfer *ptx)
+void
+nvfx_miptree_transfer_del(struct pipe_context *pipe,
+			  struct pipe_transfer *ptx)
 {
 	struct nvfx_transfer *tx = (struct nvfx_transfer *)ptx;
 
@@ -130,55 +155,51 @@ nvfx_transfer_del(struct pipe_context *pipe,
 		struct nvfx_screen *nvscreen = nvfx_screen(pscreen);
 		struct pipe_surface *dst;
 
-		dst = pscreen->get_tex_surface(pscreen, ptx->texture,
-	                                       ptx->face, ptx->level, ptx->zslice,
-	                                       PIPE_BUFFER_USAGE_GPU_WRITE | NOUVEAU_BUFFER_USAGE_NO_RENDER);
+		dst = pscreen->get_tex_surface(pscreen,
+					       ptx->resource,
+	                                       ptx->sr.face,
+					       ptx->sr.level,
+					       ptx->box.z,
+	                                       PIPE_BIND_BLIT_DESTINATION);
 
 		/* TODO: Check if SIFM can deal with x,y,w,h when swizzling */
 		nvscreen->eng2d->copy(nvscreen->eng2d,
-		                      dst, tx->base.x, tx->base.y,
+		                      dst, ptx->box.x, ptx->box.y,
 		                      tx->surface, 0, 0,
-		                      tx->base.width, tx->base.height);
+		                      ptx->box.width, ptx->box.height);
 
 		pipe_surface_reference(&dst, NULL);
 	}
 
 	pipe_surface_reference(&tx->surface, NULL);
-	pipe_texture_reference(&ptx->texture, NULL);
+	pipe_resource_reference(&ptx->resource, NULL);
 	FREE(ptx);
 }
 
-static void *
-nvfx_transfer_map(struct pipe_context *pipe, struct pipe_transfer *ptx)
+void *
+nvfx_miptree_transfer_map(struct pipe_context *pipe, struct pipe_transfer *ptx)
 {
 	struct pipe_screen *pscreen = pipe->screen;
 	struct nvfx_transfer *tx = (struct nvfx_transfer *)ptx;
 	struct nv04_surface *ns = (struct nv04_surface *)tx->surface;
 	struct nvfx_miptree *mt = (struct nvfx_miptree *)tx->surface->texture;
-	void *map = pipe_buffer_map(pscreen, mt->buffer,
-	                            pipe_transfer_buffer_flags(ptx));
+	uint8_t *map = nouveau_screen_bo_map(pscreen, mt->base.bo,
+					     nouveau_screen_transfer_flags(ptx->usage));
 
 	if(!tx->direct)
 		return map + ns->base.offset;
 	else
-		return map + ns->base.offset + ptx->y * ns->pitch + ptx->x * util_format_get_blocksize(ptx->texture->format);
+		return (map + ns->base.offset + 
+			ptx->box.y * ns->pitch + 
+			ptx->box.x * util_format_get_blocksize(ptx->resource->format));
 }
 
-static void
-nvfx_transfer_unmap(struct pipe_context *pipe, struct pipe_transfer *ptx)
+void
+nvfx_miptree_transfer_unmap(struct pipe_context *pipe, struct pipe_transfer *ptx)
 {
 	struct pipe_screen *pscreen = pipe->screen;
 	struct nvfx_transfer *tx = (struct nvfx_transfer *)ptx;
 	struct nvfx_miptree *mt = (struct nvfx_miptree *)tx->surface->texture;
 
-	pipe_buffer_unmap(pscreen, mt->buffer);
-}
-
-void
-nvfx_init_transfer_functions(struct nvfx_context *nvfx)
-{
-	nvfx->pipe.get_tex_transfer = nvfx_transfer_new;
-	nvfx->pipe.tex_transfer_destroy = nvfx_transfer_del;
-	nvfx->pipe.transfer_map = nvfx_transfer_map;
-	nvfx->pipe.transfer_unmap = nvfx_transfer_unmap;
+	nouveau_screen_bo_unmap(pscreen, mt->base.bo);
 }
diff --git a/src/gallium/drivers/nvfx/nvfx_transfer.h b/src/gallium/drivers/nvfx/nvfx_transfer.h
new file mode 100644
index 00000000000..3e3317b2c7b
--- /dev/null
+++ b/src/gallium/drivers/nvfx/nvfx_transfer.h
@@ -0,0 +1,26 @@
+
+#ifndef NVFX_TRANSFER_H
+#define NVFX_TRANSFER_H
+
+#include "util/u_transfer.h"
+#include "pipe/p_state.h"
+
+
+struct pipe_transfer *
+nvfx_miptree_transfer_new(struct pipe_context *pcontext,
+			  struct pipe_resource *pt,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box);
+void
+nvfx_miptree_transfer_del(struct pipe_context *pcontext,
+			  struct pipe_transfer *ptx);
+void *
+nvfx_miptree_transfer_map(struct pipe_context *pcontext,
+			  struct pipe_transfer *ptx);
+void
+nvfx_miptree_transfer_unmap(struct pipe_context *pcontext,
+			    struct pipe_transfer *ptx);
+
+
+#endif
diff --git a/src/gallium/drivers/nvfx/nvfx_vbo.c b/src/gallium/drivers/nvfx/nvfx_vbo.c
index c26536b0e77..bc87fe275c0 100644
--- a/src/gallium/drivers/nvfx/nvfx_vbo.c
+++ b/src/gallium/drivers/nvfx/nvfx_vbo.c
@@ -5,20 +5,12 @@
 
 #include "nvfx_context.h"
 #include "nvfx_state.h"
+#include "nvfx_resource.h"
 
 #include "nouveau/nouveau_channel.h"
 #include "nouveau/nouveau_pushbuf.h"
 #include "nouveau/nouveau_util.h"
 
-static boolean
-nvfx_force_swtnl(struct nvfx_context *nvfx)
-{
-	static int force_swtnl = -1;
-	if(force_swtnl < 0)
-		force_swtnl = debug_get_bool_option("NOUVEAU_SWTNL", 0);
-	return force_swtnl;
-}
-
 static INLINE int
 nvfx_vbo_format_to_hw(enum pipe_format pipe, unsigned *fmt, unsigned *ncomp)
 {
@@ -29,6 +21,12 @@ nvfx_vbo_format_to_hw(enum pipe_format pipe, unsigned *fmt, unsigned *ncomp)
 	case PIPE_FORMAT_R32G32B32A32_FLOAT:
 		*fmt = NV34TCL_VTXFMT_TYPE_FLOAT;
 		break;
+	case PIPE_FORMAT_R16_FLOAT:
+	case PIPE_FORMAT_R16G16_FLOAT:
+	case PIPE_FORMAT_R16G16B16_FLOAT:
+	case PIPE_FORMAT_R16G16B16A16_FLOAT:
+		*fmt = NV34TCL_VTXFMT_TYPE_HALF;
+		break;
 	case PIPE_FORMAT_R8_UNORM:
 	case PIPE_FORMAT_R8G8_UNORM:
 	case PIPE_FORMAT_R8G8B8_UNORM:
@@ -49,21 +47,25 @@ nvfx_vbo_format_to_hw(enum pipe_format pipe, unsigned *fmt, unsigned *ncomp)
 	switch (pipe) {
 	case PIPE_FORMAT_R8_UNORM:
 	case PIPE_FORMAT_R32_FLOAT:
+	case PIPE_FORMAT_R16_FLOAT:
 	case PIPE_FORMAT_R16_SSCALED:
 		*ncomp = 1;
 		break;
 	case PIPE_FORMAT_R8G8_UNORM:
 	case PIPE_FORMAT_R32G32_FLOAT:
+	case PIPE_FORMAT_R16G16_FLOAT:
 	case PIPE_FORMAT_R16G16_SSCALED:
 		*ncomp = 2;
 		break;
 	case PIPE_FORMAT_R8G8B8_UNORM:
 	case PIPE_FORMAT_R32G32B32_FLOAT:
+	case PIPE_FORMAT_R16G16B16_FLOAT:
 	case PIPE_FORMAT_R16G16B16_SSCALED:
 		*ncomp = 3;
 		break;
 	case PIPE_FORMAT_R8G8B8A8_UNORM:
 	case PIPE_FORMAT_R32G32B32A32_FLOAT:
+	case PIPE_FORMAT_R16G16B16A16_FLOAT:
 	case PIPE_FORMAT_R16G16B16A16_SSCALED:
 		*ncomp = 4;
 		break;
@@ -76,7 +78,7 @@ nvfx_vbo_format_to_hw(enum pipe_format pipe, unsigned *fmt, unsigned *ncomp)
 }
 
 static boolean
-nvfx_vbo_set_idxbuf(struct nvfx_context *nvfx, struct pipe_buffer *ib,
+nvfx_vbo_set_idxbuf(struct nvfx_context *nvfx, struct pipe_resource *ib,
 		    unsigned ib_size)
 {
 	struct pipe_screen *pscreen = &nvfx->screen->base.base;
@@ -88,7 +90,7 @@ nvfx_vbo_set_idxbuf(struct nvfx_context *nvfx, struct pipe_buffer *ib,
 		return FALSE;
 	}
 
-	if (!pscreen->get_param(pscreen, NOUVEAU_CAP_HW_IDXBUF) || ib_size == 1)
+	if (!nvfx->screen->index_buffer_reloc_flags || ib_size == 1)
 		return FALSE;
 
 	switch (ib_size) {
@@ -112,63 +114,47 @@ nvfx_vbo_set_idxbuf(struct nvfx_context *nvfx, struct pipe_buffer *ib,
 	return TRUE;
 }
 
-static boolean
-nvfx_vbo_static_attrib(struct nvfx_context *nvfx, struct nouveau_stateobj *so,
+// type must be floating point
+static inline void
+nvfx_vbo_static_attrib(struct nvfx_context *nvfx,
 		       int attrib, struct pipe_vertex_element *ve,
-		       struct pipe_vertex_buffer *vb)
+		       struct pipe_vertex_buffer *vb, unsigned ncomp)
 {
-	struct pipe_screen *pscreen = nvfx->pipe.screen;
-	struct nouveau_grobj *eng3d = nvfx->screen->eng3d;
-	unsigned type, ncomp;
+	struct pipe_transfer *transfer;
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
 	void *map;
 
-	if (nvfx_vbo_format_to_hw(ve->src_format, &type, &ncomp))
-		return FALSE;
-
-	map  = pipe_buffer_map(pscreen, vb->buffer, PIPE_BUFFER_USAGE_CPU_READ);
+	map  = pipe_buffer_map(&nvfx->pipe, vb->buffer, PIPE_TRANSFER_READ, &transfer);
 	map += vb->buffer_offset + ve->src_offset;
 
-	switch (type) {
-	case NV34TCL_VTXFMT_TYPE_FLOAT:
-	{
-		float *v = map;
-
-		switch (ncomp) {
-		case 4:
-			so_method(so, eng3d, NV34TCL_VTX_ATTR_4F_X(attrib), 4);
-			so_data  (so, fui(v[0]));
-			so_data  (so, fui(v[1]));
-			so_data  (so, fui(v[2]));
-			so_data  (so, fui(v[3]));
-			break;
-		case 3:
-			so_method(so, eng3d, NV34TCL_VTX_ATTR_3F_X(attrib), 3);
-			so_data  (so, fui(v[0]));
-			so_data  (so, fui(v[1]));
-			so_data  (so, fui(v[2]));
-			break;
-		case 2:
-			so_method(so, eng3d, NV34TCL_VTX_ATTR_2F_X(attrib), 2);
-			so_data  (so, fui(v[0]));
-			so_data  (so, fui(v[1]));
-			break;
-		case 1:
-			so_method(so, eng3d, NV34TCL_VTX_ATTR_1F(attrib), 1);
-			so_data  (so, fui(v[0]));
-			break;
-		default:
-			pipe_buffer_unmap(pscreen, vb->buffer);
-			return FALSE;
-		}
-	}
+	float *v = map;
+
+	switch (ncomp) {
+	case 4:
+		OUT_RING(chan, RING_3D(NV34TCL_VTX_ATTR_4F_X(attrib), 4));
+		OUT_RING(chan, fui(v[0]));
+		OUT_RING(chan, fui(v[1]));
+		OUT_RING(chan,  fui(v[2]));
+		OUT_RING(chan,  fui(v[3]));
+		break;
+	case 3:
+		OUT_RING(chan, RING_3D(NV34TCL_VTX_ATTR_3F_X(attrib), 3));
+		OUT_RING(chan,  fui(v[0]));
+		OUT_RING(chan,  fui(v[1]));
+		OUT_RING(chan,  fui(v[2]));
+		break;
+	case 2:
+		OUT_RING(chan, RING_3D(NV34TCL_VTX_ATTR_2F_X(attrib), 2));
+		OUT_RING(chan,  fui(v[0]));
+		OUT_RING(chan,  fui(v[1]));
+		break;
+	case 1:
+		OUT_RING(chan, RING_3D(NV34TCL_VTX_ATTR_1F(attrib), 1));
+		OUT_RING(chan,  fui(v[0]));
 		break;
-	default:
-		pipe_buffer_unmap(pscreen, vb->buffer);
-		return FALSE;
 	}
 
-	pipe_buffer_unmap(pscreen, vb->buffer);
-	return TRUE;
+	pipe_buffer_unmap(&nvfx->pipe, vb->buffer, transfer);
 }
 
 void
@@ -178,11 +164,10 @@ nvfx_draw_arrays(struct pipe_context *pipe,
 	struct nvfx_context *nvfx = nvfx_context(pipe);
 	struct nvfx_screen *screen = nvfx->screen;
 	struct nouveau_channel *chan = screen->base.channel;
-	struct nouveau_grobj *eng3d = screen->eng3d;
 	unsigned restart = 0;
 
 	nvfx_vbo_set_idxbuf(nvfx, NULL, 0);
-	if (nvfx_force_swtnl(nvfx) || !nvfx_state_validate(nvfx)) {
+	if (nvfx->screen->force_swtnl || !nvfx_state_validate(nvfx)) {
 		nvfx_draw_elements_swtnl(pipe, NULL, 0,
                                            mode, start, count);
                 return;
@@ -193,19 +178,22 @@ nvfx_draw_arrays(struct pipe_context *pipe,
 
 		nvfx_state_emit(nvfx);
 
-		vc = nouveau_vbuf_split(AVAIL_RING(chan), 6, 256,
+		unsigned avail = AVAIL_RING(chan);
+		avail -= 16 + (avail >> 10); /* for the BEGIN_RING_NIs, conservatively assuming one every 1024, plus 16 for safety */
+
+		vc = nouveau_vbuf_split(avail, 6, 256,
 					mode, start, count, &restart);
 		if (!vc) {
 			FIRE_RING(chan);
 			continue;
 		}
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, nvgl_primitive(mode));
 
 		nr = (vc & 0xff);
 		if (nr) {
-			BEGIN_RING(chan, eng3d, NV34TCL_VB_VERTEX_BATCH, 1);
+			OUT_RING(chan, RING_3D(NV34TCL_VB_VERTEX_BATCH, 1));
 			OUT_RING  (chan, ((nr - 1) << 24) | start);
 			start += nr;
 		}
@@ -216,14 +204,14 @@ nvfx_draw_arrays(struct pipe_context *pipe,
 
 			nr -= push;
 
-			BEGIN_RING_NI(chan, eng3d, NV34TCL_VB_VERTEX_BATCH, push);
+			OUT_RING(chan, RING_3D_NI(NV34TCL_VB_VERTEX_BATCH, push));
 			while (push--) {
 				OUT_RING(chan, ((0x100 - 1) << 24) | start);
 				start += 0x100;
 			}
 		}
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, 0);
 
 		count -= vc;
@@ -239,7 +227,6 @@ nvfx_draw_elements_u08(struct nvfx_context *nvfx, void *ib,
 {
 	struct nvfx_screen *screen = nvfx->screen;
 	struct nouveau_channel *chan = screen->base.channel;
-	struct nouveau_grobj *eng3d = screen->eng3d;
 
 	while (count) {
 		uint8_t *elts = (uint8_t *)ib + start;
@@ -247,7 +234,10 @@ nvfx_draw_elements_u08(struct nvfx_context *nvfx, void *ib,
 
 		nvfx_state_emit(nvfx);
 
-		vc = nouveau_vbuf_split(AVAIL_RING(chan), 6, 2,
+		unsigned avail = AVAIL_RING(chan);
+		avail -= 16 + (avail >> 10); /* for the BEGIN_RING_NIs, conservatively assuming one every 1024, plus 16 for safety */
+
+		vc = nouveau_vbuf_split(avail, 6, 2,
 					mode, start, count, &restart);
 		if (vc == 0) {
 			FIRE_RING(chan);
@@ -255,11 +245,11 @@ nvfx_draw_elements_u08(struct nvfx_context *nvfx, void *ib,
 		}
 		count -= vc;
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, nvgl_primitive(mode));
 
 		if (vc & 1) {
-			BEGIN_RING(chan, eng3d, NV34TCL_VB_ELEMENT_U32, 1);
+			OUT_RING(chan, RING_3D(NV34TCL_VB_ELEMENT_U32, 1));
 			OUT_RING  (chan, elts[0]);
 			elts++; vc--;
 		}
@@ -269,7 +259,7 @@ nvfx_draw_elements_u08(struct nvfx_context *nvfx, void *ib,
 
 			push = MIN2(vc, 2047 * 2);
 
-			BEGIN_RING_NI(chan, eng3d, NV34TCL_VB_ELEMENT_U16, push >> 1);
+			OUT_RING(chan, RING_3D_NI(NV34TCL_VB_ELEMENT_U16, push >> 1));
 			for (i = 0; i < push; i+=2)
 				OUT_RING(chan, (elts[i+1] << 16) | elts[i]);
 
@@ -277,7 +267,7 @@ nvfx_draw_elements_u08(struct nvfx_context *nvfx, void *ib,
 			elts += push;
 		}
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, 0);
 
 		start = restart;
@@ -290,7 +280,6 @@ nvfx_draw_elements_u16(struct nvfx_context *nvfx, void *ib,
 {
 	struct nvfx_screen *screen = nvfx->screen;
 	struct nouveau_channel *chan = screen->base.channel;
-	struct nouveau_grobj *eng3d = screen->eng3d;
 
 	while (count) {
 		uint16_t *elts = (uint16_t *)ib + start;
@@ -298,7 +287,10 @@ nvfx_draw_elements_u16(struct nvfx_context *nvfx, void *ib,
 
 		nvfx_state_emit(nvfx);
 
-		vc = nouveau_vbuf_split(AVAIL_RING(chan), 6, 2,
+		unsigned avail = AVAIL_RING(chan);
+		avail -= 16 + (avail >> 10); /* for the BEGIN_RING_NIs, conservatively assuming one every 1024, plus 16 for safety */
+
+		vc = nouveau_vbuf_split(avail, 6, 2,
 					mode, start, count, &restart);
 		if (vc == 0) {
 			FIRE_RING(chan);
@@ -306,11 +298,11 @@ nvfx_draw_elements_u16(struct nvfx_context *nvfx, void *ib,
 		}
 		count -= vc;
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, nvgl_primitive(mode));
 
 		if (vc & 1) {
-			BEGIN_RING(chan, eng3d, NV34TCL_VB_ELEMENT_U32, 1);
+			OUT_RING(chan, RING_3D(NV34TCL_VB_ELEMENT_U32, 1));
 			OUT_RING  (chan, elts[0]);
 			elts++; vc--;
 		}
@@ -320,7 +312,7 @@ nvfx_draw_elements_u16(struct nvfx_context *nvfx, void *ib,
 
 			push = MIN2(vc, 2047 * 2);
 
-			BEGIN_RING_NI(chan, eng3d, NV34TCL_VB_ELEMENT_U16, push >> 1);
+			OUT_RING(chan, RING_3D_NI(NV34TCL_VB_ELEMENT_U16, push >> 1));
 			for (i = 0; i < push; i+=2)
 				OUT_RING(chan, (elts[i+1] << 16) | elts[i]);
 
@@ -328,7 +320,7 @@ nvfx_draw_elements_u16(struct nvfx_context *nvfx, void *ib,
 			elts += push;
 		}
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, 0);
 
 		start = restart;
@@ -341,7 +333,6 @@ nvfx_draw_elements_u32(struct nvfx_context *nvfx, void *ib,
 {
 	struct nvfx_screen *screen = nvfx->screen;
 	struct nouveau_channel *chan = screen->base.channel;
-	struct nouveau_grobj *eng3d = screen->eng3d;
 
 	while (count) {
 		uint32_t *elts = (uint32_t *)ib + start;
@@ -349,7 +340,10 @@ nvfx_draw_elements_u32(struct nvfx_context *nvfx, void *ib,
 
 		nvfx_state_emit(nvfx);
 
-		vc = nouveau_vbuf_split(AVAIL_RING(chan), 5, 1,
+		unsigned avail = AVAIL_RING(chan);
+		avail -= 16 + (avail >> 10); /* for the BEGIN_RING_NIs, conservatively assuming one every 1024, plus 16 for safety */
+
+		vc = nouveau_vbuf_split(avail, 5, 1,
 					mode, start, count, &restart);
 		if (vc == 0) {
 			FIRE_RING(chan);
@@ -357,20 +351,20 @@ nvfx_draw_elements_u32(struct nvfx_context *nvfx, void *ib,
 		}
 		count -= vc;
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, nvgl_primitive(mode));
 
 		while (vc) {
 			push = MIN2(vc, 2047);
 
-			BEGIN_RING_NI(chan, eng3d, NV34TCL_VB_ELEMENT_U32, push);
+			OUT_RING(chan, RING_3D_NI(NV34TCL_VB_ELEMENT_U32, push));
 			OUT_RINGp    (chan, elts, push);
 
 			vc -= push;
 			elts += push;
 		}
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, 0);
 
 		start = restart;
@@ -379,14 +373,14 @@ nvfx_draw_elements_u32(struct nvfx_context *nvfx, void *ib,
 
 static void
 nvfx_draw_elements_inline(struct pipe_context *pipe,
-			  struct pipe_buffer *ib, unsigned ib_size,
+			  struct pipe_resource *ib, unsigned ib_size,
 			  unsigned mode, unsigned start, unsigned count)
 {
 	struct nvfx_context *nvfx = nvfx_context(pipe);
-	struct pipe_screen *pscreen = pipe->screen;
+	struct pipe_transfer *transfer;
 	void *map;
 
-	map = pipe_buffer_map(pscreen, ib, PIPE_BUFFER_USAGE_CPU_READ);
+	map = pipe_buffer_map(pipe, ib, PIPE_TRANSFER_READ, &transfer);
 	if (!ib) {
 		NOUVEAU_ERR("failed mapping ib\n");
 		return;
@@ -407,7 +401,7 @@ nvfx_draw_elements_inline(struct pipe_context *pipe,
 		break;
 	}
 
-	pipe_buffer_unmap(pscreen, ib);
+	pipe_buffer_unmap(pipe, ib, transfer);
 }
 
 static void
@@ -417,7 +411,6 @@ nvfx_draw_elements_vbo(struct pipe_context *pipe,
 	struct nvfx_context *nvfx = nvfx_context(pipe);
 	struct nvfx_screen *screen = nvfx->screen;
 	struct nouveau_channel *chan = screen->base.channel;
-	struct nouveau_grobj *eng3d = screen->eng3d;
 	unsigned restart = 0;
 
 	while (count) {
@@ -425,19 +418,22 @@ nvfx_draw_elements_vbo(struct pipe_context *pipe,
 
 		nvfx_state_emit(nvfx);
 
-		vc = nouveau_vbuf_split(AVAIL_RING(chan), 6, 256,
+		unsigned avail = AVAIL_RING(chan);
+		avail -= 16 + (avail >> 10); /* for the BEGIN_RING_NIs, conservatively assuming one every 1024, plus 16 for safety */
+
+		vc = nouveau_vbuf_split(avail, 6, 256,
 					mode, start, count, &restart);
 		if (!vc) {
 			FIRE_RING(chan);
 			continue;
 		}
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, nvgl_primitive(mode));
 
 		nr = (vc & 0xff);
 		if (nr) {
-			BEGIN_RING(chan, eng3d, NV34TCL_VB_INDEX_BATCH, 1);
+			OUT_RING(chan, RING_3D(NV34TCL_VB_INDEX_BATCH, 1));
 			OUT_RING  (chan, ((nr - 1) << 24) | start);
 			start += nr;
 		}
@@ -448,14 +444,14 @@ nvfx_draw_elements_vbo(struct pipe_context *pipe,
 
 			nr -= push;
 
-			BEGIN_RING_NI(chan, eng3d, NV34TCL_VB_INDEX_BATCH, push);
+			OUT_RING(chan, RING_3D_NI(NV34TCL_VB_INDEX_BATCH, push));
 			while (push--) {
 				OUT_RING(chan, ((0x100 - 1) << 24) | start);
 				start += 0x100;
 			}
 		}
 
-		BEGIN_RING(chan, eng3d, NV34TCL_VERTEX_BEGIN_END, 1);
+		OUT_RING(chan, RING_3D(NV34TCL_VERTEX_BEGIN_END, 1));
 		OUT_RING  (chan, 0);
 
 		count -= vc;
@@ -465,14 +461,14 @@ nvfx_draw_elements_vbo(struct pipe_context *pipe,
 
 void
 nvfx_draw_elements(struct pipe_context *pipe,
-		   struct pipe_buffer *indexBuffer, unsigned indexSize,
+		   struct pipe_resource *indexBuffer, unsigned indexSize,
 		   unsigned mode, unsigned start, unsigned count)
 {
 	struct nvfx_context *nvfx = nvfx_context(pipe);
 	boolean idxbuf;
 
 	idxbuf = nvfx_vbo_set_idxbuf(nvfx, indexBuffer, indexSize);
-	if (nvfx_force_swtnl(nvfx) || !nvfx_state_validate(nvfx)) {
+	if (nvfx->screen->force_swtnl || !nvfx_state_validate(nvfx)) {
 		nvfx_draw_elements_swtnl(pipe, indexBuffer, indexSize,
                                            mode, start, count);
 		return;
@@ -488,83 +484,138 @@ nvfx_draw_elements(struct pipe_context *pipe,
 	pipe->flush(pipe, 0, NULL);
 }
 
-static boolean
+boolean
 nvfx_vbo_validate(struct nvfx_context *nvfx)
 {
-	struct nouveau_stateobj *vtxbuf, *vtxfmt, *sattr = NULL;
-	struct nouveau_grobj *eng3d = nvfx->screen->eng3d;
-	struct pipe_buffer *ib = nvfx->idxbuf;
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
+	struct pipe_resource *ib = nvfx->idxbuf;
 	unsigned ib_format = nvfx->idxbuf_format;
-	unsigned vb_flags = nvfx->screen->vertex_buffer_flags | NOUVEAU_BO_RD;
-	int hw;
+	int i;
+	int elements = MAX2(nvfx->vtxelt->num_elements, nvfx->hw_vtxelt_nr);
+	uint32_t vtxfmt[16];
+	unsigned vb_flags = nvfx->screen->vertex_buffer_reloc_flags | NOUVEAU_BO_RD;
+
+	if (!elements)
+		return TRUE;
 
-	vtxbuf = so_new(3, 17, 18);
-	so_method(vtxbuf, eng3d, NV34TCL_VTXBUF_ADDRESS(0), nvfx->vtxelt->num_elements);
-	vtxfmt = so_new(1, 16, 0);
-	so_method(vtxfmt, eng3d, NV34TCL_VTXFMT(0), nvfx->vtxelt->num_elements);
+	nvfx->vbo_bo = 0;
 
-	for (hw = 0; hw < nvfx->vtxelt->num_elements; hw++) {
+	MARK_RING(chan, (5 + 2) * 16 + 2 + 11, 16 + 2);
+	for (i = 0; i < nvfx->vtxelt->num_elements; i++) {
 		struct pipe_vertex_element *ve;
 		struct pipe_vertex_buffer *vb;
 		unsigned type, ncomp;
 
-		ve = &nvfx->vtxelt->pipe[hw];
+		ve = &nvfx->vtxelt->pipe[i];
 		vb = &nvfx->vtxbuf[ve->vertex_buffer_index];
 
-		if (!vb->stride) {
-			if (!sattr)
-				sattr = so_new(16, 16 * 4, 0);
-
-			if (nvfx_vbo_static_attrib(nvfx, sattr, hw, ve, vb)) {
-				so_data(vtxbuf, 0);
-				so_data(vtxfmt, NV34TCL_VTXFMT_TYPE_FLOAT);
-				continue;
-			}
-		}
-
 		if (nvfx_vbo_format_to_hw(ve->src_format, &type, &ncomp)) {
+			MARK_UNDO(chan);
 			nvfx->fallback_swtnl |= NVFX_NEW_ARRAYS;
-			so_ref(NULL, &vtxbuf);
-			so_ref(NULL, &vtxfmt);
 			return FALSE;
 		}
 
-		so_reloc(vtxbuf, nouveau_bo(vb->buffer),
+		if (!vb->stride && type == NV34TCL_VTXFMT_TYPE_FLOAT) {
+			nvfx_vbo_static_attrib(nvfx, i, ve, vb, ncomp);
+			vtxfmt[i] = type;
+		} else {
+			vtxfmt[i] = ((vb->stride << NV34TCL_VTXFMT_STRIDE_SHIFT) |
+				(ncomp << NV34TCL_VTXFMT_SIZE_SHIFT) | type);
+			nvfx->vbo_bo |= (1 << i);
+		}
+	}
+
+	for(; i < elements; ++i)
+		vtxfmt[i] = NV34TCL_VTXFMT_TYPE_FLOAT;
+
+	OUT_RING(chan, RING_3D(NV34TCL_VTXFMT(0), elements));
+	OUT_RINGp(chan, vtxfmt, elements);
+
+	if(nvfx->is_nv4x) {
+		unsigned i;
+		/* seems to be some kind of cache flushing */
+		for(i = 0; i < 3; ++i) {
+			OUT_RING(chan, RING_3D(0x1718, 1));
+			OUT_RING(chan, 0);
+		}
+	}
+
+	OUT_RING(chan, RING_3D(NV34TCL_VTXBUF_ADDRESS(0), elements));
+	for (i = 0; i < nvfx->vtxelt->num_elements; i++) {
+		struct pipe_vertex_element *ve;
+		struct pipe_vertex_buffer *vb;
+
+		ve = &nvfx->vtxelt->pipe[i];
+		vb = &nvfx->vtxbuf[ve->vertex_buffer_index];
+
+		if (!(nvfx->vbo_bo & (1 << i)))
+			OUT_RING(chan, 0);
+		else
+		{
+			struct nouveau_bo* bo = nvfx_resource(vb->buffer)->bo;
+			OUT_RELOC(chan, bo,
 				 vb->buffer_offset + ve->src_offset,
 				 vb_flags | NOUVEAU_BO_LOW | NOUVEAU_BO_OR,
 				 0, NV34TCL_VTXBUF_ADDRESS_DMA1);
-		so_data (vtxfmt, ((vb->stride << NV34TCL_VTXFMT_STRIDE_SHIFT) |
-				  (ncomp << NV34TCL_VTXFMT_SIZE_SHIFT) | type));
+		}
 	}
 
+        for (; i < elements; i++)
+		OUT_RING(chan, 0);
+
+	OUT_RING(chan, RING_3D(0x1710, 1));
+	OUT_RING(chan, 0);
+
 	if (ib) {
-		struct nouveau_bo *bo = nouveau_bo(ib);
+		unsigned ib_flags = nvfx->screen->index_buffer_reloc_flags | NOUVEAU_BO_RD;
+		struct nouveau_bo* bo = nvfx_resource(ib)->bo;
+
+		assert(nvfx->screen->index_buffer_reloc_flags);
 
-		so_method(vtxbuf, eng3d, NV34TCL_IDXBUF_ADDRESS, 2);
-		so_reloc (vtxbuf, bo, 0, vb_flags | NOUVEAU_BO_LOW, 0, 0);
-		so_reloc (vtxbuf, bo, ib_format, vb_flags | NOUVEAU_BO_OR,
+		OUT_RING(chan, RING_3D(NV34TCL_IDXBUF_ADDRESS, 2));
+		OUT_RELOC(chan, bo, 0, ib_flags | NOUVEAU_BO_LOW, 0, 0);
+		OUT_RELOC(chan, bo, ib_format, ib_flags | NOUVEAU_BO_OR,
 				  0, NV34TCL_IDXBUF_FORMAT_DMA1);
 	}
 
-	so_method(vtxbuf, eng3d, 0x1710, 1);
-	so_data  (vtxbuf, 0);
-
-	so_ref(vtxbuf, &nvfx->state.hw[NVFX_STATE_VTXBUF]);
-	so_ref(NULL, &vtxbuf);
-	nvfx->state.dirty |= (1ULL << NVFX_STATE_VTXBUF);
-	so_ref(vtxfmt, &nvfx->state.hw[NVFX_STATE_VTXFMT]);
-	so_ref(NULL, &vtxfmt);
-	nvfx->state.dirty |= (1ULL << NVFX_STATE_VTXFMT);
-	so_ref(sattr, &nvfx->state.hw[NVFX_STATE_VTXATTR]);
-	so_ref(NULL, &sattr);
-	nvfx->state.dirty |= (1ULL << NVFX_STATE_VTXATTR);
-	return FALSE;
+	nvfx->hw_vtxelt_nr = nvfx->vtxelt->num_elements;
+	return TRUE;
 }
 
-struct nvfx_state_entry nvfx_state_vbo = {
-	.validate = nvfx_vbo_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_ARRAYS,
-		.hw = 0,
+void
+nvfx_vbo_relocate(struct nvfx_context *nvfx)
+{
+	struct nouveau_channel* chan = nvfx->screen->base.channel;
+	unsigned vb_flags = nvfx->screen->vertex_buffer_reloc_flags | NOUVEAU_BO_RD | NOUVEAU_BO_DUMMY;
+	int i;
+
+	MARK_RING(chan, 2 * 16 + 3, 2 * 16 + 3);
+	for(i = 0; i < nvfx->vtxelt->num_elements; ++i) {
+		if(nvfx->vbo_bo & (1 << i)) {
+			struct pipe_vertex_element *ve = &nvfx->vtxelt->pipe[i];
+			struct pipe_vertex_buffer *vb = &nvfx->vtxbuf[ve->vertex_buffer_index];
+			struct nouveau_bo* bo = nvfx_resource(vb->buffer)->bo;
+			OUT_RELOC(chan, bo, RING_3D(NV34TCL_VTXBUF_ADDRESS(i), 1),
+					vb_flags, 0, 0);
+			OUT_RELOC(chan, bo, vb->buffer_offset + ve->src_offset,
+					vb_flags | NOUVEAU_BO_LOW | NOUVEAU_BO_OR,
+					0, NV34TCL_VTXBUF_ADDRESS_DMA1);
+		}
 	}
-};
+
+	if(nvfx->idxbuf)
+	{
+		unsigned ib_flags = nvfx->screen->index_buffer_reloc_flags | NOUVEAU_BO_RD | NOUVEAU_BO_DUMMY;
+		struct nouveau_bo* bo = nvfx_resource(nvfx->idxbuf)->bo;
+
+		assert(nvfx->screen->index_buffer_reloc_flags);
+
+		OUT_RELOC(chan, bo, RING_3D(NV34TCL_IDXBUF_ADDRESS, 2),
+				ib_flags, 0, 0);
+		OUT_RELOC(chan, bo, 0,
+				ib_flags | NOUVEAU_BO_LOW, 0, 0);
+		OUT_RELOC(chan, bo, nvfx->idxbuf_format,
+				ib_flags | NOUVEAU_BO_OR,
+				0, NV34TCL_IDXBUF_FORMAT_DMA1);
+	}
+}
diff --git a/src/gallium/drivers/nvfx/nvfx_vertprog.c b/src/gallium/drivers/nvfx/nvfx_vertprog.c
index 2d243be16a3..b405fd9c821 100644
--- a/src/gallium/drivers/nvfx/nvfx_vertprog.c
+++ b/src/gallium/drivers/nvfx/nvfx_vertprog.c
@@ -479,6 +479,9 @@ nvfx_vertprog_parse_instruction(struct nvfx_context* nvfx, struct nvfx_vpc *vpc,
 	case TGSI_OPCODE_ARL:
 		arith(vpc, VEC, ARL, dst, mask, src[0], none, none);
 		break;
+	case TGSI_OPCODE_COS:
+		arith(vpc, SCA, COS, dst, mask, none, none, src[0]);
+		break;
 	case TGSI_OPCODE_DP3:
 		arith(vpc, VEC, DP3, dst, mask, src[0], src[1], none);
 		break;
@@ -512,6 +515,11 @@ nvfx_vertprog_parse_instruction(struct nvfx_context* nvfx, struct nvfx_vpc *vpc,
 	case TGSI_OPCODE_LOG:
 		arith(vpc, SCA, LOG, dst, mask, none, none, src[0]);
 		break;
+	case TGSI_OPCODE_LRP:
+		tmp = temp(vpc);
+		arith(vpc, VEC, MAD, tmp, mask, neg(src[0]), src[2], src[2]);
+		arith(vpc, VEC, MAD, dst, mask, src[0], src[1], tmp);
+		break;
 	case TGSI_OPCODE_MAD:
 		arith(vpc, VEC, MAD, dst, mask, src[0], src[1], src[2]);
 		break;
@@ -544,15 +552,36 @@ nvfx_vertprog_parse_instruction(struct nvfx_context* nvfx, struct nvfx_vpc *vpc,
 	case TGSI_OPCODE_RSQ:
 		arith(vpc, SCA, RSQ, dst, mask, none, none, abs(src[0]));
 		break;
+	case TGSI_OPCODE_SEQ:
+		arith(vpc, VEC, SEQ, dst, mask, src[0], src[1], none);
+		break;
+	case TGSI_OPCODE_SFL:
+		arith(vpc, VEC, SFL, dst, mask, src[0], src[1], none);
+		break;
 	case TGSI_OPCODE_SGE:
 		arith(vpc, VEC, SGE, dst, mask, src[0], src[1], none);
 		break;
 	case TGSI_OPCODE_SGT:
 		arith(vpc, VEC, SGT, dst, mask, src[0], src[1], none);
 		break;
+	case TGSI_OPCODE_SIN:
+		arith(vpc, SCA, SIN, dst, mask, none, none, src[0]);
+		break;
+	case TGSI_OPCODE_SLE:
+		arith(vpc, VEC, SLE, dst, mask, src[0], src[1], none);
+		break;
 	case TGSI_OPCODE_SLT:
 		arith(vpc, VEC, SLT, dst, mask, src[0], src[1], none);
 		break;
+	case TGSI_OPCODE_SNE:
+		arith(vpc, VEC, SNE, dst, mask, src[0], src[1], none);
+		break;
+	case TGSI_OPCODE_SSG:
+		arith(vpc, VEC, SSG, dst, mask, src[0], src[1], none);
+		break;
+	case TGSI_OPCODE_STR:
+		arith(vpc, VEC, STR, dst, mask, src[0], src[1], none);
+		break;
 	case TGSI_OPCODE_SUB:
 		arith(vpc, VEC, ADD, dst, mask, src[0], none, neg(src[1]));
 		break;
@@ -830,15 +859,16 @@ out_err:
 	FREE(vpc);
 }
 
-static boolean
+boolean
 nvfx_vertprog_validate(struct nvfx_context *nvfx)
 {
-	struct pipe_screen *pscreen = nvfx->pipe.screen;
+	struct pipe_context *pipe = &nvfx->pipe;
 	struct nvfx_screen *screen = nvfx->screen;
 	struct nouveau_channel *chan = screen->base.channel;
 	struct nouveau_grobj *eng3d = screen->eng3d;
 	struct nvfx_vertex_program *vp;
-	struct pipe_buffer *constbuf;
+	struct pipe_resource *constbuf;
+	struct pipe_transfer *transfer = NULL;
 	boolean upload_code = FALSE, upload_data = FALSE;
 	int i;
 
@@ -846,6 +876,7 @@ nvfx_vertprog_validate(struct nvfx_context *nvfx)
 		vp = nvfx->vertprog;
 		constbuf = nvfx->constbuf[PIPE_SHADER_VERTEX];
 
+		// TODO: ouch! can't we just use constant slots for these?!
 		if ((nvfx->dirty & NVFX_NEW_UCP) ||
 		    memcmp(&nvfx->clip, &vp->ucp, sizeof(vp->ucp))) {
 			nvfx_vertprog_destroy(nvfx, vp);
@@ -857,21 +888,19 @@ nvfx_vertprog_validate(struct nvfx_context *nvfx)
 	}
 
 	/* Translate TGSI shader into hw bytecode */
-	if (vp->translated)
-		goto check_gpu_resources;
-
-	nvfx->fallback_swtnl &= ~NVFX_NEW_VERTPROG;
+	if (!vp->translated)
+	{
+		nvfx->fallback_swtnl &= ~NVFX_NEW_VERTPROG;
 		nvfx_vertprog_translate(nvfx, vp);
-	if (!vp->translated) {
-		nvfx->fallback_swtnl |= NVFX_NEW_VERTPROG;
+		if (!vp->translated) {
+			nvfx->fallback_swtnl |= NVFX_NEW_VERTPROG;
 			return FALSE;
+		}
 	}
 
-check_gpu_resources:
 	/* Allocate hw vtxprog exec slots */
 	if (!vp->exec) {
 		struct nouveau_resource *heap = nvfx->screen->vp_exec_heap;
-		struct nouveau_stateobj *so;
 		uint vplen = vp->nr_insns;
 
 		if (nouveau_resource_alloc(heap, vplen, vp, &vp->exec)) {
@@ -886,19 +915,6 @@ check_gpu_resources:
 				assert(0);
 		}
 
-		so = so_new(3, 4, 0);
-		so_method(so, eng3d, NV34TCL_VP_START_FROM_ID, 1);
-		so_data  (so, vp->exec->start);
-		if(nvfx->is_nv4x) {
-			so_method(so, eng3d, NV40TCL_VP_ATTRIB_EN, 2);
-			so_data  (so, vp->ir);
-			so_data  (so, vp->or);
-		}
-		so_method(so, eng3d,  NV34TCL_VP_CLIP_PLANES_ENABLE, 1);
-		so_data  (so, vp->clip_ctrl);
-		so_ref(so, &vp->so);
-		so_ref(NULL, &so);
-
 		upload_code = TRUE;
 	}
 
@@ -962,8 +978,9 @@ check_gpu_resources:
 		float *map = NULL;
 
 		if (constbuf) {
-			map = pipe_buffer_map(pscreen, constbuf,
-					      PIPE_BUFFER_USAGE_CPU_READ);
+			map = pipe_buffer_map(pipe, constbuf,
+					      PIPE_TRANSFER_READ,
+					      &transfer);
 		}
 
 		for (i = 0; i < vp->nr_consts; i++) {
@@ -984,7 +1001,7 @@ check_gpu_resources:
 		}
 
 		if (constbuf)
-			pipe_buffer_unmap(pscreen, constbuf);
+			pipe_buffer_unmap(pipe, constbuf, transfer);
 	}
 
 	/* Upload vtxprog */
@@ -1005,12 +1022,21 @@ check_gpu_resources:
 		}
 	}
 
-	if (vp->so != nvfx->state.hw[NVFX_STATE_VERTPROG]) {
-		so_ref(vp->so, &nvfx->state.hw[NVFX_STATE_VERTPROG]);
-		return TRUE;
+	if(nvfx->dirty & (NVFX_NEW_VERTPROG | NVFX_NEW_UCP))
+	{
+		WAIT_RING(chan, 7);
+		OUT_RING(chan, RING_3D(NV34TCL_VP_START_FROM_ID, 1));
+		OUT_RING(chan, vp->exec->start);
+		if(nvfx->is_nv4x) {
+			OUT_RING(chan, RING_3D(NV40TCL_VP_ATTRIB_EN, 2));
+			OUT_RING(chan, vp->ir);
+			OUT_RING(chan, vp->or);
+		}
+		OUT_RING(chan, RING_3D(NV34TCL_VP_CLIP_PLANES_ENABLE, 1));
+		OUT_RING(chan, vp->clip_ctrl);
 	}
 
-	return FALSE;
+	return TRUE;
 }
 
 void
@@ -1037,13 +1063,4 @@ nvfx_vertprog_destroy(struct nvfx_context *nvfx, struct nvfx_vertex_program *vp)
 	vp->data_start_min = 0;
 
 	vp->ir = vp->or = vp->clip_ctrl = 0;
-	so_ref(NULL, &vp->so);
 }
-
-struct nvfx_state_entry nvfx_state_vertprog = {
-	.validate = nvfx_vertprog_validate,
-	.dirty = {
-		.pipe = NVFX_NEW_VERTPROG | NVFX_NEW_UCP,
-		.hw = NVFX_STATE_VERTPROG,
-	}
-};
diff --git a/src/gallium/drivers/r300/Makefile b/src/gallium/drivers/r300/Makefile
index a6529b20604..5a8e00f15a2 100644
--- a/src/gallium/drivers/r300/Makefile
+++ b/src/gallium/drivers/r300/Makefile
@@ -13,6 +13,7 @@ C_SOURCES = \
 	r300_fs.c \
 	r300_query.c \
 	r300_render.c \
+	r300_resource.c \
 	r300_screen.c \
 	r300_screen_buffer.c \
 	r300_state.c \
diff --git a/src/gallium/drivers/r300/SConscript b/src/gallium/drivers/r300/SConscript
index 221878c1c0c..08aec427a15 100644
--- a/src/gallium/drivers/r300/SConscript
+++ b/src/gallium/drivers/r300/SConscript
@@ -23,6 +23,7 @@ r300 = env.ConvenienceLibrary(
         'r300_fs.c',
         'r300_query.c',
         'r300_render.c',
+        'r300_resource.c',
         'r300_screen.c',
         'r300_screen_buffer.c',
         'r300_state.c',
diff --git a/src/gallium/drivers/r300/r300_blit.c b/src/gallium/drivers/r300/r300_blit.c
index bcdf950df9c..322eaa83bd0 100644
--- a/src/gallium/drivers/r300/r300_blit.c
+++ b/src/gallium/drivers/r300/r300_blit.c
@@ -32,7 +32,7 @@ static void r300_blitter_save_states(struct r300_context* r300)
     util_blitter_save_depth_stencil_alpha(r300->blitter, r300->dsa_state.state);
     util_blitter_save_stencil_ref(r300->blitter, &(r300->stencil_ref));
     util_blitter_save_rasterizer(r300->blitter, r300->rs_state.state);
-    util_blitter_save_fragment_shader(r300->blitter, r300->fs);
+    util_blitter_save_fragment_shader(r300->blitter, r300->fs.state);
     util_blitter_save_vertex_shader(r300->blitter, r300->vs_state.state);
     util_blitter_save_viewport(r300->blitter, &r300->viewport);
     util_blitter_save_clip(r300->blitter, &r300->clip);
@@ -111,11 +111,12 @@ static void r300_hw_copy(struct pipe_context* pipe,
     util_blitter_save_framebuffer(r300->blitter, r300->fb_state.state);
 
     util_blitter_save_fragment_sampler_states(
-        r300->blitter, state->sampler_count, (void**)state->sampler_states);
+        r300->blitter, state->sampler_state_count,
+        (void**)state->sampler_states);
 
     util_blitter_save_fragment_sampler_views(
-        r300->blitter, state->texture_count,
-        state->fragment_sampler_views);
+        r300->blitter, state->sampler_view_count,
+        (struct pipe_sampler_view**)state->sampler_views);
 
     /* Do a copy */
     util_blitter_copy(r300->blitter,
@@ -137,8 +138,8 @@ void r300_surface_copy(struct pipe_context* pipe,
 
     if (!pipe->screen->is_format_supported(pipe->screen,
                                            old_format, src->texture->target,
-                                           PIPE_TEXTURE_USAGE_RENDER_TARGET |
-                                           PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                           PIPE_BIND_RENDER_TARGET |
+                                           PIPE_BIND_SAMPLER_VIEW, 0)) {
         switch (util_format_get_blocksize(old_format)) {
             case 1:
                 new_format = PIPE_FORMAT_I8_UNORM;
diff --git a/src/gallium/drivers/r300/r300_chipset.c b/src/gallium/drivers/r300/r300_chipset.c
index 41719862635..9b2163e44cc 100644
--- a/src/gallium/drivers/r300/r300_chipset.c
+++ b/src/gallium/drivers/r300/r300_chipset.c
@@ -34,12 +34,12 @@ void r300_parse_chipset(struct r300_capabilities* caps)
 {
     /* Reasonable defaults */
     caps->num_vert_fpus = 4;
+    caps->num_tex_units = 16;
     caps->has_tcl = debug_get_bool_option("RADEON_NO_TCL", FALSE) ? FALSE : TRUE;
     caps->is_r400 = FALSE;
     caps->is_r500 = FALSE;
     caps->high_second_pipe = FALSE;
 
-
     /* Note: These are not ordered by PCI ID. I leave that task to GCC,
      * which will perform the ordering while collating jump tables. Instead,
      * I've tried to group them according to capabilities and age. */
diff --git a/src/gallium/drivers/r300/r300_chipset.h b/src/gallium/drivers/r300/r300_chipset.h
index 28084864929..ff957b7c29c 100644
--- a/src/gallium/drivers/r300/r300_chipset.h
+++ b/src/gallium/drivers/r300/r300_chipset.h
@@ -38,6 +38,8 @@ struct r300_capabilities {
     unsigned num_frag_pipes;
     /* The number of z pipes */
     unsigned num_z_pipes;
+    /* The number of texture units. */
+    unsigned num_tex_units;
     /* Whether or not TCL is physically present */
     boolean has_tcl;
     /* Whether or not this is R400. The differences compared to their R3xx
diff --git a/src/gallium/drivers/r300/r300_context.c b/src/gallium/drivers/r300/r300_context.c
index 4b470b2c6af..06af2c2fd8d 100644
--- a/src/gallium/drivers/r300/r300_context.c
+++ b/src/gallium/drivers/r300/r300_context.c
@@ -35,7 +35,6 @@
 #include "r300_screen.h"
 #include "r300_screen_buffer.h"
 #include "r300_state_invariant.h"
-#include "r300_transfer.h"
 #include "r300_winsys.h"
 
 static void r300_destroy_context(struct pipe_context* context)
@@ -47,7 +46,7 @@ static void r300_destroy_context(struct pipe_context* context)
     draw_destroy(r300->draw);
 
     /* Free the OQ BO. */
-    context->screen->buffer_destroy(r300->oqbo);
+    context->screen->resource_destroy(context->screen, r300->oqbo);
 
     /* If there are any queries pending or not destroyed, remove them now. */
     foreach_s(query, temp, &r300->query_list) {
@@ -67,28 +66,11 @@ static void r300_destroy_context(struct pipe_context* context)
     FREE(r300->vap_output_state.state);
     FREE(r300->viewport_state.state);
     FREE(r300->ztop_state.state);
+    FREE(r300->fs_constants.state);
+    FREE(r300->vs_constants.state);
     FREE(r300);
 }
 
-static unsigned int
-r300_is_texture_referenced(struct pipe_context *context,
-                           struct pipe_texture *texture,
-                           unsigned face, unsigned level)
-{
-    struct r300_context* r300 = r300_context(context);
-    struct r300_texture* tex = (struct r300_texture*)texture;
-
-    return r300->rws->is_buffer_referenced(r300->rws, tex->buffer);
-}
-
-static unsigned int
-r300_is_buffer_referenced(struct pipe_context *context,
-                          struct pipe_buffer *buf)
-{
-    struct r300_context* r300 = r300_context(context);
-
-    return r300_buffer_is_referenced(r300, buf);
-}
 
 static void r300_flush_cb(void *data)
 {
@@ -107,8 +89,8 @@ static void r300_flush_cb(void *data)
 
 static void r300_setup_atoms(struct r300_context* r300)
 {
-    boolean is_r500 = r300_screen(r300->context.screen)->caps->is_r500;
-    boolean has_tcl = r300_screen(r300->context.screen)->caps->has_tcl;
+    boolean is_r500 = r300->screen->caps.is_r500;
+    boolean has_tcl = r300->screen->caps.has_tcl;
 
     /* Create the actual atom list.
      *
@@ -119,6 +101,7 @@ static void r300_setup_atoms(struct r300_context* r300)
      * the size of 0 here. */
     make_empty_list(&r300->atom_list);
     R300_INIT_ATOM(invariant_state, 71);
+    R300_INIT_ATOM(query_start, 4);
     R300_INIT_ATOM(ztop_state, 2);
     R300_INIT_ATOM(blend_state, 8);
     R300_INIT_ATOM(blend_color_state, is_r500 ? 3 : 2);
@@ -133,8 +116,19 @@ static void r300_setup_atoms(struct r300_context* r300)
     R300_INIT_ATOM(vap_output_state, 6);
     R300_INIT_ATOM(pvs_flush, 2);
     R300_INIT_ATOM(vs_state, 0);
+    R300_INIT_ATOM(vs_constants, 0);
     R300_INIT_ATOM(texture_cache_inval, 2);
     R300_INIT_ATOM(textures_state, 0);
+    R300_INIT_ATOM(fs, 0);
+    R300_INIT_ATOM(fs_rc_constant_state, 0);
+    R300_INIT_ATOM(fs_constants, 0);
+
+    /* Replace emission functions for r500. */
+    if (r300->screen->caps.is_r500) {
+        r300->fs.emit = r500_emit_fs;
+        r300->fs_rc_constant_state.emit = r500_emit_fs_rc_constant_state;
+        r300->fs_constants.emit = r500_emit_fs_constants;
+    }
 
     /* Some non-CSO atoms need explicit space to store the state locally. */
     r300->blend_color_state.state = CALLOC_STRUCT(r300_blend_color_state);
@@ -146,6 +140,8 @@ static void r300_setup_atoms(struct r300_context* r300)
     r300->vap_output_state.state = CALLOC_STRUCT(r300_vap_output_state);
     r300->viewport_state.state = CALLOC_STRUCT(r300_viewport_state);
     r300->ztop_state.state = CALLOC_STRUCT(r300_ztop_state);
+    r300->fs_constants.state = CALLOC_STRUCT(r300_constant_buffer);
+    r300->vs_constants.state = CALLOC_STRUCT(r300_constant_buffer);
 }
 
 struct pipe_context* r300_create_context(struct pipe_screen* screen,
@@ -159,6 +155,7 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
         return NULL;
 
     r300->rws = rws;
+    r300->screen = r300screen;
 
     r300->context.winsys = (struct pipe_winsys*)rws;
     r300->context.screen = screen;
@@ -170,10 +167,20 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
     r300->context.surface_copy = r300_surface_copy;
     r300->context.surface_fill = r300_surface_fill;
 
-    if (r300screen->caps->has_tcl) {
+    if (r300screen->caps.has_tcl) {
         r300->context.draw_arrays = r300_draw_arrays;
         r300->context.draw_elements = r300_draw_elements;
         r300->context.draw_range_elements = r300_draw_range_elements;
+
+        if (r300screen->caps.is_r500) {
+            r300->emit_draw_arrays_immediate = r500_emit_draw_arrays_immediate;
+            r300->emit_draw_arrays = r500_emit_draw_arrays;
+            r300->emit_draw_elements = r500_emit_draw_elements;
+        } else {
+            r300->emit_draw_arrays_immediate = r300_emit_draw_arrays_immediate;
+            r300->emit_draw_arrays = r300_emit_draw_arrays;
+            r300->emit_draw_elements = r300_emit_draw_elements;
+        }
     } else {
         r300->context.draw_arrays = r300_swtcl_draw_arrays;
         r300->context.draw_elements = r300_draw_elements;
@@ -190,23 +197,17 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
         draw_set_viewport_state(r300->draw, &r300_viewport_identity);
     }
 
-    r300->context.is_texture_referenced = r300_is_texture_referenced;
-    r300->context.is_buffer_referenced = r300_is_buffer_referenced;
-
     r300_setup_atoms(r300);
 
     /* Open up the OQ BO. */
-    r300->oqbo = screen->buffer_create(screen, 4096,
-            PIPE_BUFFER_USAGE_PIXEL, 4096);
+    r300->oqbo = pipe_buffer_create(screen,
+				    R300_BIND_OQBO, 4096);
     make_empty_list(&r300->query_list);
 
     r300_init_flush_functions(r300);
-
     r300_init_query_functions(r300);
-
-    r300_init_transfer_functions(r300);
-
     r300_init_state_functions(r300);
+    r300_init_resource_functions(r300);
 
     r300->invariant_state.dirty = TRUE;
 
@@ -215,16 +216,16 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
 
     r300->blitter = util_blitter_create(&r300->context);
 
-    r300->upload_ib = u_upload_create(screen,
+    r300->upload_ib = u_upload_create(&r300->context,
 				      32 * 1024, 16,
-				      PIPE_BUFFER_USAGE_INDEX);
+				      PIPE_BIND_INDEX_BUFFER);
 
     if (r300->upload_ib == NULL)
         goto no_upload_ib;
 
-    r300->upload_vb = u_upload_create(screen,
+    r300->upload_vb = u_upload_create(&r300->context,
 				      128 * 1024, 16,
-				      PIPE_BUFFER_USAGE_VERTEX);
+				      PIPE_BIND_VERTEX_BUFFER);
     if (r300->upload_vb == NULL)
         goto no_upload_vb;
 
diff --git a/src/gallium/drivers/r300/r300_context.h b/src/gallium/drivers/r300/r300_context.h
index 0a82484e89d..2e8601b65ef 100644
--- a/src/gallium/drivers/r300/r300_context.h
+++ b/src/gallium/drivers/r300/r300_context.h
@@ -29,6 +29,7 @@
 
 #include "pipe/p_context.h"
 #include "util/u_inlines.h"
+#include "util/u_transfer.h"
 
 #include "r300_defines.h"
 #include "r300_screen.h"
@@ -52,8 +53,6 @@ struct r300_atom {
     unsigned size;
     /* Whether this atom should be emitted. */
     boolean dirty;
-    /* Another dirty flag that is never automatically cleared. */
-    boolean always_dirty;
 };
 
 struct r300_blend_state {
@@ -79,6 +78,11 @@ struct r300_dsa_state {
     uint32_t z_stencil_control; /* R300_ZB_ZSTENCILCNTL: 0x4f04 */
     uint32_t stencil_ref_mask;  /* R300_ZB_STENCILREFMASK: 0x4f08 */
     uint32_t stencil_ref_bf;    /* R500_ZB_STENCILREFMASK_BF: 0x4fd4 */
+
+    /* Whether a two-sided stencil is enabled. */
+    boolean two_sided;
+    /* Whether a fallback should be used for a two-sided stencil ref value. */
+    boolean stencil_ref_bf_fallback;
 };
 
 struct r300_rs_state {
@@ -99,6 +103,17 @@ struct r300_rs_state {
     uint32_t line_stipple_value;    /* R300_GA_LINE_STIPPLE_VALUE: 0x4260 */
     uint32_t color_control;         /* R300_GA_COLOR_CONTROL: 0x4278 */
     uint32_t polygon_mode;          /* R300_GA_POLY_MODE: 0x4288 */
+    uint32_t clip_rule;             /* R300_SC_CLIP_RULE: 0x43D0 */
+
+    /* Specifies top of Raster pipe specific enable controls,
+     * i.e. texture coordinates stuffing for points, lines, triangles */
+    uint32_t stuffing_enable;       /* R300_GB_ENABLE: 0x4008 */
+
+    /* Point sprites texture coordinates, 0: lower left, 1: upper right */
+    float point_texcoord_left;      /* R300_GA_POINT_S0: 0x4200 */
+    float point_texcoord_bottom;    /* R300_GA_POINT_T0: 0x4204 */
+    float point_texcoord_right;     /* R300_GA_POINT_S1: 0x4208 */
+    float point_texcoord_top;       /* R300_GA_POINT_T1: 0x420c */
 };
 
 struct r300_rs_block {
@@ -124,6 +139,15 @@ struct r300_texture_format_state {
     uint32_t format0; /* R300_TX_FORMAT0: 0x4480 */
     uint32_t format1; /* R300_TX_FORMAT1: 0x44c0 */
     uint32_t format2; /* R300_TX_FORMAT2: 0x4500 */
+    uint32_t tile_config; /* R300_TX_OFFSET (subset thereof) */
+};
+
+struct r300_sampler_view {
+    struct pipe_sampler_view base;
+
+    /* Copy of r300_texture::texture_format_state with format-specific bits
+     * added. */
+    struct r300_texture_format_state format;
 };
 
 struct r300_texture_fb_state {
@@ -138,21 +162,21 @@ struct r300_texture_fb_state {
 
 struct r300_textures_state {
     /* Textures. */
-    struct pipe_sampler_view *fragment_sampler_views[8];
-    int texture_count;
+    struct r300_sampler_view *sampler_views[16];
+    int sampler_view_count;
     /* Sampler states. */
-    struct r300_sampler_state *sampler_states[8];
-    int sampler_count;
+    struct r300_sampler_state *sampler_states[16];
+    int sampler_state_count;
 
-    /* These is the merge of the texture and sampler states. */
+    /* This is the merge of the texture and sampler states. */
     unsigned count;
     uint32_t tx_enable;         /* R300_TX_ENABLE: 0x4101 */
     struct r300_texture_sampler_state {
-        uint32_t format[3];     /* R300_TX_FORMAT[0-2] */
-        uint32_t filter[2];     /* R300_TX_FILTER[0-1] */
+        struct r300_texture_format_state format;
+        uint32_t filter0;      /* R300_TX_FILTER0: 0x4400 */
+        uint32_t filter1;      /* R300_TX_FILTER1: 0x4440 */
         uint32_t border_color;  /* R300_TX_BORDER_COLOR: 0x45c0 */
-        uint32_t tile_config;   /* R300_TX_OFFSET (subset thereof) */
-    } regs[8];
+    } regs[16];
 };
 
 struct r300_vertex_stream_state {
@@ -223,7 +247,7 @@ struct r300_query {
 
 struct r300_texture {
     /* Parent class */
-    struct pipe_texture tex;
+    struct u_resource b;
 
     /* Offsets into the buffer. */
     unsigned offset[R300_MAX_TEXTURE_LEVELS];
@@ -250,16 +274,19 @@ struct r300_texture {
     /* Total size of this texture, in bytes. */
     unsigned size;
 
-    /* Whether this texture has non-power-of-two dimensions.
+    /* Whether this texture has non-power-of-two dimensions
+     * or a user-specified pitch.
      * It can be either a regular texture or a rectangle one.
      */
-    boolean is_npot;
+    boolean uses_pitch;
 
     /* Pipe buffer backing this texture. */
     struct r300_winsys_buffer *buffer;
 
     /* Registers carrying texture format data. */
-    struct r300_texture_format_state state;
+    /* Only format-independent bits should be filled in. */
+    struct r300_texture_format_state tx_format;
+    /* All bits should be filled in. */
     struct r300_texture_fb_state fb_state;
 
     /* Buffer tiling */
@@ -289,20 +316,37 @@ struct r300_context {
     /* Parent class */
     struct pipe_context context;
 
+    /* Emission of drawing packets. */
+    void (*emit_draw_arrays_immediate)(
+            struct r300_context *r300,
+            unsigned mode, unsigned start, unsigned count);
+
+    void (*emit_draw_arrays)(
+            struct r300_context *r300,
+            unsigned mode, unsigned count);
+
+    void (*emit_draw_elements)(
+            struct r300_context *r300, struct pipe_resource* indexBuffer,
+            unsigned indexSize, unsigned minIndex, unsigned maxIndex,
+            unsigned mode, unsigned start, unsigned count);
+
+
     /* The interface to the windowing system, etc. */
     struct r300_winsys_screen *rws;
+    /* Screen. */
+    struct r300_screen *screen;
     /* Draw module. Used mostly for SW TCL. */
     struct draw_context* draw;
     /* Accelerated blit support. */
     struct blitter_context* blitter;
 
     /* Vertex buffer for rendering. */
-    struct pipe_buffer* vbo;
+    struct pipe_resource* vbo;
     /* Offset into the VBO. */
     size_t vbo_offset;
 
     /* Occlusion query buffer. */
-    struct pipe_buffer* oqbo;
+    struct pipe_resource* oqbo;
     /* Query list. */
     struct r300_query *query_current;
     struct r300_query query_list;
@@ -316,14 +360,18 @@ struct r300_context {
     struct r300_atom blend_color_state;
     /* User clip planes. */
     struct r300_atom clip_state;
-    /* Shader constants. */
-    struct r300_constant_buffer shader_constants[PIPE_SHADER_TYPES];
     /* Depth, stencil, and alpha state. */
     struct r300_atom dsa_state;
     /* Fragment shader. */
-    struct r300_fragment_shader* fs;
+    struct r300_atom fs;
+    /* Fragment shader RC_CONSTANT_STATE variables. */
+    struct r300_atom fs_rc_constant_state;
+    /* Fragment shader constant buffer. */
+    struct r300_atom fs_constants;
     /* Framebuffer state. */
     struct r300_atom fb_state;
+    /* Occlusion query. */
+    struct r300_atom query_start;
     /* Rasterizer state. */
     struct r300_atom rs_state;
     /* RS block state. */
@@ -338,6 +386,8 @@ struct r300_context {
     struct r300_atom vap_output_state;
     /* Vertex shader. */
     struct r300_atom vs_state;
+    /* Vertex shader constant buffer. */
+    struct r300_atom vs_constants;
     /* Viewport state. */
     struct r300_atom viewport_state;
     /* ZTOP state. */
@@ -367,27 +417,40 @@ struct r300_context {
 
     struct pipe_viewport_state viewport;
 
-    /* Bitmask of dirty state objects. */
-    uint32_t dirty_state;
     /* Flag indicating whether or not the HW is dirty. */
     uint32_t dirty_hw;
     /* Whether polygon offset is enabled. */
     boolean polygon_offset_enabled;
     /* Z buffer bit depth. */
     uint32_t zbuffer_bpp;
-    /* Whether scissor is enabled. */
-    boolean scissor_enabled;
+    /* Whether rendering is conditional and should be skipped. */
+    boolean skip_rendering;
+    /* Whether the two-sided stencil ref value is different for front and
+     * back faces, and fallback should be used for r3xx-r4xx. */
+    boolean stencil_ref_bf_fallback;
+    /* Point sprites texcoord index,  1 bit per texcoord */
+    int sprite_coord_enable;
+
     /* upload managers */
     struct u_upload_mgr *upload_vb;
     struct u_upload_mgr *upload_ib;
 };
 
 /* Convenience cast wrapper. */
+static INLINE struct r300_texture* r300_texture(struct pipe_resource* tex)
+{
+    return (struct r300_texture*)tex;
+}
+
 static INLINE struct r300_context* r300_context(struct pipe_context* context)
 {
     return (struct r300_context*)context;
 }
 
+static INLINE struct r300_fragment_shader *r300_fs(struct r300_context *r300)
+{
+    return (struct r300_fragment_shader*)r300->fs.state;
+}
 
 struct pipe_context* r300_create_context(struct pipe_screen* screen,
                                          void *priv);
@@ -395,12 +458,11 @@ struct pipe_context* r300_create_context(struct pipe_screen* screen,
 /* Context initialization. */
 struct draw_stage* r300_draw_stage(struct r300_context* r300);
 void r300_init_state_functions(struct r300_context* r300);
-void r300_init_surface_functions(struct r300_context* r300);
-void r300_init_tex_functions( struct pipe_context *pipe );
+void r300_init_resource_functions(struct r300_context* r300);
 
 static INLINE boolean CTX_DBG_ON(struct r300_context * ctx, unsigned flags)
 {
-    return SCREEN_DBG_ON(r300_screen(ctx->context.screen), flags);
+    return SCREEN_DBG_ON(ctx->screen, flags);
 }
 
 static INLINE void CTX_DBG(struct r300_context * ctx, unsigned flags,
diff --git a/src/gallium/drivers/r300/r300_defines.h b/src/gallium/drivers/r300/r300_defines.h
index 2e04876de92..8237c999aac 100644
--- a/src/gallium/drivers/r300/r300_defines.h
+++ b/src/gallium/drivers/r300/r300_defines.h
@@ -28,14 +28,7 @@
 #define R300_MAX_TEXTURE_LEVELS         13
 #define R300_MAX_DRAW_VBO_SIZE          (1024 * 1024)
 
-#define R300_TEXTURE_USAGE_TRANSFER     PIPE_TEXTURE_USAGE_CUSTOM
-
-/* Non-atom dirty state flags. */
-#define R300_NEW_FRAGMENT_SHADER                0x00000020
-#define R300_NEW_FRAGMENT_SHADER_CONSTANTS      0x00000040
-#define R300_NEW_VERTEX_SHADER_CONSTANTS        0x10000000
-#define R300_NEW_QUERY                          0x40000000
-#define R300_NEW_KITCHEN_SINK                   0x7fffffff
+#define R300_RESOURCE_FLAG_TRANSFER     PIPE_RESOURCE_FLAG_DRV_PRIV
 
 /* Tiling flags. */
 enum r300_buffer_tiling {
diff --git a/src/gallium/drivers/r300/r300_emit.c b/src/gallium/drivers/r300/r300_emit.c
index 15bcf8907f3..9c4bcfc49b1 100644
--- a/src/gallium/drivers/r300/r300_emit.c
+++ b/src/gallium/drivers/r300/r300_emit.c
@@ -64,10 +64,9 @@ void r300_emit_blend_color_state(struct r300_context* r300,
                                  unsigned size, void* state)
 {
     struct r300_blend_color_state* bc = (struct r300_blend_color_state*)state;
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     CS_LOCALS(r300);
 
-    if (r300screen->caps->is_r500) {
+    if (r300->screen->caps.is_r500) {
         BEGIN_CS(size);
         OUT_CS_REG_SEQ(R500_RB3D_CONSTANT_COLOR_AR, 2);
         OUT_CS(bc->blend_color_red_alpha);
@@ -85,13 +84,12 @@ void r300_emit_clip_state(struct r300_context* r300,
 {
     struct pipe_clip_state* clip = (struct pipe_clip_state*)state;
     int i;
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     CS_LOCALS(r300);
 
-    if (r300screen->caps->has_tcl) {
+    if (r300->screen->caps.has_tcl) {
         BEGIN_CS(size);
         OUT_CS_REG(R300_VAP_PVS_VECTOR_INDX_REG,
-                (r300screen->caps->is_r500 ?
+                (r300->screen->caps.is_r500 ?
                  R500_PVS_UCP_START : R300_PVS_UCP_START));
         OUT_CS_ONE_REG(R300_VAP_PVS_UPLOAD_DATA, 6 * 4);
         for (i = 0; i < 6; i++) {
@@ -114,7 +112,6 @@ void r300_emit_clip_state(struct r300_context* r300,
 void r300_emit_dsa_state(struct r300_context* r300, unsigned size, void* state)
 {
     struct r300_dsa_state* dsa = (struct r300_dsa_state*)state;
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     struct pipe_framebuffer_state* fb =
         (struct pipe_framebuffer_state*)r300->fb_state.state;
     struct pipe_stencil_ref stencil_ref = r300->stencil_ref;
@@ -134,66 +131,53 @@ void r300_emit_dsa_state(struct r300_context* r300, unsigned size, void* state)
 
     OUT_CS(dsa->stencil_ref_mask | stencil_ref.ref_value[0]);
 
-    if (r300screen->caps->is_r500) {
+    if (r300->screen->caps.is_r500) {
         OUT_CS_REG(R500_ZB_STENCILREFMASK_BF, dsa->stencil_ref_bf | stencil_ref.ref_value[1]);
     }
     END_CS;
 }
 
-static const float * get_shader_constant(
+static const float * get_rc_constant_state(
     struct r300_context * r300,
-    struct rc_constant * constant,
-    struct r300_constant_buffer * externals)
+    struct rc_constant * constant)
 {
     struct r300_viewport_state* viewport = r300->viewport_state.state;
     struct r300_textures_state* texstate = r300->textures_state.state;
     static float vec[4] = { 0.0, 0.0, 0.0, 1.0 };
-    struct pipe_texture *tex;
-
-    switch(constant->Type) {
-        case RC_CONSTANT_EXTERNAL:
-            return externals->constants[constant->u.External];
-
-        case RC_CONSTANT_IMMEDIATE:
-            return constant->u.Immediate;
-
-        case RC_CONSTANT_STATE:
-            switch (constant->u.State[0]) {
-                /* Factor for converting rectangle coords to
-                 * normalized coords. Should only show up on non-r500. */
-                case RC_STATE_R300_TEXRECT_FACTOR:
-                    tex = texstate->fragment_sampler_views[constant->u.State[1]]->texture;
-                    vec[0] = 1.0 / tex->width0;
-                    vec[1] = 1.0 / tex->height0;
-                    break;
-
-                /* Texture compare-fail value. Shouldn't ever show up, but if
-                 * it does, we'll be ready. */
-                case RC_STATE_SHADOW_AMBIENT:
-                    vec[3] = 0;
-                    break;
-
-                case RC_STATE_R300_VIEWPORT_SCALE:
-                    vec[0] = viewport->xscale;
-                    vec[1] = viewport->yscale;
-                    vec[2] = viewport->zscale;
-                    break;
-
-                case RC_STATE_R300_VIEWPORT_OFFSET:
-                    vec[0] = viewport->xoffset;
-                    vec[1] = viewport->yoffset;
-                    vec[2] = viewport->zoffset;
-                    break;
-
-                default:
-                    fprintf(stderr, "r300: Implementation error: "
-                        "Unknown RC_CONSTANT type %d\n", constant->u.State[0]);
-            }
+    struct pipe_resource *tex;
+
+    assert(constant->Type == RC_CONSTANT_STATE);
+
+    switch (constant->u.State[0]) {
+        /* Factor for converting rectangle coords to
+         * normalized coords. Should only show up on non-r500. */
+        case RC_STATE_R300_TEXRECT_FACTOR:
+            tex = texstate->sampler_views[constant->u.State[1]]->base.texture;
+            vec[0] = 1.0 / tex->width0;
+            vec[1] = 1.0 / tex->height0;
+            break;
+
+        /* Texture compare-fail value. Shouldn't ever show up, but if
+         * it does, we'll be ready. */
+        case RC_STATE_SHADOW_AMBIENT:
+            vec[3] = 0;
+            break;
+
+        case RC_STATE_R300_VIEWPORT_SCALE:
+            vec[0] = viewport->xscale;
+            vec[1] = viewport->yscale;
+            vec[2] = viewport->zscale;
+            break;
+
+        case RC_STATE_R300_VIEWPORT_OFFSET:
+            vec[0] = viewport->xoffset;
+            vec[1] = viewport->yoffset;
+            vec[2] = viewport->zoffset;
             break;
 
         default:
             fprintf(stderr, "r300: Implementation error: "
-                "Unhandled constant type %d\n", constant->Type);
+                "Unknown RC_CONSTANT type %d\n", constant->u.State[0]);
     }
 
     /* This should either be (0, 0, 0, 1), which should be a relatively safe
@@ -236,17 +220,31 @@ static uint32_t pack_float24(float f)
     return float24;
 }
 
-void r300_emit_fragment_program_code(struct r300_context* r300,
-                                     struct rX00_fragment_program_code* generic_code)
+unsigned r300_get_fs_atom_size(struct r300_context *r300)
+{
+    struct r300_fragment_shader *fs = r300_fs(r300);
+    unsigned imm_count = fs->shader->immediates_count;
+    struct r300_fragment_program_code *code = &fs->shader->code.code.r300;
+
+    return 19 +
+           code->alu.length * 4 +
+           (code->tex.length ? (1 + code->tex.length) : 0) +
+           (imm_count ? imm_count * 5 : 0);
+}
+
+void r300_emit_fs(struct r300_context* r300, unsigned size, void *state)
 {
+    struct r300_fragment_shader *fs = r300_fs(r300);
+    struct rX00_fragment_program_code* generic_code = &fs->shader->code;
     struct r300_fragment_program_code * code = &generic_code->code.r300;
-    int i;
+    unsigned i;
+    unsigned imm_count = fs->shader->immediates_count;
+    unsigned imm_first = fs->shader->externals_count;
+    unsigned imm_end = generic_code->constants.Count;
+    struct rc_constant *constants = generic_code->constants.Constants;
     CS_LOCALS(r300);
 
-    BEGIN_CS(15 +
-             code->alu.length * 4 +
-             (code->tex.length ? (1 + code->tex.length) : 0));
-
+    BEGIN_CS(size);
     OUT_CS_REG(R300_US_CONFIG, code->config);
     OUT_CS_REG(R300_US_PIXSIZE, code->pixsize);
     OUT_CS_REG(R300_US_CODE_OFFSET, code->code_offset);
@@ -277,24 +275,43 @@ void r300_emit_fragment_program_code(struct r300_context* r300,
             OUT_CS(code->tex.inst[i]);
     }
 
+    /* Emit immediates. */
+    if (imm_count) {
+        for(i = imm_first; i < imm_end; ++i) {
+            if (constants[i].Type == RC_CONSTANT_IMMEDIATE) {
+                const float *data = constants[i].u.Immediate;
+
+                OUT_CS_REG_SEQ(R300_PFS_PARAM_0_X + i * 16, 4);
+                OUT_CS(pack_float24(data[0]));
+                OUT_CS(pack_float24(data[1]));
+                OUT_CS(pack_float24(data[2]));
+                OUT_CS(pack_float24(data[3]));
+            }
+        }
+    }
+
+    OUT_CS_REG(R300_FG_DEPTH_SRC, fs->shader->fg_depth_src);
+    OUT_CS_REG(R300_US_W_FMT, fs->shader->us_out_w);
     END_CS;
 }
 
-void r300_emit_fs_constant_buffer(struct r300_context* r300,
-                                  struct rc_constant_list* constants)
+void r300_emit_fs_constants(struct r300_context* r300, unsigned size, void *state)
 {
-    int i;
+    struct r300_fragment_shader *fs = r300_fs(r300);
+    struct rc_constant_list *constants = &fs->shader->code.constants;
+    struct r300_constant_buffer *buf = (struct r300_constant_buffer*)state;
+    unsigned i, count = fs->shader->externals_count;
     CS_LOCALS(r300);
 
-    if (constants->Count == 0)
+    if (count == 0)
         return;
 
-    BEGIN_CS(constants->Count * 4 + 1);
-    OUT_CS_REG_SEQ(R300_PFS_PARAM_0_X, constants->Count * 4);
-    for(i = 0; i < constants->Count; ++i) {
-        const float * data = get_shader_constant(r300,
-                                                 &constants->Constants[i],
-                                                 &r300->shader_constants[PIPE_SHADER_FRAGMENT]);
+    BEGIN_CS(size);
+    OUT_CS_REG_SEQ(R300_PFS_PARAM_0_X, count * 4);
+    for(i = 0; i < count; ++i) {
+        const float *data;
+        assert(constants->Constants[i].Type == RC_CONSTANT_EXTERNAL);
+        data = buf->constants[i];
         OUT_CS(pack_float24(data[0]));
         OUT_CS(pack_float24(data[1]));
         OUT_CS(pack_float24(data[2]));
@@ -303,31 +320,59 @@ void r300_emit_fs_constant_buffer(struct r300_context* r300,
     END_CS;
 }
 
-static void r300_emit_fragment_depth_config(struct r300_context* r300,
-                                            struct r300_fragment_shader* fs)
+void r300_emit_fs_rc_constant_state(struct r300_context* r300, unsigned size, void *state)
 {
+    struct r300_fragment_shader *fs = r300_fs(r300);
+    struct rc_constant_list *constants = &fs->shader->code.constants;
+    unsigned i;
+    unsigned count = fs->shader->rc_state_count;
+    unsigned first = fs->shader->externals_count;
+    unsigned end = constants->Count;
     CS_LOCALS(r300);
 
-    BEGIN_CS(4);
-    if (r300_fragment_shader_writes_depth(fs)) {
-        OUT_CS_REG(R300_FG_DEPTH_SRC, R300_FG_DEPTH_SRC_SHADER);
-        OUT_CS_REG(R300_US_W_FMT, R300_W_FMT_W24 | R300_W_SRC_US);
-    } else {
-        OUT_CS_REG(R300_FG_DEPTH_SRC, R300_FG_DEPTH_SRC_SCAN);
-        OUT_CS_REG(R300_US_W_FMT, R300_W_FMT_W0 | R300_W_SRC_US);
+    if (count == 0)
+        return;
+
+    BEGIN_CS(size);
+    for(i = first; i < end; ++i) {
+        if (constants->Constants[i].Type == RC_CONSTANT_STATE) {
+            const float *data =
+                    get_rc_constant_state(r300, &constants->Constants[i]);
+
+            OUT_CS_REG_SEQ(R300_PFS_PARAM_0_X + i * 16, 4);
+            OUT_CS(pack_float24(data[0]));
+            OUT_CS(pack_float24(data[1]));
+            OUT_CS(pack_float24(data[2]));
+            OUT_CS(pack_float24(data[3]));
+        }
     }
     END_CS;
 }
 
-void r500_emit_fragment_program_code(struct r300_context* r300,
-                                     struct rX00_fragment_program_code* generic_code)
+unsigned r500_get_fs_atom_size(struct r300_context *r300)
+{
+    struct r300_fragment_shader *fs = r300_fs(r300);
+    unsigned imm_count = fs->shader->immediates_count;
+    struct r500_fragment_program_code *code = &fs->shader->code.code.r500;
+
+    return 17 +
+           ((code->inst_end + 1) * 6) +
+           (imm_count ? imm_count * 7 : 0);
+}
+
+void r500_emit_fs(struct r300_context* r300, unsigned size, void *state)
 {
+    struct r300_fragment_shader *fs = r300_fs(r300);
+    struct rX00_fragment_program_code* generic_code = &fs->shader->code;
     struct r500_fragment_program_code * code = &generic_code->code.r500;
-    int i;
+    unsigned i;
+    unsigned imm_count = fs->shader->immediates_count;
+    unsigned imm_first = fs->shader->externals_count;
+    unsigned imm_end = generic_code->constants.Count;
+    struct rc_constant *constants = generic_code->constants.Constants;
     CS_LOCALS(r300);
 
-    BEGIN_CS(13 +
-             ((code->inst_end + 1) * 6));
+    BEGIN_CS(size);
     OUT_CS_REG(R500_US_CONFIG, R500_ZERO_TIMES_ANYTHING_EQUALS_ZERO);
     OUT_CS_REG(R500_US_PIXSIZE, code->max_temp_idx);
     OUT_CS_REG(R500_US_CODE_RANGE,
@@ -347,25 +392,48 @@ void r500_emit_fragment_program_code(struct r300_context* r300,
         OUT_CS(code->inst[i].inst5);
     }
 
+    /* Emit immediates. */
+    if (imm_count) {
+        for(i = imm_first; i < imm_end; ++i) {
+            if (constants[i].Type == RC_CONSTANT_IMMEDIATE) {
+                const float *data = constants[i].u.Immediate;
+
+                OUT_CS_REG(R500_GA_US_VECTOR_INDEX,
+                           R500_GA_US_VECTOR_INDEX_TYPE_CONST |
+                           (i & R500_GA_US_VECTOR_INDEX_MASK));
+                OUT_CS_ONE_REG(R500_GA_US_VECTOR_DATA, 4);
+                OUT_CS_32F(data[0]);
+                OUT_CS_32F(data[1]);
+                OUT_CS_32F(data[2]);
+                OUT_CS_32F(data[3]);
+            }
+        }
+    }
+
+    OUT_CS_REG(R300_FG_DEPTH_SRC, fs->shader->fg_depth_src);
+    OUT_CS_REG(R300_US_W_FMT, fs->shader->us_out_w);
     END_CS;
 }
 
-void r500_emit_fs_constant_buffer(struct r300_context* r300,
-                                  struct rc_constant_list* constants)
+void r500_emit_fs_constants(struct r300_context* r300, unsigned size, void *state)
 {
-    int i;
+    struct r300_fragment_shader *fs = r300_fs(r300);
+    struct rc_constant_list *constants = &fs->shader->code.constants;
+    struct r300_constant_buffer *buf = (struct r300_constant_buffer*)state;
+    unsigned i, count = fs->shader->externals_count;
     CS_LOCALS(r300);
 
-    if (constants->Count == 0)
+    if (count == 0)
         return;
 
-    BEGIN_CS(constants->Count * 4 + 3);
+    BEGIN_CS(size);
     OUT_CS_REG(R500_GA_US_VECTOR_INDEX, R500_GA_US_VECTOR_INDEX_TYPE_CONST);
-    OUT_CS_ONE_REG(R500_GA_US_VECTOR_DATA, constants->Count * 4);
-    for (i = 0; i < constants->Count; i++) {
-        const float * data = get_shader_constant(r300,
-                                                 &constants->Constants[i],
-                                                 &r300->shader_constants[PIPE_SHADER_FRAGMENT]);
+    OUT_CS_ONE_REG(R500_GA_US_VECTOR_DATA, count * 4);
+    for(i = 0; i < count; ++i) {
+        const float *data;
+        assert(constants->Constants[i].Type == RC_CONSTANT_EXTERNAL);
+        data = buf->constants[i];
+
         OUT_CS_32F(data[0]);
         OUT_CS_32F(data[1]);
         OUT_CS_32F(data[2]);
@@ -374,10 +442,41 @@ void r500_emit_fs_constant_buffer(struct r300_context* r300,
     END_CS;
 }
 
+void r500_emit_fs_rc_constant_state(struct r300_context* r300, unsigned size, void *state)
+{
+    struct r300_fragment_shader *fs = r300_fs(r300);
+    struct rc_constant_list *constants = &fs->shader->code.constants;
+    unsigned i;
+    unsigned count = fs->shader->rc_state_count;
+    unsigned first = fs->shader->externals_count;
+    unsigned end = constants->Count;
+    CS_LOCALS(r300);
+
+    if (count == 0)
+        return;
+
+    BEGIN_CS(size);
+    for(i = first; i < end; ++i) {
+        if (constants->Constants[i].Type == RC_CONSTANT_STATE) {
+            const float *data =
+                    get_rc_constant_state(r300, &constants->Constants[i]);
+
+            OUT_CS_REG(R500_GA_US_VECTOR_INDEX,
+                       R500_GA_US_VECTOR_INDEX_TYPE_CONST |
+                       (i & R500_GA_US_VECTOR_INDEX_MASK));
+            OUT_CS_ONE_REG(R500_GA_US_VECTOR_DATA, 4);
+            OUT_CS_32F(data[0]);
+            OUT_CS_32F(data[1]);
+            OUT_CS_32F(data[2]);
+            OUT_CS_32F(data[3]);
+        }
+    }
+    END_CS;
+}
+
 void r300_emit_fb_state(struct r300_context* r300, unsigned size, void* state)
 {
     struct pipe_framebuffer_state* fb = (struct pipe_framebuffer_state*)state;
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     struct r300_texture* tex;
     struct pipe_surface* surf;
     int i;
@@ -395,7 +494,7 @@ void r300_emit_fb_state(struct r300_context* r300, unsigned size, void* state)
 
     /* Set the number of colorbuffers. */
     if (fb->nr_cbufs > 1) {
-        if (r300screen->caps->is_r500) {
+        if (r300->screen->caps.is_r500) {
             OUT_CS_REG(R300_RB3D_CCTL,
                 R300_RB3D_CCTL_NUM_MULTIWRITES(fb->nr_cbufs) |
                 R300_RB3D_CCTL_INDEPENDENT_COLORFORMAT_ENABLE_ENABLE);
@@ -410,7 +509,7 @@ void r300_emit_fb_state(struct r300_context* r300, unsigned size, void* state)
     /* Set up colorbuffers. */
     for (i = 0; i < fb->nr_cbufs; i++) {
         surf = fb->cbufs[i];
-        tex = (struct r300_texture*)surf->texture;
+        tex = r300_texture(surf->texture);
         assert(tex && tex->buffer && "cbuf is marked, but NULL!");
 
         OUT_CS_REG_SEQ(R300_RB3D_COLOROFFSET0 + (4 * i), 1);
@@ -429,7 +528,7 @@ void r300_emit_fb_state(struct r300_context* r300, unsigned size, void* state)
     /* Set up a zbuffer. */
     if (fb->zsbuf) {
         surf = fb->zsbuf;
-        tex = (struct r300_texture*)surf->texture;
+        tex = r300_texture(surf->texture);
         assert(tex && tex->buffer && "zsbuf is marked, but NULL!");
 
         OUT_CS_REG_SEQ(R300_ZB_DEPTHOFFSET, 1);
@@ -442,22 +541,32 @@ void r300_emit_fb_state(struct r300_context* r300, unsigned size, void* state)
                      0, RADEON_GEM_DOMAIN_VRAM, 0);
     }
 
+    OUT_CS_REG_SEQ(R300_SC_SCISSORS_TL, 2);
+    if (r300->screen->caps.is_r500) {
+        OUT_CS(0);
+        OUT_CS(((fb->width  - 1) << R300_SCISSORS_X_SHIFT) |
+               ((fb->height - 1) << R300_SCISSORS_Y_SHIFT));
+    } else {
+        OUT_CS((1440 << R300_SCISSORS_X_SHIFT) |
+               (1440 << R300_SCISSORS_Y_SHIFT));
+        OUT_CS(((fb->width  + 1440-1) << R300_SCISSORS_X_SHIFT) |
+               ((fb->height + 1440-1) << R300_SCISSORS_Y_SHIFT));
+    }
     OUT_CS_REG(R300_GA_POINT_MINMAX,
         (MAX2(fb->width, fb->height) * 6) << R300_GA_POINT_MINMAX_MAX_SHIFT);
     END_CS;
 }
 
-void r300_emit_query_start(struct r300_context *r300)
+void r300_emit_query_start(struct r300_context *r300, unsigned size, void*state)
 {
-    struct r300_capabilities *caps = r300_screen(r300->context.screen)->caps;
     struct r300_query *query = r300->query_current;
     CS_LOCALS(r300);
 
     if (!query)
 	return;
 
-    BEGIN_CS(4);
-    if (caps->family == CHIP_FAMILY_RV530) {
+    BEGIN_CS(size);
+    if (r300->screen->caps.family == CHIP_FAMILY_RV530) {
         OUT_CS_REG(RV530_FG_ZBREG_DEST, RV530_FG_ZBREG_DEST_PIPE_SELECT_ALL);
     } else {
         OUT_CS_REG(R300_SU_REG_DEST, R300_RASTER_PIPE_SELECT_ALL);
@@ -471,7 +580,7 @@ void r300_emit_query_start(struct r300_context *r300)
 static void r300_emit_query_finish(struct r300_context *r300,
                                    struct r300_query *query)
 {
-    struct r300_capabilities* caps = r300_screen(r300->context.screen)->caps;
+    struct r300_capabilities* caps = &r300->screen->caps;
     CS_LOCALS(r300);
 
     assert(caps->num_frag_pipes);
@@ -555,7 +664,7 @@ static void rv530_emit_query_double(struct r300_context *r300,
 
 void r300_emit_query_end(struct r300_context* r300)
 {
-    struct r300_capabilities *caps = r300_screen(r300->context.screen)->caps;
+    struct r300_capabilities *caps = &r300->screen->caps;
     struct r300_query *query = r300->query_current;
 
     if (!query)
@@ -613,6 +722,13 @@ void r300_emit_rs_state(struct r300_context* r300, unsigned size, void* state)
     OUT_CS_REG(R300_GA_LINE_STIPPLE_CONFIG, rs->line_stipple_config);
     OUT_CS_REG(R300_GA_LINE_STIPPLE_VALUE, rs->line_stipple_value);
     OUT_CS_REG(R300_GA_POLY_MODE, rs->polygon_mode);
+    OUT_CS_REG(R300_SC_CLIP_RULE, rs->clip_rule);
+    OUT_CS_REG(R300_GB_ENABLE, rs->stuffing_enable);
+    OUT_CS_REG_SEQ(R300_GA_POINT_S0, 4);
+    OUT_CS_32F(rs->point_texcoord_left);
+    OUT_CS_32F(rs->point_texcoord_bottom);
+    OUT_CS_32F(rs->point_texcoord_right);
+    OUT_CS_32F(rs->point_texcoord_top);
     END_CS;
 }
 
@@ -621,7 +737,6 @@ void r300_emit_rs_block_state(struct r300_context* r300,
 {
     struct r300_rs_block* rs = (struct r300_rs_block*)state;
     unsigned i;
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     /* It's the same for both INST and IP tables */
     unsigned count = (rs->inst_count & R300_RS_INST_COUNT_MASK) + 1;
     CS_LOCALS(r300);
@@ -629,7 +744,7 @@ void r300_emit_rs_block_state(struct r300_context* r300,
     DBG(r300, DBG_DRAW, "r300: RS emit:\n");
 
     BEGIN_CS(size);
-    if (r300screen->caps->is_r500) {
+    if (r300->screen->caps.is_r500) {
         OUT_CS_REG_SEQ(R500_RS_IP_0, count);
     } else {
         OUT_CS_REG_SEQ(R300_RS_IP_0, count);
@@ -643,7 +758,7 @@ void r300_emit_rs_block_state(struct r300_context* r300,
     OUT_CS(rs->count);
     OUT_CS(rs->inst_count);
 
-    if (r300screen->caps->is_r500) {
+    if (r300->screen->caps.is_r500) {
         OUT_CS_REG_SEQ(R500_RS_INST_0, count);
     } else {
         OUT_CS_REG_SEQ(R300_RS_INST_0, count);
@@ -662,62 +777,22 @@ void r300_emit_rs_block_state(struct r300_context* r300,
 void r300_emit_scissor_state(struct r300_context* r300,
                              unsigned size, void* state)
 {
-    unsigned minx, miny, maxx, maxy;
-    uint32_t top_left, bottom_right;
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     struct pipe_scissor_state* scissor = (struct pipe_scissor_state*)state;
-    struct pipe_framebuffer_state* fb =
-        (struct pipe_framebuffer_state*)r300->fb_state.state;
     CS_LOCALS(r300);
 
-    minx = miny = 0;
-    maxx = fb->width;
-    maxy = fb->height;
-
-    if (r300->scissor_enabled) {
-        minx = MAX2(minx, scissor->minx);
-        miny = MAX2(miny, scissor->miny);
-        maxx = MIN2(maxx, scissor->maxx);
-        maxy = MIN2(maxy, scissor->maxy);
-    }
-
-    /* Special case for zero-area scissor.
-     *
-     * We can't allow the variables maxx and maxy to be zero because they are
-     * subtracted from later in the code, which would cause emitting ~0 and
-     * making the kernel checker angry.
-     *
-     * Let's consider we change maxx and maxy to 1, which is effectively
-     * a one-pixel area. We must then change minx and miny to a number which is
-     * greater than 1 to get the zero area back. */
-    if (!maxx || !maxy) {
-        minx = 2;
-        miny = 2;
-        maxx = 1;
-        maxy = 1;
-    }
-
-    if (r300screen->caps->is_r500) {
-        top_left =
-            (minx << R300_SCISSORS_X_SHIFT) |
-            (miny << R300_SCISSORS_Y_SHIFT);
-        bottom_right =
-            ((maxx - 1) << R300_SCISSORS_X_SHIFT) |
-            ((maxy - 1) << R300_SCISSORS_Y_SHIFT);
+    BEGIN_CS(size);
+    OUT_CS_REG_SEQ(R300_SC_CLIPRECT_TL_0, 2);
+    if (r300->screen->caps.is_r500) {
+        OUT_CS((scissor->minx << R300_CLIPRECT_X_SHIFT) |
+               (scissor->miny << R300_CLIPRECT_Y_SHIFT));
+        OUT_CS(((scissor->maxx - 1) << R300_CLIPRECT_X_SHIFT) |
+               ((scissor->maxy - 1) << R300_CLIPRECT_Y_SHIFT));
     } else {
-        /* Offset of 1440 in non-R500 chipsets. */
-        top_left =
-            ((minx + 1440) << R300_SCISSORS_X_SHIFT) |
-            ((miny + 1440) << R300_SCISSORS_Y_SHIFT);
-        bottom_right =
-            (((maxx - 1) + 1440) << R300_SCISSORS_X_SHIFT) |
-            (((maxy - 1) + 1440) << R300_SCISSORS_Y_SHIFT);
+        OUT_CS(((scissor->minx + 1440) << R300_CLIPRECT_X_SHIFT) |
+               ((scissor->miny + 1440) << R300_CLIPRECT_Y_SHIFT));
+        OUT_CS(((scissor->maxx + 1440-1) << R300_CLIPRECT_X_SHIFT) |
+               ((scissor->maxy + 1440-1) << R300_CLIPRECT_Y_SHIFT));
     }
-
-    BEGIN_CS(size);
-    OUT_CS_REG_SEQ(R300_SC_SCISSORS_TL, 2);
-    OUT_CS(top_left);
-    OUT_CS(bottom_right);
     END_CS;
 }
 
@@ -736,18 +811,18 @@ void r300_emit_textures_state(struct r300_context *r300,
         if ((1 << i) & allstate->tx_enable) {
             texstate = &allstate->regs[i];
 
-            OUT_CS_REG(R300_TX_FILTER0_0 + (i * 4), texstate->filter[0]);
-            OUT_CS_REG(R300_TX_FILTER1_0 + (i * 4), texstate->filter[1]);
+            OUT_CS_REG(R300_TX_FILTER0_0 + (i * 4), texstate->filter0);
+            OUT_CS_REG(R300_TX_FILTER1_0 + (i * 4), texstate->filter1);
             OUT_CS_REG(R300_TX_BORDER_COLOR_0 + (i * 4),
                        texstate->border_color);
 
-            OUT_CS_REG(R300_TX_FORMAT0_0 + (i * 4), texstate->format[0]);
-            OUT_CS_REG(R300_TX_FORMAT1_0 + (i * 4), texstate->format[1]);
-            OUT_CS_REG(R300_TX_FORMAT2_0 + (i * 4), texstate->format[2]);
+            OUT_CS_REG(R300_TX_FORMAT0_0 + (i * 4), texstate->format.format0);
+            OUT_CS_REG(R300_TX_FORMAT1_0 + (i * 4), texstate->format.format1);
+            OUT_CS_REG(R300_TX_FORMAT2_0 + (i * 4), texstate->format.format2);
 
             OUT_CS_REG_SEQ(R300_TX_OFFSET_0 + (i * 4), 1);
-            OUT_CS_TEX_RELOC((struct r300_texture *)allstate->fragment_sampler_views[i]->texture,
-                             texstate->tile_config,
+            OUT_CS_TEX_RELOC(r300_texture(allstate->sampler_views[i]->base.texture),
+                             texstate->format.tile_config,
                              RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0, 0);
         }
     }
@@ -876,11 +951,11 @@ void r300_emit_vs_state(struct r300_context* r300, unsigned size, void* state)
 {
     struct r300_vertex_shader* vs = (struct r300_vertex_shader*)state;
     struct r300_vertex_program_code* code = &vs->code;
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
+    struct r300_screen* r300screen = r300->screen;
     unsigned instruction_count = code->length / 4;
     unsigned i;
 
-    unsigned vtx_mem_size = r300screen->caps->is_r500 ? 128 : 72;
+    unsigned vtx_mem_size = r300screen->caps.is_r500 ? 128 : 72;
     unsigned input_count = MAX2(util_bitcount(code->InputsRead), 1);
     unsigned output_count = MAX2(util_bitcount(code->OutputsWritten), 1);
     unsigned temp_count = MAX2(code->num_temporaries, 1);
@@ -889,6 +964,10 @@ void r300_emit_vs_state(struct r300_context* r300, unsigned size, void* state)
                                   vtx_mem_size / output_count, 10);
     unsigned pvs_num_controllers = MIN2(vtx_mem_size / temp_count, 6);
 
+    unsigned imm_first = vs->externals_count;
+    unsigned imm_end = vs->code.constants.Count;
+    unsigned imm_count = vs->immediates_count;
+
     CS_LOCALS(r300);
 
     BEGIN_CS(size);
@@ -911,28 +990,47 @@ void r300_emit_vs_state(struct r300_context* r300, unsigned size, void* state)
 
     OUT_CS_REG(R300_VAP_CNTL, R300_PVS_NUM_SLOTS(pvs_num_slots) |
             R300_PVS_NUM_CNTLRS(pvs_num_controllers) |
-            R300_PVS_NUM_FPUS(r300screen->caps->num_vert_fpus) |
+            R300_PVS_NUM_FPUS(r300screen->caps.num_vert_fpus) |
             R300_PVS_VF_MAX_VTX_NUM(12) |
-            (r300screen->caps->is_r500 ? R500_TCL_STATE_OPTIMIZATION : 0));
+            (r300screen->caps.is_r500 ? R500_TCL_STATE_OPTIMIZATION : 0));
+
+    /* Emit immediates. */
+    if (imm_count) {
+        OUT_CS_REG(R300_VAP_PVS_VECTOR_INDX_REG,
+                   (r300->screen->caps.is_r500 ?
+                   R500_PVS_CONST_START : R300_PVS_CONST_START) +
+                   imm_first);
+        OUT_CS_ONE_REG(R300_VAP_PVS_UPLOAD_DATA, imm_count * 4);
+        for (i = imm_first; i < imm_end; i++) {
+            const float *data = vs->code.constants.Constants[i].u.Immediate;
+            OUT_CS_32F(data[0]);
+            OUT_CS_32F(data[1]);
+            OUT_CS_32F(data[2]);
+            OUT_CS_32F(data[3]);
+        }
+    }
     END_CS;
 }
 
-void r300_emit_vs_constant_buffer(struct r300_context* r300,
-                                  struct rc_constant_list* constants)
+void r300_emit_vs_constants(struct r300_context* r300,
+                            unsigned size, void *state)
 {
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
     unsigned i;
+    unsigned count =
+        ((struct r300_vertex_shader*)r300->vs_state.state)->externals_count;
+    struct r300_constant_buffer *buf = (struct r300_constant_buffer*)state;
     CS_LOCALS(r300);
 
-    BEGIN_CS(constants->Count * 4 + 3);
+    if (!count)
+        return;
+
+    BEGIN_CS(size);
     OUT_CS_REG(R300_VAP_PVS_VECTOR_INDX_REG,
-               (r300screen->caps->is_r500 ?
+               (r300->screen->caps.is_r500 ?
                R500_PVS_CONST_START : R300_PVS_CONST_START));
-    OUT_CS_ONE_REG(R300_VAP_PVS_UPLOAD_DATA, constants->Count * 4);
-    for (i = 0; i < constants->Count; i++) {
-        const float *data = get_shader_constant(r300,
-                                                &constants->Constants[i],
-                                                &r300->shader_constants[PIPE_SHADER_VERTEX]);
+    OUT_CS_ONE_REG(R300_VAP_PVS_UPLOAD_DATA, count * 4);
+    for (i = 0; i < count; i++) {
+        const float *data = buf->constants[i];
         OUT_CS_32F(data[0]);
         OUT_CS_32F(data[1]);
         OUT_CS_32F(data[2]);
@@ -981,7 +1079,7 @@ void r300_emit_texture_cache_inval(struct r300_context* r300, unsigned size, voi
 
 void r300_emit_buffer_validate(struct r300_context *r300,
                                boolean do_validate_vertex_buffers,
-                               struct pipe_buffer *index_buffer)
+                               struct pipe_resource *index_buffer)
 {
     struct pipe_framebuffer_state* fb =
         (struct pipe_framebuffer_state*)r300->fb_state.state;
@@ -990,7 +1088,7 @@ void r300_emit_buffer_validate(struct r300_context *r300,
     struct r300_texture* tex;
     struct pipe_vertex_buffer *vbuf = r300->vertex_buffer;
     struct pipe_vertex_element *velem = r300->velems->velem;
-    struct pipe_buffer *pbuf;
+    struct pipe_resource *pbuf;
     unsigned i;
     boolean invalid = FALSE;
 
@@ -1006,7 +1104,7 @@ void r300_emit_buffer_validate(struct r300_context *r300,
 validate:
     /* Color buffers... */
     for (i = 0; i < fb->nr_cbufs; i++) {
-        tex = (struct r300_texture*)fb->cbufs[i]->texture;
+        tex = r300_texture(fb->cbufs[i]->texture);
         assert(tex && tex->buffer && "cbuf is marked, but NULL!");
         if (!r300_add_texture(r300->rws, tex,
 			      0, RADEON_GEM_DOMAIN_VRAM)) {
@@ -1016,7 +1114,7 @@ validate:
     }
     /* ...depth buffer... */
     if (fb->zsbuf) {
-        tex = (struct r300_texture*)fb->zsbuf->texture;
+        tex = r300_texture(fb->zsbuf->texture);
         assert(tex && tex->buffer && "zsbuf is marked, but NULL!");
         if (!r300_add_texture(r300->rws, tex,
 			      0, RADEON_GEM_DOMAIN_VRAM)) {
@@ -1030,7 +1128,7 @@ validate:
             continue;
         }
 
-        tex = (struct r300_texture*)texstate->fragment_sampler_views[i]->texture;
+        tex = r300_texture(texstate->sampler_views[i]->base.texture);
         if (!r300_add_texture(r300->rws, tex,
 			      RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0)) {
             r300->context.flush(&r300->context, 0, NULL);
@@ -1038,7 +1136,7 @@ validate:
         }
     }
     /* ...occlusion query buffer... */
-    if (r300->dirty_state & R300_NEW_QUERY) {
+    if (r300->query_start.dirty) {
         if (!r300_add_buffer(r300->rws, r300->oqbo,
 			     0, RADEON_GEM_DOMAIN_GTT)) {
             r300->context.flush(&r300->context, 0, NULL);
@@ -1091,70 +1189,29 @@ unsigned r300_get_num_dirty_dwords(struct r300_context *r300)
     unsigned dwords = 0;
 
     foreach(atom, &r300->atom_list) {
-        if (atom->dirty || atom->always_dirty) {
+        if (atom->dirty) {
             dwords += atom->size;
         }
     }
 
-    /* XXX This is the compensation for the non-atomized states. */
-    dwords += 1024;
-
     return dwords;
 }
 
 /* Emit all dirty state. */
 void r300_emit_dirty_state(struct r300_context* r300)
 {
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
+    struct r300_screen* r300screen = r300->screen;
     struct r300_atom* atom;
 
-    if (r300->dirty_state & R300_NEW_QUERY) {
-        r300_emit_query_start(r300);
-        r300->dirty_state &= ~R300_NEW_QUERY;
-    }
-
     foreach(atom, &r300->atom_list) {
-        if (atom->dirty || atom->always_dirty) {
+        if (atom->dirty) {
             atom->emit(r300, atom->size, atom->state);
             atom->dirty = FALSE;
         }
     }
 
-    if (r300->dirty_state & R300_NEW_FRAGMENT_SHADER) {
-        r300_emit_fragment_depth_config(r300, r300->fs);
-        if (r300screen->caps->is_r500) {
-            r500_emit_fragment_program_code(r300, &r300->fs->shader->code);
-        } else {
-            r300_emit_fragment_program_code(r300, &r300->fs->shader->code);
-        }
-        r300->dirty_state &= ~R300_NEW_FRAGMENT_SHADER;
-    }
-
-    if (r300->dirty_state & R300_NEW_FRAGMENT_SHADER_CONSTANTS) {
-        if (r300screen->caps->is_r500) {
-            r500_emit_fs_constant_buffer(r300,
-                                         &r300->fs->shader->code.constants);
-        } else {
-            r300_emit_fs_constant_buffer(r300,
-                                         &r300->fs->shader->code.constants);
-        }
-        r300->dirty_state &= ~R300_NEW_FRAGMENT_SHADER_CONSTANTS;
-    }
-
-    if (r300->dirty_state & R300_NEW_VERTEX_SHADER_CONSTANTS) {
-        struct r300_vertex_shader* vs = r300->vs_state.state;
-        if (vs->code.constants.Count) {
-            r300_emit_vs_constant_buffer(r300, &vs->code.constants);
-        }
-        r300->dirty_state &= ~R300_NEW_VERTEX_SHADER_CONSTANTS;
-    }
-
-    /* XXX
-    assert(r300->dirty_state == 0);
-    */
-
     /* Emit the VBO for SWTCL. */
-    if (!r300screen->caps->has_tcl) {
+    if (!r300screen->caps.has_tcl) {
         r300_emit_vertex_buffer(r300);
     }
 
diff --git a/src/gallium/drivers/r300/r300_emit.h b/src/gallium/drivers/r300/r300_emit.h
index 7db2fc6a1a1..56f7318cdbe 100644
--- a/src/gallium/drivers/r300/r300_emit.h
+++ b/src/gallium/drivers/r300/r300_emit.h
@@ -43,21 +43,25 @@ void r300_emit_clip_state(struct r300_context* r300,
 void r300_emit_dsa_state(struct r300_context* r300,
                          unsigned size, void* state);
 
-void r300_emit_fragment_program_code(struct r300_context* r300,
-                                     struct rX00_fragment_program_code* generic_code);
+unsigned r300_get_fs_atom_size(struct r300_context *r300);
 
-void r300_emit_fs_constant_buffer(struct r300_context* r300,
-                                  struct rc_constant_list* constants);
+void r300_emit_fs(struct r300_context* r300, unsigned size, void *state);
 
-void r500_emit_fragment_program_code(struct r300_context* r300,
-                                     struct rX00_fragment_program_code* generic_code);
+void r300_emit_fs_constants(struct r300_context* r300, unsigned size, void *state);
 
-void r500_emit_fs_constant_buffer(struct r300_context* r300,
-                                  struct rc_constant_list* constants);
+void r300_emit_fs_rc_constant_state(struct r300_context* r300, unsigned size, void *state);
+
+unsigned r500_get_fs_atom_size(struct r300_context *r300);
+
+void r500_emit_fs(struct r300_context* r300, unsigned size, void *state);
+
+void r500_emit_fs_constants(struct r300_context* r300, unsigned size, void *state);
+
+void r500_emit_fs_rc_constant_state(struct r300_context* r300, unsigned size, void *state);
 
 void r300_emit_fb_state(struct r300_context* r300, unsigned size, void* state);
 
-void r300_emit_query_start(struct r300_context* r300);
+void r300_emit_query_start(struct r300_context *r300, unsigned size, void *state);
 
 void r300_emit_query_end(struct r300_context* r300);
 
@@ -80,8 +84,8 @@ void r300_emit_vertex_stream_state(struct r300_context* r300,
 void r300_emit_vap_output_state(struct r300_context* r300,
                                unsigned size, void* state);
 
-void r300_emit_vs_constant_buffer(struct r300_context* r300,
-                                  struct rc_constant_list* constants);
+void r300_emit_vs_constants(struct r300_context* r300,
+                            unsigned size, void *state);
 
 void r300_emit_vs_state(struct r300_context* r300, unsigned size, void* state);
 
@@ -102,6 +106,6 @@ void r300_emit_dirty_state(struct r300_context* r300);
 
 void r300_emit_buffer_validate(struct r300_context *r300,
                                boolean do_validate_vertex_buffers,
-                               struct pipe_buffer *index_buffer);
+                               struct pipe_resource *index_buffer);
 
 #endif /* R300_EMIT_H */
diff --git a/src/gallium/drivers/r300/r300_flush.c b/src/gallium/drivers/r300/r300_flush.c
index 70de152713d..5e61f528b64 100644
--- a/src/gallium/drivers/r300/r300_flush.c
+++ b/src/gallium/drivers/r300/r300_flush.c
@@ -52,7 +52,6 @@ static void r300_flush(struct pipe_context* pipe,
 
     if (r300->dirty_hw) {
         FLUSH_CS;
-        r300->dirty_state = R300_NEW_KITCHEN_SINK;
         r300->dirty_hw = 0;
 
         /* New kitchen sink, baby. */
@@ -63,9 +62,9 @@ static void r300_flush(struct pipe_context* pipe,
         }
 
         /* Unmark HWTCL state for SWTCL. */
-        if (!r300_screen(pipe->screen)->caps->has_tcl) {
+        if (!r300->screen->caps.has_tcl) {
             r300->vs_state.dirty = FALSE;
-            r300->dirty_state &= ~R300_NEW_VERTEX_SHADER_CONSTANTS;
+            r300->vs_constants.dirty = FALSE;
         }
     }
 
diff --git a/src/gallium/drivers/r300/r300_fs.c b/src/gallium/drivers/r300/r300_fs.c
index e23fef8c9f7..cf81771bb7b 100644
--- a/src/gallium/drivers/r300/r300_fs.c
+++ b/src/gallium/drivers/r300/r300_fs.c
@@ -26,10 +26,12 @@
 #include "util/u_memory.h"
 
 #include "tgsi/tgsi_dump.h"
+#include "tgsi/tgsi_ureg.h"
 
 #include "r300_context.h"
 #include "r300_screen.h"
 #include "r300_fs.h"
+#include "r300_reg.h"
 #include "r300_tgsi_to_rc.h"
 
 #include "radeon_code.h"
@@ -69,26 +71,27 @@ void r300_shader_read_fs_inputs(struct tgsi_shader_info* info,
                 break;
 
             default:
-                assert(0);
+                fprintf(stderr, "r300: FP: Unknown input semantic: %i\n",
+                        info->input_semantic_name[i]);
         }
     }
 }
 
 static void find_output_registers(struct r300_fragment_program_compiler * compiler,
-                                  struct r300_fragment_shader * fs)
+                                  struct r300_fragment_shader_code *shader)
 {
     unsigned i, colorbuf_count = 0;
 
     /* Mark the outputs as not present initially */
-    compiler->OutputColor[0] = fs->info.num_outputs;
-    compiler->OutputColor[1] = fs->info.num_outputs;
-    compiler->OutputColor[2] = fs->info.num_outputs;
-    compiler->OutputColor[3] = fs->info.num_outputs;
-    compiler->OutputDepth = fs->info.num_outputs;
+    compiler->OutputColor[0] = shader->info.num_outputs;
+    compiler->OutputColor[1] = shader->info.num_outputs;
+    compiler->OutputColor[2] = shader->info.num_outputs;
+    compiler->OutputColor[3] = shader->info.num_outputs;
+    compiler->OutputDepth = shader->info.num_outputs;
 
     /* Now see where they really are. */
-    for(i = 0; i < fs->info.num_outputs; ++i) {
-        switch(fs->info.output_semantic_name[i]) {
+    for(i = 0; i < shader->info.num_outputs; ++i) {
+        switch(shader->info.output_semantic_name[i]) {
             case TGSI_SEMANTIC_COLOR:
                 compiler->OutputColor[colorbuf_count] = i;
                 colorbuf_count++;
@@ -128,20 +131,21 @@ static void allocate_hardware_inputs(
     }
 }
 
-static void get_compare_state(
+static void get_external_state(
     struct r300_context* r300,
-    struct r300_fragment_program_external_state* state,
-    unsigned shadow_samplers)
+    struct r300_fragment_program_external_state* state)
 {
-    struct r300_textures_state *texstate =
-        (struct r300_textures_state*)r300->textures_state.state;
-
-    memset(state, 0, sizeof(*state));
+    struct r300_textures_state *texstate = r300->textures_state.state;
+    unsigned i;
 
-    for (int i = 0; i < texstate->sampler_count; i++) {
+    for (i = 0; i < texstate->sampler_state_count; i++) {
         struct r300_sampler_state* s = texstate->sampler_states[i];
 
-        if (s && s->state.compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
+        if (!s) {
+            continue;
+        }
+
+        if (s->state.compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) {
             /* XXX Gallium doesn't provide us with any information regarding
              * this mode, so we are screwed. I'm setting 0 = LUMINANCE. */
             state->unit[i].depth_texture_mode = 0;
@@ -149,17 +153,89 @@ static void get_compare_state(
             /* Fortunately, no need to translate this. */
             state->unit[i].texture_compare_func = s->state.compare_func;
         }
+
+        state->unit[i].non_normalized_coords = !s->state.normalized_coords;
+
+        if (texstate->sampler_views[i]) {
+            struct r300_texture *t;
+            t = (struct r300_texture*)texstate->sampler_views[i]->base.texture;
+
+            /* XXX this should probably take into account STR, not just S. */
+            if (t->uses_pitch) {
+                switch (s->state.wrap_s) {
+                    case PIPE_TEX_WRAP_REPEAT:
+                        state->unit[i].wrap_mode = RC_WRAP_REPEAT;
+                        /* XXX Enable when REPEAT fallback works.
+                        state->unit[i].fake_npot = TRUE; */
+                        break;
+
+                    case PIPE_TEX_WRAP_CLAMP:
+                    case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
+                    case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
+                        state->unit[i].wrap_mode = RC_WRAP_CLAMP;
+                        break;
+
+                    case PIPE_TEX_WRAP_MIRROR_REPEAT:
+                    case PIPE_TEX_WRAP_MIRROR_CLAMP:
+                    case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
+                    case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
+                        state->unit[i].wrap_mode = RC_WRAP_MIRROR;
+                        state->unit[i].fake_npot = TRUE;
+                        break;
+
+                    default:
+                        state->unit[i].wrap_mode = RC_WRAP_NONE;
+                        break;
+                }
+            }
+        }
     }
 }
 
 static void r300_translate_fragment_shader(
     struct r300_context* r300,
+    struct r300_fragment_shader_code* shader,
+    const struct tgsi_token *tokens);
+
+static void r300_dummy_fragment_shader(
+    struct r300_context* r300,
     struct r300_fragment_shader_code* shader)
 {
-    struct r300_fragment_shader* fs = r300->fs;
+    struct pipe_shader_state state;
+    struct ureg_program *ureg;
+    struct ureg_dst out;
+    struct ureg_src imm;
+
+    /* Make a simple fragment shader which outputs (0, 0, 0, 1) */
+    ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
+    out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
+    imm = ureg_imm4f(ureg, 0, 0, 0, 1);
+
+    ureg_MOV(ureg, out, imm);
+    ureg_END(ureg);
+
+    state.tokens = ureg_finalize(ureg);
+
+    shader->dummy = TRUE;
+    r300_translate_fragment_shader(r300, shader, state.tokens);
+
+    ureg_destroy(ureg);
+}
+
+static void r300_translate_fragment_shader(
+    struct r300_context* r300,
+    struct r300_fragment_shader_code* shader,
+    const struct tgsi_token *tokens)
+{
     struct r300_fragment_program_compiler compiler;
     struct tgsi_to_rc ttr;
-    int wpos = fs->inputs.wpos;
+    int wpos;
+    unsigned i;
+
+    tgsi_scan_shader(tokens, &shader->info);
+    r300_shader_read_fs_inputs(&shader->info, &shader->inputs);
+
+    wpos = shader->inputs.wpos;
 
     /* Setup the compiler. */
     memset(&compiler, 0, sizeof(compiler));
@@ -168,25 +244,24 @@ static void r300_translate_fragment_shader(
 
     compiler.code = &shader->code;
     compiler.state = shader->compare_state;
-    compiler.is_r500 = r300_screen(r300->context.screen)->caps->is_r500;
+    compiler.is_r500 = r300->screen->caps.is_r500;
+    compiler.max_temp_regs = compiler.is_r500 ? 128 : 32;
     compiler.AllocateHwInputs = &allocate_hardware_inputs;
-    compiler.UserData = &fs->inputs;
+    compiler.UserData = &shader->inputs;
 
-    find_output_registers(&compiler, fs);
+    find_output_registers(&compiler, shader);
 
     if (compiler.Base.Debug) {
         debug_printf("r300: Initial fragment program\n");
-        tgsi_dump(fs->state.tokens, 0);
+        tgsi_dump(tokens, 0);
     }
 
     /* Translate TGSI to our internal representation */
     ttr.compiler = &compiler.Base;
-    ttr.info = &fs->info;
+    ttr.info = &shader->info;
     ttr.use_half_swizzles = TRUE;
 
-    r300_tgsi_to_rc(&ttr, fs->state.tokens);
-
-    fs->shadow_samplers = compiler.Base.Program.ShadowSamplers;
+    r300_tgsi_to_rc(&ttr, tokens);
 
     /**
      * Transform the program to support WPOS.
@@ -202,11 +277,47 @@ static void r300_translate_fragment_shader(
 
     /* Invoke the compiler */
     r3xx_compile_fragment_program(&compiler);
+
     if (compiler.Base.Error) {
-        /* XXX failover maybe? */
-        fprintf(stderr, "r300 FP: Compiler Error:\n%s",
-                compiler.Base.ErrorMsg);
-        abort();
+        fprintf(stderr, "r300 FP: Compiler Error:\n%sUsing a dummy shader"
+                " instead.\n", compiler.Base.ErrorMsg);
+
+        if (shader->dummy) {
+            fprintf(stderr, "r300 FP: Cannot compile the dummy shader! "
+                    "Giving up...\n");
+            abort();
+        }
+
+        rc_destroy(&compiler.Base);
+        r300_dummy_fragment_shader(r300, shader);
+        return;
+    }
+
+    /* Initialize numbers of constants for each type. */
+    shader->externals_count = ttr.immediate_offset;
+    shader->immediates_count = 0;
+    shader->rc_state_count = 0;
+
+    for (i = shader->externals_count; i < shader->code.constants.Count; i++) {
+        switch (shader->code.constants.Constants[i].Type) {
+            case RC_CONSTANT_IMMEDIATE:
+                ++shader->immediates_count;
+                break;
+            case RC_CONSTANT_STATE:
+                ++shader->rc_state_count;
+                break;
+            default:
+                assert(0);
+        }
+    }
+
+    /* Setup shader depth output. */
+    if (shader->code.writes_depth) {
+        shader->fg_depth_src = R300_FG_DEPTH_SRC_SHADER;
+        shader->us_out_w = R300_W_FMT_W24 | R300_W_SRC_US;
+    } else {
+        shader->fg_depth_src = R300_FG_DEPTH_SRC_SCAN;
+        shader->us_out_w = R300_W_FMT_W0 | R300_W_SRC_US;
     }
 
     /* And, finally... */
@@ -215,24 +326,22 @@ static void r300_translate_fragment_shader(
 
 boolean r300_pick_fragment_shader(struct r300_context* r300)
 {
-    struct r300_fragment_shader* fs = r300->fs;
-    struct r300_fragment_program_external_state state;
+    struct r300_fragment_shader* fs = r300_fs(r300);
+    struct r300_fragment_program_external_state state = {{{ 0 }}};
     struct r300_fragment_shader_code* ptr;
 
+    get_external_state(r300, &state);
+
     if (!fs->first) {
         /* Build the fragment shader for the first time. */
         fs->first = fs->shader = CALLOC_STRUCT(r300_fragment_shader_code);
 
-        /* BTW shadow samplers will be known after the first translation,
-         * therefore we set ~0, which means it should look at all sampler
-         * states. This choice doesn't have any impact on the correctness. */
-        get_compare_state(r300, &fs->shader->compare_state, ~0);
-        r300_translate_fragment_shader(r300, fs->shader);
+        memcpy(&fs->shader->compare_state, &state,
+            sizeof(struct r300_fragment_program_external_state));
+        r300_translate_fragment_shader(r300, fs->shader, fs->state.tokens);
         return TRUE;
 
-    } else if (fs->shadow_samplers) {
-        get_compare_state(r300, &state, fs->shadow_samplers);
-
+    } else {
         /* Check if the currently-bound shader has been compiled
          * with the texture-compare state we need. */
         if (memcmp(&fs->shader->compare_state, &state, sizeof(state)) != 0) {
@@ -240,8 +349,12 @@ boolean r300_pick_fragment_shader(struct r300_context* r300)
             ptr = fs->first;
             while (ptr) {
                 if (memcmp(&ptr->compare_state, &state, sizeof(state)) == 0) {
-                    fs->shader = ptr;
-                    return TRUE;
+                    if (fs->shader != ptr) {
+                        fs->shader = ptr;
+                        return TRUE;
+                    }
+                    /* The currently-bound one is OK. */
+                    return FALSE;
                 }
                 ptr = ptr->next;
             }
@@ -252,7 +365,7 @@ boolean r300_pick_fragment_shader(struct r300_context* r300)
             fs->first = fs->shader = ptr;
 
             ptr->compare_state = state;
-            r300_translate_fragment_shader(r300, ptr);
+            r300_translate_fragment_shader(r300, ptr, fs->state.tokens);
             return TRUE;
         }
     }
diff --git a/src/gallium/drivers/r300/r300_fs.h b/src/gallium/drivers/r300/r300_fs.h
index 40ce874353c..1cc43553595 100644
--- a/src/gallium/drivers/r300/r300_fs.h
+++ b/src/gallium/drivers/r300/r300_fs.h
@@ -31,6 +31,22 @@
 #include "r300_shader_semantics.h"
 
 struct r300_fragment_shader_code {
+    struct tgsi_shader_info info;
+    struct r300_shader_semantics inputs;
+
+    /* Whether the shader was replaced by a dummy one due to a shader
+     * compilation failure. */
+    boolean dummy;
+
+    /* Numbers of constants for each type. */
+    unsigned externals_count;
+    unsigned immediates_count;
+    unsigned rc_state_count;
+
+    /* Registers for fragment depth output setup. */
+    uint32_t fg_depth_src;      /* R300_FG_DEPTH_SRC: 0x4bd8 */
+    uint32_t us_out_w;          /* R300_US_W_FMT:     0x46b4 */
+
     struct r300_fragment_program_external_state compare_state;
     struct rX00_fragment_program_code code;
 
@@ -41,12 +57,6 @@ struct r300_fragment_shader {
     /* Parent class */
     struct pipe_shader_state state;
 
-    struct tgsi_shader_info info;
-    struct r300_shader_semantics inputs;
-
-    /* Bits 0-15: TRUE if it's a shadow sampler, FALSE otherwise. */
-    unsigned shadow_samplers;
-
     /* Currently-bound fragment shader. */
     struct r300_fragment_shader_code* shader;
 
diff --git a/src/gallium/drivers/r300/r300_query.c b/src/gallium/drivers/r300/r300_query.c
index f8b52d593d5..398edb9d101 100644
--- a/src/gallium/drivers/r300/r300_query.c
+++ b/src/gallium/drivers/r300/r300_query.c
@@ -36,7 +36,7 @@ static struct pipe_query *r300_create_query(struct pipe_context *pipe,
                                             unsigned query_type)
 {
     struct r300_context *r300 = r300_context(pipe);
-    struct r300_screen *r300screen = r300_screen(r300->context.screen);
+    struct r300_screen *r300screen = r300->screen;
     unsigned query_size;
     struct r300_query *q, *qptr;
 
@@ -47,10 +47,10 @@ static struct pipe_query *r300_create_query(struct pipe_context *pipe,
 
     q->active = FALSE;
 
-    if (r300screen->caps->family == CHIP_FAMILY_RV530)
-	query_size = r300screen->caps->num_z_pipes * sizeof(uint32_t);
+    if (r300screen->caps.family == CHIP_FAMILY_RV530)
+        query_size = r300screen->caps.num_z_pipes * sizeof(uint32_t);
     else
-	query_size = r300screen->caps->num_frag_pipes * sizeof(uint32_t);
+        query_size = r300screen->caps.num_frag_pipes * sizeof(uint32_t);
 
     if (!is_empty_list(&r300->query_list)) {
         qptr = last_elem(&r300->query_list);
@@ -78,21 +78,21 @@ static void r300_destroy_query(struct pipe_context* pipe,
 static void r300_begin_query(struct pipe_context* pipe,
                              struct pipe_query* query)
 {
-    uint32_t* map;
+    uint32_t value = ~0U;
     struct r300_context* r300 = r300_context(pipe);
     struct r300_query* q = (struct r300_query*)query;
 
     assert(r300->query_current == NULL);
 
-    map = pipe->screen->buffer_map(pipe->screen, r300->oqbo,
-            PIPE_BUFFER_USAGE_CPU_WRITE);
-    map += q->offset / 4;
-    *map = ~0U;
-    pipe->screen->buffer_unmap(pipe->screen, r300->oqbo);
+    pipe_buffer_write(pipe,
+		      r300->oqbo,
+		      q->offset,
+		      sizeof value,
+		      &value);
 
     q->flushed = FALSE;
     r300->query_current = q;
-    r300->dirty_state |= R300_NEW_QUERY;
+    r300->query_start.dirty = TRUE;
 }
 
 static void r300_end_query(struct pipe_context* pipe,
@@ -112,9 +112,10 @@ static boolean r300_get_query_result(struct pipe_context* pipe,
                                      uint64_t* result)
 {
     struct r300_context* r300 = r300_context(pipe);
-    struct r300_screen* r300screen = r300_screen(r300->context.screen);
+    struct r300_screen* r300screen = r300->screen;
     struct r300_query *q = (struct r300_query*)query;
-    unsigned flags = PIPE_BUFFER_USAGE_CPU_READ;
+    struct pipe_transfer *transfer;
+    unsigned flags = PIPE_TRANSFER_READ;
     uint32_t* map;
     uint32_t temp = 0;
     unsigned i, num_results;
@@ -122,18 +123,18 @@ static boolean r300_get_query_result(struct pipe_context* pipe,
     if (q->flushed == FALSE)
         pipe->flush(pipe, 0, NULL);
     if (!wait) {
-        flags |= PIPE_BUFFER_USAGE_DONTBLOCK;
+        flags |= PIPE_TRANSFER_DONTBLOCK;
     }
 
-    map = pipe->screen->buffer_map(pipe->screen, r300->oqbo, flags);
+    map = pipe_buffer_map(pipe, r300->oqbo, flags, &transfer);
     if (!map)
         return FALSE;
     map += q->offset / 4;
 
-    if (r300screen->caps->family == CHIP_FAMILY_RV530)
-        num_results = r300screen->caps->num_z_pipes;
+    if (r300screen->caps.family == CHIP_FAMILY_RV530)
+        num_results = r300screen->caps.num_z_pipes;
     else
-        num_results = r300screen->caps->num_frag_pipes;
+        num_results = r300screen->caps.num_frag_pipes;
 
     for (i = 0; i < num_results; i++) {
         if (*map == ~0U) {
@@ -148,7 +149,7 @@ static boolean r300_get_query_result(struct pipe_context* pipe,
         temp += *map;
         map++;
     }
-    pipe->screen->buffer_unmap(pipe->screen, r300->oqbo);
+    pipe_buffer_unmap(pipe, r300->oqbo, transfer);
 
     if (temp == ~0U) {
         /* Our results haven't been written yet... */
@@ -159,10 +160,33 @@ static boolean r300_get_query_result(struct pipe_context* pipe,
     return TRUE;
 }
 
+static void r300_render_condition(struct pipe_context *pipe,
+                                  struct pipe_query *query,
+                                  uint mode)
+{
+    struct r300_context *r300 = r300_context(pipe);
+    uint64_t result;
+    boolean wait;
+
+    if (query) {
+        wait = mode == PIPE_RENDER_COND_WAIT ||
+               mode == PIPE_RENDER_COND_BY_REGION_WAIT;
+
+        if (!r300_get_query_result(pipe, query, wait, &result)) {
+            r300->skip_rendering = FALSE;
+        }
+
+        r300->skip_rendering = result == 0;
+    } else {
+        r300->skip_rendering = FALSE;
+    }
+}
+
 void r300_init_query_functions(struct r300_context* r300) {
     r300->context.create_query = r300_create_query;
     r300->context.destroy_query = r300_destroy_query;
     r300->context.begin_query = r300_begin_query;
     r300->context.end_query = r300_end_query;
     r300->context.get_query_result = r300_get_query_result;
+    r300->context.render_condition = r300_render_condition;
 }
diff --git a/src/gallium/drivers/r300/r300_reg.h b/src/gallium/drivers/r300/r300_reg.h
index 0d6b7654f30..239f91443f2 100644
--- a/src/gallium/drivers/r300/r300_reg.h
+++ b/src/gallium/drivers/r300/r300_reg.h
@@ -1543,7 +1543,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #	define R300_TX_FORMAT_DXT1	    	    0xF
 #	define R300_TX_FORMAT_DXT3	    	    0x10
 #	define R300_TX_FORMAT_DXT5	    	    0x11
-#	define R300_TX_FORMAT_Y8           	    0x12
+#	define R300_TX_FORMAT_CxV8U8           	    0x12
 #	define R300_TX_FORMAT_AVYU444 	    	    0x13
 #	define R300_TX_FORMAT_VYUY422  	    	    0x14
 #	define R300_TX_FORMAT_YVYU422  	    	    0x15
@@ -1740,6 +1740,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_PFS_CNTL_TEX_OFFSET_MASK     (31 << 13)
 #       define R300_PFS_CNTL_TEX_END_SHIFT       18
 #       define R300_PFS_CNTL_TEX_END_MASK        (31 << 18)
+#       define R400_PFS_CNTL_TEX_OFFSET_MSB_SHIFT 24
+#       define R400_PFS_CNTL_TEX_OFFSET_MSB_MASK (0xf << 24)
+#       define R400_PFS_CNTL_TEX_END_MSB_SHIFT   28
+#       define R400_PFS_CNTL_TEX_END_MSB_MASK    (0xf << 28)
 
 /* gap */
 
@@ -1764,6 +1768,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_TEX_SIZE_MASK           (31 << 17)
 #	define R300_RGBA_OUT                (1 << 22)
 #	define R300_W_OUT                   (1 << 23)
+#       define R400_TEX_START_MSB_SHIFT     24
+#       define R400_TEX_START_MSG_MASK      (0xf << 24)
+#       define R400_TEX_SIZE_MSB_SHIFT      28
+#       define R400_TEX_SIZE_MSG_MASK       (0xf << 28)
 
 /* TEX
  * As far as I can tell, texture instructions cannot write into output
@@ -1784,6 +1792,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #		define R300_TEX_OP_TXP	        3
 #		define R300_TEX_OP_TXB	        4
 #	define R300_TEX_INST_MASK               (7 << 15)
+#      define R400_SRC_ADDR_EXT_BIT         (1 << 19)
+#      define R400_DST_ADDR_EXT_BIT         (1 << 20)
 
 /* Output format from the unfied shader */
 #define R300_US_OUT_FMT_0                   0x46A4
@@ -2092,6 +2102,43 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #       define R300_ALU_OUTA_CLAMP              (1 << 30)
 /* END: Fragment program instruction set */
 
+/* R4xx extended fragment shader registers. */
+#define R400_US_ALU_EXT_ADDR_0              0x4ac0 /* up to 63 (0x4bbc) */
+#   define R400_ADDR0_EXT_RGB_MSB_BIT       0x01
+#   define R400_ADDR1_EXT_RGB_MSB_BIT       0x02
+#   define R400_ADDR2_EXT_RGB_MSB_BIT       0x04
+#   define R400_ADDRD_EXT_RGB_MSB_BIT       0x08
+#   define R400_ADDR0_EXT_A_MSB_BIT         0x10
+#   define R400_ADDR1_EXT_A_MSB_BIT         0x20
+#   define R400_ADDR2_EXT_A_MSB_BIT         0x40
+#   define R400_ADDRD_EXT_A_MSB_BIT         0x80
+#define R400_US_CODE_BANK                   0x46b8
+#   define R400_BANK_SHIFT                  0
+#   define R400_BANK_MASK                   0xf
+#   define R400_R390_MODE_ENABLE            (1 << 4)
+#define R400_US_CODE_EXT                    0x46bc
+#   define R400_ALU_OFFSET_MSB_SHIFT        0
+#   define R400_ALU_OFFSET_MSB_MASK         (0x7 << 0)
+#   define R400_ALU_SIZE_MSB_SHIFT          3
+#   define R400_ALU_SIZE_MSB_MASK           (0x7 << 3)
+#   define R400_ALU_START0_MSB_SHIFT        6
+#   define R400_ALU_START0_MSB_MASK         (0x7 << 6)
+#   define R400_ALU_SIZE0_MSB_SHIFT         9
+#   define R400_ALU_SIZE0_MSB_MASK          (0x7 << 9)
+#   define R400_ALU_START1_MSB_SHIFT        12
+#   define R400_ALU_START1_MSB_MASK         (0x7 << 12)
+#   define R400_ALU_SIZE1_MSB_SHIFT         15
+#   define R400_ALU_SIZE1_MSB_MASK          (0x7 << 15)
+#   define R400_ALU_START2_MSB_SHIFT        18
+#   define R400_ALU_START2_MSB_MASK         (0x7 << 18)
+#   define R400_ALU_SIZE2_MSB_SHIFT         21
+#   define R400_ALU_SIZE2_MSB_MASK          (0x7 << 21)
+#   define R400_ALU_START3_MSB_SHIFT        24
+#   define R400_ALU_START3_MSB_MASK         (0x7 << 24)
+#   define R400_ALU_SIZE3_MSB_SHIFT         27
+#   define R400_ALU_SIZE3_MSB_MASK          (0x7 << 27)
+/* END: R4xx extended fragment shader registers. */
+
 /* Fog: Fog Blending Enable */
 #define R300_FG_FOG_BLEND                             0x4bc0
 #       define R300_FG_FOG_BLEND_DISABLE              (0 << 0)
@@ -3290,7 +3337,6 @@ enum {
 #   define R300_W_SRC_US				(0 << 2)
 #   define R300_W_SRC_RAS				(1 << 2)
 
-
 /* Draw a primitive from vertex data in arrays loaded via 3D_LOAD_VBPNTR.
  * Two parameter dwords:
  * 0. VAP_VTX_FMT: The first parameter is not written to hardware
diff --git a/src/gallium/drivers/r300/r300_render.c b/src/gallium/drivers/r300/r300_render.c
index 1fb7eac2b34..751a7e6d5bd 100644
--- a/src/gallium/drivers/r300/r300_render.c
+++ b/src/gallium/drivers/r300/r300_render.c
@@ -152,7 +152,9 @@ static boolean immd_is_good_idea(struct r300_context *r300,
         if (!checked[vbi]) {
             vbuf = &r300->vertex_buffer[vbi];
 
-            if (r300_buffer_is_referenced(r300, vbuf->buffer)) {
+            if (r300->context.is_resource_referenced(&r300->context,
+						     vbuf->buffer,
+						     0, 0)) {
                 /* It's a very bad idea to map it... */
                 return FALSE;
             }
@@ -162,10 +164,15 @@ static boolean immd_is_good_idea(struct r300_context *r300,
     return TRUE;
 }
 
-static void r300_emit_draw_arrays_immediate(struct r300_context *r300,
-                                            unsigned mode,
-                                            unsigned start,
-                                            unsigned count)
+/*****************************************************************************
+ * The emission of draw packets for r500. Older GPUs may use these functions *
+ * after resolving fallback issues (e.g. stencil ref two-sided).             *
+ ****************************************************************************/
+
+void r500_emit_draw_arrays_immediate(struct r300_context *r300,
+                                     unsigned mode,
+                                     unsigned start,
+                                     unsigned count)
 {
     struct pipe_vertex_element* velem;
     struct pipe_vertex_buffer* vbuf;
@@ -187,6 +194,7 @@ static void r300_emit_draw_arrays_immediate(struct r300_context *r300,
 
     /* Mapped vertex buffers. */
     uint32_t* map[PIPE_MAX_ATTRIBS] = {0};
+    struct pipe_transfer* transfer[PIPE_MAX_ATTRIBS] = {NULL};
 
     CS_LOCALS(r300);
 
@@ -201,9 +209,10 @@ static void r300_emit_draw_arrays_immediate(struct r300_context *r300,
         /* Map the buffer. */
         if (!map[vbi]) {
             vbuf = &r300->vertex_buffer[vbi];
-            map[vbi] = (uint32_t*)pipe_buffer_map(r300->context.screen,
+            map[vbi] = (uint32_t*)pipe_buffer_map(&r300->context,
                                                   vbuf->buffer,
-                                                  PIPE_BUFFER_USAGE_CPU_READ);
+                                                  PIPE_TRANSFER_READ,
+						  &transfer[vbi]);
             map[vbi] += vbuf->buffer_offset / 4;
             stride[vbi] = vbuf->stride / 4;
         }
@@ -246,15 +255,15 @@ static void r300_emit_draw_arrays_immediate(struct r300_context *r300,
 
         if (map[vbi]) {
             vbuf = &r300->vertex_buffer[vbi];
-            pipe_buffer_unmap(r300->context.screen, vbuf->buffer);
+            pipe_buffer_unmap(&r300->context, vbuf->buffer, transfer[vbi]);
             map[vbi] = NULL;
         }
     }
 }
 
-static void r300_emit_draw_arrays(struct r300_context *r300,
-                                  unsigned mode,
-                                  unsigned count)
+void r500_emit_draw_arrays(struct r300_context *r300,
+                           unsigned mode,
+                           unsigned count)
 {
 #if defined(ENABLE_ALT_NUM_VERTS)
     boolean alt_num_verts = count > 65535;
@@ -264,7 +273,11 @@ static void r300_emit_draw_arrays(struct r300_context *r300,
     CS_LOCALS(r300);
 
     if (alt_num_verts) {
-        assert(count < (1 << 24));
+        if (count >= (1 << 24)) {
+            fprintf(stderr, "r300: Got a huge number of vertices: %i, "
+                    "refusing to render.\n", count);
+            return;
+        }
         BEGIN_CS(9);
         OUT_CS_REG(R500_VAP_ALT_NUM_VERTICES, count);
     } else {
@@ -282,14 +295,14 @@ static void r300_emit_draw_arrays(struct r300_context *r300,
     END_CS;
 }
 
-static void r300_emit_draw_elements(struct r300_context *r300,
-                                    struct pipe_buffer* indexBuffer,
-                                    unsigned indexSize,
-                                    unsigned minIndex,
-                                    unsigned maxIndex,
-                                    unsigned mode,
-                                    unsigned start,
-                                    unsigned count)
+void r500_emit_draw_elements(struct r300_context *r300,
+                             struct pipe_resource* indexBuffer,
+                             unsigned indexSize,
+                             unsigned minIndex,
+                             unsigned maxIndex,
+                             unsigned mode,
+                             unsigned start,
+                             unsigned count)
 {
     uint32_t count_dwords;
     uint32_t offset_dwords = indexSize * start / sizeof(uint32_t);
@@ -300,7 +313,11 @@ static void r300_emit_draw_elements(struct r300_context *r300,
 #endif
     CS_LOCALS(r300);
 
-    assert(count < (1 << 24));
+    if (count >= (1 << 24)) {
+        fprintf(stderr, "r300: Got a huge number of vertices: %i, "
+                "refusing to render.\n", count);
+        return;
+    }
 
     maxIndex = MIN2(maxIndex, r300->vertex_buffer_max_index);
 
@@ -347,25 +364,123 @@ static void r300_emit_draw_elements(struct r300_context *r300,
     END_CS;
 }
 
+/*****************************************************************************
+ * The emission of draw packets for r300 which take care of the two-sided    *
+ * stencil ref fallback and call r500's functions.                           *
+ ****************************************************************************/
+
+/* Set drawing for front faces. */
+static void r300_begin_stencil_ref_fallback(struct r300_context *r300)
+{
+    struct r300_rs_state *rs = (struct r300_rs_state*)r300->rs_state.state;
+    CS_LOCALS(r300);
+
+    BEGIN_CS(2);
+    OUT_CS_REG(R300_SU_CULL_MODE, rs->cull_mode | R300_CULL_BACK);
+    END_CS;
+}
+
+/* Set drawing for back faces. */
+static void r300_switch_stencil_ref_side(struct r300_context *r300)
+{
+    struct r300_rs_state *rs = (struct r300_rs_state*)r300->rs_state.state;
+    struct r300_dsa_state *dsa = (struct r300_dsa_state*)r300->dsa_state.state;
+    CS_LOCALS(r300);
+
+    BEGIN_CS(4);
+    OUT_CS_REG(R300_SU_CULL_MODE, rs->cull_mode | R300_CULL_FRONT);
+    OUT_CS_REG(R300_ZB_STENCILREFMASK,
+               dsa->stencil_ref_bf | r300->stencil_ref.ref_value[1]);
+    END_CS;
+}
+
+/* Restore the original state. */
+static void r300_end_stencil_ref_fallback(struct r300_context *r300)
+{
+    struct r300_rs_state *rs = (struct r300_rs_state*)r300->rs_state.state;
+    struct r300_dsa_state *dsa = (struct r300_dsa_state*)r300->dsa_state.state;
+    CS_LOCALS(r300);
+
+    BEGIN_CS(4);
+    OUT_CS_REG(R300_SU_CULL_MODE, rs->cull_mode);
+    OUT_CS_REG(R300_ZB_STENCILREFMASK,
+               dsa->stencil_ref_mask | r300->stencil_ref.ref_value[0]);
+    END_CS;
+}
+
+void r300_emit_draw_arrays_immediate(struct r300_context *r300,
+                                     unsigned mode,
+                                     unsigned start,
+                                     unsigned count)
+{
+    if (!r300->stencil_ref_bf_fallback) {
+        r500_emit_draw_arrays_immediate(r300, mode, start, count);
+    } else {
+        r300_begin_stencil_ref_fallback(r300);
+        r500_emit_draw_arrays_immediate(r300, mode, start, count);
+        r300_switch_stencil_ref_side(r300);
+        r500_emit_draw_arrays_immediate(r300, mode, start, count);
+        r300_end_stencil_ref_fallback(r300);
+    }
+}
+
+void r300_emit_draw_arrays(struct r300_context *r300,
+                           unsigned mode,
+                           unsigned count)
+{
+    if (!r300->stencil_ref_bf_fallback) {
+        r500_emit_draw_arrays(r300, mode, count);
+    } else {
+        r300_begin_stencil_ref_fallback(r300);
+        r500_emit_draw_arrays(r300, mode, count);
+        r300_switch_stencil_ref_side(r300);
+        r500_emit_draw_arrays(r300, mode, count);
+        r300_end_stencil_ref_fallback(r300);
+    }
+}
+
+void r300_emit_draw_elements(struct r300_context *r300,
+                             struct pipe_resource* indexBuffer,
+                             unsigned indexSize,
+                             unsigned minIndex,
+                             unsigned maxIndex,
+                             unsigned mode,
+                             unsigned start,
+                             unsigned count)
+{
+    if (!r300->stencil_ref_bf_fallback) {
+        r500_emit_draw_elements(r300, indexBuffer, indexSize, minIndex,
+                                maxIndex, mode, start, count);
+    } else {
+        r300_begin_stencil_ref_fallback(r300);
+        r500_emit_draw_elements(r300, indexBuffer, indexSize, minIndex,
+                                maxIndex, mode, start, count);
+        r300_switch_stencil_ref_side(r300);
+        r500_emit_draw_elements(r300, indexBuffer, indexSize, minIndex,
+                                maxIndex, mode, start, count);
+        r300_end_stencil_ref_fallback(r300);
+    }
+}
+
 static void r300_shorten_ubyte_elts(struct r300_context* r300,
-                                    struct pipe_buffer** elts,
+                                    struct pipe_resource** elts,
                                     unsigned start,
                                     unsigned count)
 {
+    struct pipe_context* context = &r300->context;
     struct pipe_screen* screen = r300->context.screen;
-    struct pipe_buffer* new_elts;
+    struct pipe_resource* new_elts;
     unsigned char *in_map;
     unsigned short *out_map;
+    struct pipe_transfer *src_transfer, *dst_transfer;
     unsigned i;
 
-    new_elts = screen->buffer_create(screen, 32,
-                                     PIPE_BUFFER_USAGE_INDEX |
-                                     PIPE_BUFFER_USAGE_CPU_WRITE |
-                                     PIPE_BUFFER_USAGE_GPU_READ,
-                                     2 * count);
+    new_elts = pipe_buffer_create(screen,
+				  PIPE_BIND_INDEX_BUFFER,
+				  2 * count);
 
-    in_map = pipe_buffer_map(screen, *elts, PIPE_BUFFER_USAGE_CPU_READ);
-    out_map = pipe_buffer_map(screen, new_elts, PIPE_BUFFER_USAGE_CPU_WRITE);
+    in_map = pipe_buffer_map(context, *elts, PIPE_TRANSFER_READ, &src_transfer);
+    out_map = pipe_buffer_map(context, new_elts, PIPE_TRANSFER_WRITE, &dst_transfer);
 
     in_map += start;
 
@@ -375,41 +490,43 @@ static void r300_shorten_ubyte_elts(struct r300_context* r300,
         out_map++;
     }
 
-    pipe_buffer_unmap(screen, *elts);
-    pipe_buffer_unmap(screen, new_elts);
+    pipe_buffer_unmap(context, *elts, src_transfer);
+    pipe_buffer_unmap(context, new_elts, dst_transfer);
 
     *elts = new_elts;
 }
 
 static void r300_align_ushort_elts(struct r300_context *r300,
-                                   struct pipe_buffer **elts,
+                                   struct pipe_resource **elts,
                                    unsigned start, unsigned count)
 {
-    struct pipe_screen* screen = r300->context.screen;
-    struct pipe_buffer* new_elts;
+    struct pipe_context* context = &r300->context;
+    struct pipe_transfer *in_transfer = NULL;
+    struct pipe_transfer *out_transfer = NULL;
+    struct pipe_resource* new_elts;
     unsigned short *in_map;
     unsigned short *out_map;
 
-    new_elts = screen->buffer_create(screen, 32,
-                                     PIPE_BUFFER_USAGE_INDEX |
-                                     PIPE_BUFFER_USAGE_CPU_WRITE |
-                                     PIPE_BUFFER_USAGE_GPU_READ,
-                                     2 * count);
+    new_elts = pipe_buffer_create(context->screen,
+				  PIPE_BIND_INDEX_BUFFER,
+				  2 * count);
 
-    in_map = pipe_buffer_map(screen, *elts, PIPE_BUFFER_USAGE_CPU_READ);
-    out_map = pipe_buffer_map(screen, new_elts, PIPE_BUFFER_USAGE_CPU_WRITE);
+    in_map = pipe_buffer_map(context, *elts,
+			     PIPE_TRANSFER_READ, &in_transfer);
+    out_map = pipe_buffer_map(context, new_elts,
+			      PIPE_TRANSFER_WRITE, &out_transfer);
 
     memcpy(out_map, in_map+start, 2 * count);
 
-    pipe_buffer_unmap(screen, *elts);
-    pipe_buffer_unmap(screen, new_elts);
+    pipe_buffer_unmap(context, *elts, in_transfer);
+    pipe_buffer_unmap(context, new_elts, out_transfer);
 
     *elts = new_elts;
 }
 
 /* This is the fast-path drawing & emission for HW TCL. */
 void r300_draw_range_elements(struct pipe_context* pipe,
-                              struct pipe_buffer* indexBuffer,
+                              struct pipe_resource* indexBuffer,
                               unsigned indexSize,
                               unsigned minIndex,
                               unsigned maxIndex,
@@ -418,15 +535,19 @@ void r300_draw_range_elements(struct pipe_context* pipe,
                               unsigned count)
 {
     struct r300_context* r300 = r300_context(pipe);
-    struct pipe_buffer* orgIndexBuffer = indexBuffer;
+    struct pipe_resource* orgIndexBuffer = indexBuffer;
 #if defined(ENABLE_ALT_NUM_VERTS)
-    boolean alt_num_verts = r300_screen(pipe->screen)->caps->is_r500 &&
+    boolean alt_num_verts = r300->screen->caps.is_r500 &&
                             count > 65536;
 #else
     boolean alt_num_verts = FALSE;
 #endif
     unsigned short_count;
 
+    if (r300->skip_rendering) {
+        return;
+    }
+
     if (!u_trim_pipe_prim(mode, &count)) {
         return;
     }
@@ -453,13 +574,13 @@ void r300_draw_range_elements(struct pipe_context* pipe,
     u_upload_flush(r300->upload_vb);
     u_upload_flush(r300->upload_ib);
     if (alt_num_verts || count <= 65535) {
-        r300_emit_draw_elements(r300, indexBuffer, indexSize, minIndex,
-                                maxIndex, mode, start, count);
+        r300->emit_draw_elements(r300, indexBuffer, indexSize, minIndex,
+                                 maxIndex, mode, start, count);
     } else {
         do {
             short_count = MIN2(count, 65534);
-            r300_emit_draw_elements(r300, indexBuffer, indexSize, minIndex,
-                                    maxIndex, mode, start, short_count);
+            r300->emit_draw_elements(r300, indexBuffer, indexSize, minIndex,
+                                      maxIndex, mode, start, short_count);
 
             start += short_count;
             count -= short_count;
@@ -474,13 +595,13 @@ void r300_draw_range_elements(struct pipe_context* pipe,
     }
 
     if (indexBuffer != orgIndexBuffer) {
-        pipe_buffer_reference( &indexBuffer, NULL );
+        pipe_resource_reference( &indexBuffer, NULL );
     }
 }
 
 /* Simple helpers for context setup. Should probably be moved to util. */
 void r300_draw_elements(struct pipe_context* pipe,
-                        struct pipe_buffer* indexBuffer,
+                        struct pipe_resource* indexBuffer,
                         unsigned indexSize, unsigned mode,
                         unsigned start, unsigned count)
 {
@@ -496,13 +617,17 @@ void r300_draw_arrays(struct pipe_context* pipe, unsigned mode,
 {
     struct r300_context* r300 = r300_context(pipe);
 #if defined(ENABLE_ALT_NUM_VERTS)
-    boolean alt_num_verts = r300_screen(pipe->screen)->caps->is_r500 &&
+    boolean alt_num_verts = r300->screen->caps.is_r500 &&
                             count > 65536;
 #else
     boolean alt_num_verts = FALSE;
 #endif
     unsigned short_count;
 
+    if (r300->skip_rendering) {
+        return;
+    }
+
     if (!u_trim_pipe_prim(mode, &count)) {
         return;
     }
@@ -510,7 +635,7 @@ void r300_draw_arrays(struct pipe_context* pipe, unsigned mode,
     r300_update_derived_state(r300);
 
     if (immd_is_good_idea(r300, count)) {
-        r300_emit_draw_arrays_immediate(r300, mode, start, count);
+        r300->emit_draw_arrays_immediate(r300, mode, start, count);
     } else {
         /* Make sure there are at least 128 spare dwords in the command buffer.
          * (most of it being consumed by emit_aos) */
@@ -520,12 +645,12 @@ void r300_draw_arrays(struct pipe_context* pipe, unsigned mode,
 
         if (alt_num_verts || count <= 65535) {
             r300_emit_aos(r300, start);
-            r300_emit_draw_arrays(r300, mode, count);
+            r300->emit_draw_arrays(r300, mode, count);
         } else {
             do {
                 short_count = MIN2(count, 65535);
                 r300_emit_aos(r300, start);
-                r300_emit_draw_arrays(r300, mode, short_count);
+                r300->emit_draw_arrays(r300, mode, short_count);
 
                 start += short_count;
                 count -= short_count;
@@ -554,16 +679,22 @@ void r300_swtcl_draw_arrays(struct pipe_context* pipe,
                                unsigned count)
 {
     struct r300_context* r300 = r300_context(pipe);
+    struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
     int i;
 
+    if (r300->skip_rendering) {
+        return;
+    }
+
     if (!u_trim_pipe_prim(mode, &count)) {
         return;
     }
 
     for (i = 0; i < r300->vertex_buffer_count; i++) {
-        void* buf = pipe_buffer_map(pipe->screen,
+        void* buf = pipe_buffer_map(pipe,
                                     r300->vertex_buffer[i].buffer,
-                                    PIPE_BUFFER_USAGE_CPU_READ);
+                                    PIPE_TRANSFER_READ,
+				    &vb_transfer[i]);
         draw_set_mapped_vertex_buffer(r300->draw, i, buf);
     }
 
@@ -572,14 +703,15 @@ void r300_swtcl_draw_arrays(struct pipe_context* pipe,
     draw_arrays(r300->draw, mode, start, count);
 
     for (i = 0; i < r300->vertex_buffer_count; i++) {
-        pipe_buffer_unmap(pipe->screen, r300->vertex_buffer[i].buffer);
+        pipe_buffer_unmap(pipe, r300->vertex_buffer[i].buffer,
+			  vb_transfer[i]);
         draw_set_mapped_vertex_buffer(r300->draw, i, NULL);
     }
 }
 
 /* SW TCL elements, using Draw. */
 void r300_swtcl_draw_range_elements(struct pipe_context* pipe,
-                                       struct pipe_buffer* indexBuffer,
+                                       struct pipe_resource* indexBuffer,
                                        unsigned indexSize,
                                        unsigned minIndex,
                                        unsigned maxIndex,
@@ -588,33 +720,42 @@ void r300_swtcl_draw_range_elements(struct pipe_context* pipe,
                                        unsigned count)
 {
     struct r300_context* r300 = r300_context(pipe);
+    struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
+    struct pipe_transfer *ib_transfer;
     int i;
     void* indices;
 
+    if (r300->skip_rendering) {
+        return;
+    }
+
     if (!u_trim_pipe_prim(mode, &count)) {
         return;
     }
 
     for (i = 0; i < r300->vertex_buffer_count; i++) {
-        void* buf = pipe_buffer_map(pipe->screen,
+        void* buf = pipe_buffer_map(pipe,
                                     r300->vertex_buffer[i].buffer,
-                                    PIPE_BUFFER_USAGE_CPU_READ);
+                                    PIPE_TRANSFER_READ,
+				    &vb_transfer[i]);
         draw_set_mapped_vertex_buffer(r300->draw, i, buf);
     }
 
-    indices = pipe_buffer_map(pipe->screen, indexBuffer,
-                              PIPE_BUFFER_USAGE_CPU_READ);
+    indices = pipe_buffer_map(pipe, indexBuffer,
+                              PIPE_TRANSFER_READ, &ib_transfer);
     draw_set_mapped_element_buffer_range(r300->draw, indexSize,
                                          minIndex, maxIndex, indices);
 
     draw_arrays(r300->draw, mode, start, count);
 
     for (i = 0; i < r300->vertex_buffer_count; i++) {
-        pipe_buffer_unmap(pipe->screen, r300->vertex_buffer[i].buffer);
+        pipe_buffer_unmap(pipe, r300->vertex_buffer[i].buffer,
+			  vb_transfer[i]);
         draw_set_mapped_vertex_buffer(r300->draw, i, NULL);
     }
 
-    pipe_buffer_unmap(pipe->screen, indexBuffer);
+    pipe_buffer_unmap(pipe, indexBuffer,
+		      ib_transfer);
     draw_set_mapped_element_buffer_range(r300->draw, 0, start,
                                          start + count - 1, NULL);
 }
@@ -633,11 +774,13 @@ struct r300_render {
     unsigned hwprim;
 
     /* VBO */
-    struct pipe_buffer* vbo;
+    struct pipe_resource* vbo;
     size_t vbo_size;
     size_t vbo_offset;
     size_t vbo_max_used;
     void * vbo_ptr;
+
+   struct pipe_transfer *vbo_transfer;
 };
 
 static INLINE struct r300_render*
@@ -668,10 +811,9 @@ static boolean r300_render_allocate_vertices(struct vbuf_render* render,
 
     if (size + r300render->vbo_offset > r300render->vbo_size)
     {
-        pipe_buffer_reference(&r300->vbo, NULL);
+        pipe_resource_reference(&r300->vbo, NULL);
         r300render->vbo = pipe_buffer_create(screen,
-                                             64,
-                                             PIPE_BUFFER_USAGE_VERTEX,
+                                             PIPE_BIND_VERTEX_BUFFER,
                                              R300_MAX_DRAW_VBO_SIZE);
         r300render->vbo_offset = 0;
         r300render->vbo_size = R300_MAX_DRAW_VBO_SIZE;
@@ -687,10 +829,11 @@ static boolean r300_render_allocate_vertices(struct vbuf_render* render,
 static void* r300_render_map_vertices(struct vbuf_render* render)
 {
     struct r300_render* r300render = r300_render(render);
-    struct pipe_screen* screen = r300render->r300->context.screen;
 
-    r300render->vbo_ptr = pipe_buffer_map(screen, r300render->vbo,
-                                          PIPE_BUFFER_USAGE_CPU_WRITE);
+    r300render->vbo_ptr = pipe_buffer_map(&r300render->r300->context,
+					  r300render->vbo,
+                                          PIPE_TRANSFER_WRITE,
+					  &r300render->vbo_transfer);
 
     return ((uint8_t*)r300render->vbo_ptr + r300render->vbo_offset);
 }
@@ -700,7 +843,7 @@ static void r300_render_unmap_vertices(struct vbuf_render* render,
                                              ushort max)
 {
     struct r300_render* r300render = r300_render(render);
-    struct pipe_screen* screen = r300render->r300->context.screen;
+    struct pipe_context* context = &r300render->r300->context;
     CS_LOCALS(r300render->r300);
     BEGIN_CS(2);
     OUT_CS_REG(R300_VAP_VF_MAX_VTX_INDX, max);
@@ -708,7 +851,7 @@ static void r300_render_unmap_vertices(struct vbuf_render* render,
 
     r300render->vbo_max_used = MAX2(r300render->vbo_max_used,
                                     r300render->vertex_size * (max + 1));
-    pipe_buffer_unmap(screen, r300render->vbo);
+    pipe_buffer_unmap(context, r300render->vbo, r300render->vbo_transfer);
 }
 
 static void r300_render_release_vertices(struct vbuf_render* render)
@@ -730,9 +873,9 @@ static boolean r300_render_set_primitive(struct vbuf_render* render,
     return TRUE;
 }
 
-static void r300_render_draw_arrays(struct vbuf_render* render,
-                                          unsigned start,
-                                          unsigned count)
+static void r500_render_draw_arrays(struct vbuf_render* render,
+                                    unsigned start,
+                                    unsigned count)
 {
     struct r300_render* r300render = r300_render(render);
     struct r300_context* r300 = r300render->r300;
@@ -752,9 +895,9 @@ static void r300_render_draw_arrays(struct vbuf_render* render,
     END_CS;
 }
 
-static void r300_render_draw(struct vbuf_render* render,
-                                   const ushort* indices,
-                                   uint count)
+static void r500_render_draw(struct vbuf_render* render,
+                             const ushort* indices,
+                             uint count)
 {
     struct r300_render* r300render = r300_render(render);
     struct r300_context* r300 = r300render->r300;
@@ -780,6 +923,40 @@ static void r300_render_draw(struct vbuf_render* render,
     END_CS;
 }
 
+static void r300_render_draw_arrays(struct vbuf_render* render,
+                                    unsigned start,
+                                    unsigned count)
+{
+    struct r300_context* r300 = r300_render(render)->r300;
+
+    if (!r300->stencil_ref_bf_fallback) {
+        r500_render_draw_arrays(render, start, count);
+    } else {
+        r300_begin_stencil_ref_fallback(r300);
+        r500_render_draw_arrays(render, start, count);
+        r300_switch_stencil_ref_side(r300);
+        r500_render_draw_arrays(render, start, count);
+        r300_end_stencil_ref_fallback(r300);
+    }
+}
+
+static void r300_render_draw(struct vbuf_render* render,
+                             const ushort* indices,
+                             uint count)
+{
+    struct r300_context* r300 = r300_render(render)->r300;
+
+    if (!r300->stencil_ref_bf_fallback) {
+        r500_render_draw(render, indices, count);
+    } else {
+        r300_begin_stencil_ref_fallback(r300);
+        r500_render_draw(render, indices, count);
+        r300_switch_stencil_ref_side(r300);
+        r500_render_draw(render, indices, count);
+        r300_end_stencil_ref_fallback(r300);
+    }
+}
+
 static void r300_render_destroy(struct vbuf_render* render)
 {
     FREE(render);
@@ -800,8 +977,13 @@ static struct vbuf_render* r300_render_create(struct r300_context* r300)
     r300render->base.map_vertices = r300_render_map_vertices;
     r300render->base.unmap_vertices = r300_render_unmap_vertices;
     r300render->base.set_primitive = r300_render_set_primitive;
-    r300render->base.draw = r300_render_draw;
-    r300render->base.draw_arrays = r300_render_draw_arrays;
+    if (r300->screen->caps.is_r500) {
+        r300render->base.draw = r500_render_draw;
+        r300render->base.draw_arrays = r500_render_draw_arrays;
+    } else {
+        r300render->base.draw = r300_render_draw;
+        r300render->base.draw_arrays = r300_render_draw_arrays;
+    }
     r300render->base.release_vertices = r300_render_release_vertices;
     r300render->base.destroy = r300_render_destroy;
 
diff --git a/src/gallium/drivers/r300/r300_render.h b/src/gallium/drivers/r300/r300_render.h
index 27b5e6a9630..b8307c84d3d 100644
--- a/src/gallium/drivers/r300/r300_render.h
+++ b/src/gallium/drivers/r300/r300_render.h
@@ -25,8 +25,44 @@
 
 uint32_t r300_translate_primitive(unsigned prim);
 
+void r500_emit_draw_arrays_immediate(struct r300_context *r300,
+                                     unsigned mode,
+                                     unsigned start,
+                                     unsigned count);
+
+void r500_emit_draw_arrays(struct r300_context *r300,
+                           unsigned mode,
+                           unsigned count);
+
+void r500_emit_draw_elements(struct r300_context *r300,
+                             struct pipe_resource* indexBuffer,
+                             unsigned indexSize,
+                             unsigned minIndex,
+                             unsigned maxIndex,
+                             unsigned mode,
+                             unsigned start,
+                             unsigned count);
+
+void r300_emit_draw_arrays_immediate(struct r300_context *r300,
+                                     unsigned mode,
+                                     unsigned start,
+                                     unsigned count);
+
+void r300_emit_draw_arrays(struct r300_context *r300,
+                           unsigned mode,
+                           unsigned count);
+
+void r300_emit_draw_elements(struct r300_context *r300,
+                             struct pipe_resource* indexBuffer,
+                             unsigned indexSize,
+                             unsigned minIndex,
+                             unsigned maxIndex,
+                             unsigned mode,
+                             unsigned start,
+                             unsigned count);
+
 void r300_draw_range_elements(struct pipe_context* pipe,
-                              struct pipe_buffer* indexBuffer,
+                              struct pipe_resource* indexBuffer,
                               unsigned indexSize,
                               unsigned minIndex,
                               unsigned maxIndex,
@@ -35,7 +71,7 @@ void r300_draw_range_elements(struct pipe_context* pipe,
                               unsigned count);
 
 void r300_draw_elements(struct pipe_context* pipe,
-                        struct pipe_buffer* indexBuffer,
+                        struct pipe_resource* indexBuffer,
                         unsigned indexSize, unsigned mode,
                         unsigned start, unsigned count);
 
@@ -48,7 +84,7 @@ void r300_swtcl_draw_arrays(struct pipe_context* pipe,
                             unsigned count);
 
 void r300_swtcl_draw_range_elements(struct pipe_context* pipe,
-                                    struct pipe_buffer* indexBuffer,
+                                    struct pipe_resource* indexBuffer,
                                     unsigned indexSize,
                                     unsigned minIndex,
                                     unsigned maxIndex,
diff --git a/src/gallium/drivers/r300/r300_resource.c b/src/gallium/drivers/r300/r300_resource.c
new file mode 100644
index 00000000000..0469b21b752
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_resource.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2010 Red Hat Inc.
+ *
+ * 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
+ * on 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
+ * THE AUTHOR(S) AND/OR THEIR 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.
+ *
+ * Authors: Dave Airlie
+ */
+#include <stdio.h>
+
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "util/u_memory.h"
+#include "util/u_upload_mgr.h"
+#include "util/u_math.h"
+
+#include "r300_context.h"
+#include "r300_texture.h"
+#include "r300_screen.h"
+#include "r300_screen_buffer.h"
+
+#include "r300_winsys.h"
+
+
+
+
+static struct pipe_resource *
+r300_resource_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template)
+{
+   if (template->target == PIPE_BUFFER)
+      return r300_buffer_create(screen, template);
+   else
+      return r300_texture_create(screen, template);
+
+}
+
+static struct pipe_resource *
+r300_resource_from_handle(struct pipe_screen * screen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle)
+{
+   if (template->target == PIPE_BUFFER)
+      return NULL;
+   else
+      return r300_texture_from_handle(screen, template, whandle);
+}
+
+
+
+void
+r300_init_resource_functions(struct r300_context *r300)
+{
+   r300->context.get_transfer = u_get_transfer_vtbl;
+   r300->context.transfer_map = u_transfer_map_vtbl;
+   r300->context.transfer_flush_region = u_transfer_flush_region_vtbl;
+   r300->context.transfer_unmap = u_transfer_unmap_vtbl;
+   r300->context.transfer_destroy = u_transfer_destroy_vtbl;
+   r300->context.transfer_inline_write = u_transfer_inline_write_vtbl;
+   r300->context.is_resource_referenced = u_is_resource_referenced_vtbl;
+}
+
+void
+r300_init_screen_resource_functions(struct r300_screen *r300screen)
+{
+   r300screen->screen.resource_create = r300_resource_create;
+   r300screen->screen.resource_from_handle = r300_resource_from_handle;
+   r300screen->screen.resource_get_handle = u_resource_get_handle_vtbl;
+   r300screen->screen.resource_destroy = u_resource_destroy_vtbl;
+   r300screen->screen.user_buffer_create = r300_user_buffer_create;
+
+   r300screen->screen.get_tex_surface = r300_get_tex_surface;
+   r300screen->screen.tex_surface_destroy = r300_tex_surface_destroy;
+}
diff --git a/src/gallium/drivers/r300/r300_screen.c b/src/gallium/drivers/r300/r300_screen.c
index 50e5e9307e9..8fc1d5aa00e 100644
--- a/src/gallium/drivers/r300/r300_screen.c
+++ b/src/gallium/drivers/r300/r300_screen.c
@@ -72,7 +72,7 @@ static const char* r300_get_name(struct pipe_screen* pscreen)
 {
     struct r300_screen* r300screen = r300_screen(pscreen);
 
-    return chip_families[r300screen->caps->family];
+    return chip_families[r300screen->caps.family];
 }
 
 static int r300_get_param(struct pipe_screen* pscreen, int param)
@@ -82,18 +82,13 @@ static int r300_get_param(struct pipe_screen* pscreen, int param)
     switch (param) {
         case PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS:
         case PIPE_CAP_MAX_COMBINED_SAMPLERS:
-            /* XXX I'm told this goes up to 16 */
-            return 8;
+            return r300screen->caps.num_tex_units;
         case PIPE_CAP_NPOT_TEXTURES:
             /* XXX enable now to get GL2.1 API,
              * figure out later how to emulate this */
             return 1;
         case PIPE_CAP_TWO_SIDED_STENCIL:
-            if (r300screen->caps->is_r500) {
-                return 1;
-            } else {
-                return 0;
-            }
+            return 1;
         case PIPE_CAP_GLSL:
             /* I'll be frank. This is a lie.
              *
@@ -126,7 +121,7 @@ static int r300_get_param(struct pipe_screen* pscreen, int param)
         case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
         case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
         case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
-            if (r300screen->caps->is_r500) {
+            if (r300screen->caps.is_r500) {
                 /* 13 == 4096 */
                 return 13;
             } else {
@@ -144,7 +139,7 @@ static int r300_get_param(struct pipe_screen* pscreen, int param)
         case PIPE_CAP_BLEND_EQUATION_SEPARATE:
             return 1;
         case PIPE_CAP_SM3:
-            if (r300screen->caps->is_r500) {
+            if (r300screen->caps.is_r500) {
                 return 1;
             } else {
                 return 0;
@@ -181,9 +176,9 @@ static float r300_get_paramf(struct pipe_screen* pscreen, int param)
         case PIPE_CAP_MAX_POINT_WIDTH_AA:
             /* The maximum dimensions of the colorbuffer are our practical
              * rendering limits. 2048 pixels should be enough for anybody. */
-            if (r300screen->caps->is_r500) {
+            if (r300screen->caps.is_r500) {
                 return 4096.0f;
-            } else if (r300screen->caps->is_r400) {
+            } else if (r300screen->caps.is_r400) {
                 return 4021.0f;
             } else {
                 return 2560.0f;
@@ -206,11 +201,14 @@ static boolean r300_is_format_supported(struct pipe_screen* screen,
                                         unsigned geom_flags)
 {
     uint32_t retval = 0;
-    boolean is_r500 = r300_screen(screen)->caps->is_r500;
-    boolean is_r400 = r300_screen(screen)->caps->is_r400;
+    boolean is_r500 = r300_screen(screen)->caps.is_r500;
+    boolean is_r400 = r300_screen(screen)->caps.is_r400;
     boolean is_z24 = format == PIPE_FORMAT_X8Z24_UNORM ||
                      format == PIPE_FORMAT_S8_USCALED_Z24_UNORM;
-    boolean is_color2101010 = format == PIPE_FORMAT_R10G10B10A2_UNORM;
+    boolean is_color2101010 = format == PIPE_FORMAT_R10G10B10A2_UNORM ||
+                              format == PIPE_FORMAT_R10G10B10X2_SNORM ||
+                              format == PIPE_FORMAT_B10G10R10A2_UNORM ||
+                              format == PIPE_FORMAT_R10SG10SB10SA2U_NORM;
     boolean is_ati1n = format == PIPE_FORMAT_RGTC1_UNORM ||
                        format == PIPE_FORMAT_RGTC1_SNORM;
     boolean is_ati2n = format == PIPE_FORMAT_RGTC2_UNORM ||
@@ -223,7 +221,7 @@ static boolean r300_is_format_supported(struct pipe_screen* screen,
     }
 
     /* Check sampler format support. */
-    if ((usage & PIPE_TEXTURE_USAGE_SAMPLER) &&
+    if ((usage & PIPE_BIND_SAMPLER_VIEW) &&
         /* Z24 cannot be sampled from on non-r5xx. */
         (is_r500 || !is_z24) &&
         /* ATI1N is r5xx-only. */
@@ -231,28 +229,28 @@ static boolean r300_is_format_supported(struct pipe_screen* screen,
         /* ATI2N is supported on r4xx-r5xx. */
         (is_r400 || is_r500 || !is_ati2n) &&
         r300_is_sampler_format_supported(format)) {
-        retval |= PIPE_TEXTURE_USAGE_SAMPLER;
+        retval |= PIPE_BIND_SAMPLER_VIEW;
     }
 
     /* Check colorbuffer format support. */
-    if ((usage & (PIPE_TEXTURE_USAGE_RENDER_TARGET |
-                  PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                  PIPE_TEXTURE_USAGE_SCANOUT |
-                  PIPE_TEXTURE_USAGE_SHARED)) &&
+    if ((usage & (PIPE_BIND_RENDER_TARGET |
+                  PIPE_BIND_DISPLAY_TARGET |
+                  PIPE_BIND_SCANOUT |
+                  PIPE_BIND_SHARED)) &&
         /* 2101010 cannot be rendered to on non-r5xx. */
         (is_r500 || !is_color2101010) &&
         r300_is_colorbuffer_format_supported(format)) {
         retval |= usage &
-            (PIPE_TEXTURE_USAGE_RENDER_TARGET |
-             PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-             PIPE_TEXTURE_USAGE_SCANOUT |
-             PIPE_TEXTURE_USAGE_SHARED);
+            (PIPE_BIND_RENDER_TARGET |
+             PIPE_BIND_DISPLAY_TARGET |
+             PIPE_BIND_SCANOUT |
+             PIPE_BIND_SHARED);
     }
 
     /* Check depth-stencil format support. */
-    if (usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL &&
+    if (usage & PIPE_BIND_DEPTH_STENCIL &&
         r300_is_zs_format_supported(format)) {
-        retval |= PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
+        retval |= PIPE_BIND_DEPTH_STENCIL;
     }
 
     return retval == usage;
@@ -266,29 +264,45 @@ static void r300_destroy_screen(struct pipe_screen* pscreen)
     if (rws)
       rws->destroy(rws);
 
-    FREE(r300screen->caps);
     FREE(r300screen);
 }
 
+static void r300_fence_reference(struct pipe_screen *screen,
+                                 struct pipe_fence_handle **ptr,
+                                 struct pipe_fence_handle *fence)
+{
+}
+
+static int r300_fence_signalled(struct pipe_screen *screen,
+                                struct pipe_fence_handle *fence,
+                                unsigned flags)
+{
+    return 0;
+}
+
+static int r300_fence_finish(struct pipe_screen *screen,
+                             struct pipe_fence_handle *fence,
+                             unsigned flags)
+{
+    return 0;
+}
+
 struct pipe_screen* r300_create_screen(struct r300_winsys_screen *rws)
 {
     struct r300_screen *r300screen = CALLOC_STRUCT(r300_screen);
-    struct r300_capabilities *caps = CALLOC_STRUCT(r300_capabilities);
 
-    if (!r300screen || !caps) {
+    if (!r300screen) {
         FREE(r300screen);
-        FREE(caps);
         return NULL;
     }
 
-    caps->pci_id = rws->get_value(rws, R300_VID_PCI_ID);
-    caps->num_frag_pipes = rws->get_value(rws, R300_VID_GB_PIPES);
-    caps->num_z_pipes = rws->get_value(rws, R300_VID_Z_PIPES);
+    r300screen->caps.pci_id = rws->get_value(rws, R300_VID_PCI_ID);
+    r300screen->caps.num_frag_pipes = rws->get_value(rws, R300_VID_GB_PIPES);
+    r300screen->caps.num_z_pipes = rws->get_value(rws, R300_VID_Z_PIPES);
 
     r300_init_debug(r300screen);
-    r300_parse_chipset(caps);
+    r300_parse_chipset(&r300screen->caps);
 
-    r300screen->caps = caps;
     r300screen->rws = rws;
     r300screen->screen.winsys = (struct pipe_winsys*)rws;
     r300screen->screen.destroy = r300_destroy_screen;
@@ -299,9 +313,12 @@ struct pipe_screen* r300_create_screen(struct r300_winsys_screen *rws)
     r300screen->screen.is_format_supported = r300_is_format_supported;
     r300screen->screen.context_create = r300_create_context;
 
-    r300_init_screen_texture_functions(&r300screen->screen);
+    r300screen->screen.fence_reference = r300_fence_reference;
+    r300screen->screen.fence_signalled = r300_fence_signalled;
+    r300screen->screen.fence_finish = r300_fence_finish;
+
+    r300_init_screen_resource_functions(r300screen);
 
-    r300_screen_init_buffer_functions(r300screen);
     return &r300screen->screen;
 }
 
diff --git a/src/gallium/drivers/r300/r300_screen.h b/src/gallium/drivers/r300/r300_screen.h
index 1cf8b7452d7..2f951c7097c 100644
--- a/src/gallium/drivers/r300/r300_screen.h
+++ b/src/gallium/drivers/r300/r300_screen.h
@@ -37,7 +37,7 @@ struct r300_screen {
     struct r300_winsys_screen *rws;
 
     /* Chipset capabilities */
-    struct r300_capabilities* caps;
+    struct r300_capabilities caps;
 
     /** Combination of DBG_xxx flags */
     unsigned debug;
@@ -89,5 +89,7 @@ static INLINE void SCREEN_DBG(struct r300_screen * screen, unsigned flags,
 
 void r300_init_debug(struct r300_screen* ctx);
 
+void r300_init_screen_resource_functions(struct r300_screen *r300screen);
+
 #endif /* R300_SCREEN_H */
 
diff --git a/src/gallium/drivers/r300/r300_screen_buffer.c b/src/gallium/drivers/r300/r300_screen_buffer.c
index a1cd48ee730..cb47ba16882 100644
--- a/src/gallium/drivers/r300/r300_screen_buffer.c
+++ b/src/gallium/drivers/r300/r300_screen_buffer.c
@@ -34,23 +34,31 @@
 
 #include "r300_winsys.h"
 
-boolean r300_buffer_is_referenced(struct r300_context *r300,
-				  struct pipe_buffer *buf)
+static unsigned r300_buffer_is_referenced(struct pipe_context *context,
+					 struct pipe_resource *buf,
+					 unsigned face, unsigned level)
 {
+    struct r300_context *r300 = r300_context(context);
     struct r300_buffer *rbuf = r300_buffer(buf);
+
     if (r300_buffer_is_user_buffer(buf))
-	return FALSE;
+ 	return PIPE_UNREFERENCED;
+
+    if (r300->rws->is_buffer_referenced(r300->rws, rbuf->buf))
+        return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
 
-    return r300->rws->is_buffer_referenced(r300->rws, rbuf->buf);
-    
+    return PIPE_UNREFERENCED;
 }
+
+/* External helper, not required to implent u_resource_vtbl:
+ */
 int r300_upload_index_buffer(struct r300_context *r300,
-			     struct pipe_buffer **index_buffer,
+			     struct pipe_resource **index_buffer,
 			     unsigned index_size,
 			     unsigned start,
 			     unsigned count)
 {
-   struct pipe_buffer *upload_buffer = NULL;
+   struct pipe_resource *upload_buffer = NULL;
    unsigned index_offset = start * index_size;
    int ret = 0;
 
@@ -68,10 +76,12 @@ int r300_upload_index_buffer(struct r300_context *r300,
     }
  done:
     //    if (upload_buffer)
-    //	pipe_buffer_reference(&upload_buffer, NULL);
+    //	pipe_resource_reference(&upload_buffer, NULL);
     return ret;
 }
 
+/* External helper, not required to implent u_resource_vtbl:
+ */
 int r300_upload_user_buffers(struct r300_context *r300)
 {
     enum pipe_error ret = PIPE_OK;
@@ -82,9 +92,9 @@ int r300_upload_user_buffers(struct r300_context *r300)
     for (i = 0; i < nr; i++) {
 
 	if (r300_buffer_is_user_buffer(r300->vertex_buffer[i].buffer)) {
-	    struct pipe_buffer *upload_buffer = NULL;
+	    struct pipe_resource *upload_buffer = NULL;
 	    unsigned offset = 0; /*r300->vertex_buffer[i].buffer_offset * 4;*/
-	    unsigned size = r300->vertex_buffer[i].buffer->size;
+	    unsigned size = r300->vertex_buffer[i].buffer->width0;
 	    unsigned upload_offset;
 	    ret = u_upload_buffer(r300->upload_vb,
 				  offset, size,
@@ -93,7 +103,7 @@ int r300_upload_user_buffers(struct r300_context *r300)
 	    if (ret)
 		return ret;
 
-	    pipe_buffer_reference(&r300->vertex_buffer[i].buffer, NULL);
+	    pipe_resource_reference(&r300->vertex_buffer[i].buffer, NULL);
 	    r300->vertex_buffer[i].buffer = upload_buffer;
 	    r300->vertex_buffer[i].buffer_offset = upload_offset;
 	}
@@ -125,70 +135,11 @@ static void r300_winsys_buffer_destroy(struct r300_screen *r300screen,
     }
 }
 
-static struct pipe_buffer *r300_buffer_create(struct pipe_screen *screen,
-					      unsigned alignment,
-					      unsigned usage,
-					      unsigned size)
-{
-    struct r300_screen *r300screen = r300_screen(screen);
-    struct r300_buffer *rbuf;
-
-    rbuf = CALLOC_STRUCT(r300_buffer);
-    if (!rbuf)
-	goto error1;
-
-    rbuf->magic = R300_BUFFER_MAGIC;
-
-    pipe_reference_init(&rbuf->base.reference, 1);
-    rbuf->base.screen = screen;
-    rbuf->base.alignment = alignment;
-    rbuf->base.usage = usage;
-    rbuf->base.size = size;
 
-    rbuf->buf = r300_winsys_buffer_create(r300screen,
-					  alignment,
-					  usage,
-					  size);
-
-    if (!rbuf->buf)
-	goto error2;
-
-    return &rbuf->base;
-error2:
-    FREE(rbuf);
-error1:
-    return NULL;
-}
-
-
-static struct pipe_buffer *r300_user_buffer_create(struct pipe_screen *screen,
-						   void *ptr,
-						   unsigned bytes)
+static void r300_buffer_destroy(struct pipe_screen *screen,
+				struct pipe_resource *buf)
 {
-    struct r300_buffer *rbuf;
-
-    rbuf = CALLOC_STRUCT(r300_buffer);
-    if (!rbuf)
-	goto no_rbuf;
-
-    rbuf->magic = R300_BUFFER_MAGIC;
-
-    pipe_reference_init(&rbuf->base.reference, 1);
-    rbuf->base.screen = screen;
-    rbuf->base.alignment = 1;
-    rbuf->base.usage = 0;
-    rbuf->base.size = bytes;
-
-    rbuf->user_buffer = ptr;
-    return &rbuf->base;
-
-no_rbuf:
-    return NULL;
-}
-
-static void r300_buffer_destroy(struct pipe_buffer *buf)
-{
-    struct r300_screen *r300screen = r300_screen(buf->screen);
+    struct r300_screen *r300screen = r300_screen(screen);
     struct r300_buffer *rbuf = r300_buffer(buf);
 
     r300_winsys_buffer_destroy(r300screen, rbuf);
@@ -197,7 +148,7 @@ static void r300_buffer_destroy(struct pipe_buffer *buf)
 
 static void *
 r300_buffer_map_range(struct pipe_screen *screen,
-		      struct pipe_buffer *buf,
+		      struct pipe_resource *buf,
 		      unsigned offset, unsigned length,
 		      unsigned usage )
 {
@@ -211,11 +162,12 @@ r300_buffer_map_range(struct pipe_screen *screen,
     if (rbuf->user_buffer)
 	return rbuf->user_buffer;
 
-    if (rbuf->base.usage & PIPE_BUFFER_USAGE_CONSTANT)
+    if (rbuf->b.b.bind & PIPE_BIND_CONSTANT_BUFFER) {
 	goto just_map;
+    }
 
     /* check if the mapping is to a range we already flushed */
-    if (usage & PIPE_BUFFER_USAGE_DISCARD) {
+    if (usage & PIPE_TRANSFER_DISCARD) {
 	for (i = 0; i < rbuf->num_ranges; i++) {
 
 	    if ((offset >= rbuf->ranges[i].start) &&
@@ -229,9 +181,9 @@ r300_buffer_map_range(struct pipe_screen *screen,
 		rbuf->num_ranges = 0;
 		rbuf->map = NULL;
 		rbuf->buf = r300_winsys_buffer_create(r300screen,
-						      rbuf->base.alignment,
-						      rbuf->base.usage,
-						      rbuf->base.size);
+						      16,
+						      rbuf->b.b.bind, /* XXX */
+						      rbuf->b.b.width0);
 		break;
 	    }
 	}
@@ -244,7 +196,7 @@ just_map:
 
 static void 
 r300_buffer_flush_mapped_range( struct pipe_screen *screen,
-				struct pipe_buffer *buf,
+				struct pipe_resource *buf,
 				unsigned offset,
 				unsigned length )
 {
@@ -254,7 +206,7 @@ r300_buffer_flush_mapped_range( struct pipe_screen *screen,
     if (rbuf->user_buffer)
 	return;
 
-    if (rbuf->base.usage & PIPE_BUFFER_USAGE_CONSTANT)
+    if (rbuf->b.b.bind & PIPE_BIND_CONSTANT_BUFFER)
 	return;
 
     /* mark the range as used */
@@ -271,44 +223,152 @@ r300_buffer_flush_mapped_range( struct pipe_screen *screen,
     rbuf->num_ranges++;
 }
 
-static void *
-r300_buffer_map(struct pipe_screen *screen,
-		struct pipe_buffer *buf,
-		unsigned usage)
+
+static void
+r300_buffer_unmap(struct pipe_screen *screen,
+		  struct pipe_resource *buf)
 {
     struct r300_screen *r300screen = r300_screen(screen);
     struct r300_winsys_screen *rws = r300screen->rws;
     struct r300_buffer *rbuf = r300_buffer(buf);
-    void *map;
 
-   if (rbuf->user_buffer)
-      return rbuf->user_buffer;
+    if (rbuf->buf) {
+        rws->buffer_unmap(rws, rbuf->buf);
+    }
+}
 
-    map = rws->buffer_map(rws, rbuf->buf, usage);
 
-    return map;
+
+
+/* As a first step, keep the original code intact, implement buffer
+ * transfers in terms of the old map/unmap functions.
+ *
+ * Utility functions for transfer create/destroy are hooked in and
+ * just record the arguments to those functions.
+ */
+static void *
+r300_buffer_transfer_map( struct pipe_context *pipe,
+			  struct pipe_transfer *transfer )
+{
+   uint8_t *map = r300_buffer_map_range( pipe->screen,
+					 transfer->resource,
+					 transfer->box.x,
+					 transfer->box.width,
+					 transfer->usage );
+   if (map == NULL)
+      return NULL;
+
+   /* map_buffer() returned a pointer to the beginning of the buffer,
+    * but transfers are expected to return a pointer to just the
+    * region specified in the box.
+    */
+   return map + transfer->box.x;
 }
 
-static void
-r300_buffer_unmap(struct pipe_screen *screen,
-		  struct pipe_buffer *buf)
+
+
+static void r300_buffer_transfer_flush_region( struct pipe_context *pipe,
+					       struct pipe_transfer *transfer,
+					       const struct pipe_box *box)
+{
+   assert(box->x + box->width <= transfer->box.width);
+
+   r300_buffer_flush_mapped_range(pipe->screen,
+				  transfer->resource,
+				  transfer->box.x + box->x,
+				  box->width);
+}
+
+static void r300_buffer_transfer_unmap( struct pipe_context *pipe,
+			    struct pipe_transfer *transfer )
+{
+   r300_buffer_unmap(pipe->screen,
+		     transfer->resource);
+}
+
+
+
+
+struct u_resource_vtbl r300_buffer_vtbl = 
+{
+   u_default_resource_get_handle,      /* get_handle */
+   r300_buffer_destroy,		     /* resource_destroy */
+   r300_buffer_is_referenced,	     /* is_buffer_referenced */
+   u_default_get_transfer,	     /* get_transfer */
+   u_default_transfer_destroy,	     /* transfer_destroy */
+   r300_buffer_transfer_map,	     /* transfer_map */
+   r300_buffer_transfer_flush_region,  /* transfer_flush_region */
+   r300_buffer_transfer_unmap,	     /* transfer_unmap */
+   u_default_transfer_inline_write   /* transfer_inline_write */
+};
+
+
+
+
+struct pipe_resource *r300_buffer_create(struct pipe_screen *screen,
+					 const struct pipe_resource *template)
 {
     struct r300_screen *r300screen = r300_screen(screen);
-    struct r300_winsys_screen *rws = r300screen->rws;
-    struct r300_buffer *rbuf = r300_buffer(buf);
+    struct r300_buffer *rbuf;
+    unsigned alignment = 16;
 
-    if (rbuf->buf) {
-        rws->buffer_unmap(rws, rbuf->buf);
-    }
+    rbuf = CALLOC_STRUCT(r300_buffer);
+    if (!rbuf)
+	goto error1;
+
+    rbuf->magic = R300_BUFFER_MAGIC;
+
+    rbuf->b.b = *template;
+    rbuf->b.vtbl = &r300_buffer_vtbl;
+    pipe_reference_init(&rbuf->b.b.reference, 1);
+    rbuf->b.b.screen = screen;
+
+    if (rbuf->b.b.bind & R300_BIND_OQBO)
+       alignment = 4096;
+
+    rbuf->buf = r300_winsys_buffer_create(r300screen,
+					  alignment,
+					  rbuf->b.b.bind,
+					  rbuf->b.b.width0);
+
+    if (!rbuf->buf)
+	goto error2;
+
+    return &rbuf->b.b;
+error2:
+    FREE(rbuf);
+error1:
+    return NULL;
 }
 
-void r300_screen_init_buffer_functions(struct r300_screen *r300screen)
+
+struct pipe_resource *r300_user_buffer_create(struct pipe_screen *screen,
+					      void *ptr,
+					      unsigned bytes,
+					      unsigned bind)
 {
-    r300screen->screen.buffer_create = r300_buffer_create;
-    r300screen->screen.user_buffer_create = r300_user_buffer_create;
-    r300screen->screen.buffer_map = r300_buffer_map;
-    r300screen->screen.buffer_map_range = r300_buffer_map_range;
-    r300screen->screen.buffer_flush_mapped_range = r300_buffer_flush_mapped_range;
-    r300screen->screen.buffer_unmap = r300_buffer_unmap;
-    r300screen->screen.buffer_destroy = r300_buffer_destroy;
+    struct r300_buffer *rbuf;
+
+    rbuf = CALLOC_STRUCT(r300_buffer);
+    if (!rbuf)
+	goto no_rbuf;
+
+    rbuf->magic = R300_BUFFER_MAGIC;
+
+    pipe_reference_init(&rbuf->b.b.reference, 1);
+    rbuf->b.vtbl = &r300_buffer_vtbl;
+    rbuf->b.b.screen = screen;
+    rbuf->b.b.format = PIPE_FORMAT_R8_UNORM;
+    rbuf->b.b._usage = PIPE_USAGE_IMMUTABLE;
+    rbuf->b.b.bind = bind;
+    rbuf->b.b.width0 = bytes;
+    rbuf->b.b.height0 = 1;
+    rbuf->b.b.depth0 = 1;
+
+    rbuf->user_buffer = ptr;
+    return &rbuf->b.b;
+
+no_rbuf:
+    return NULL;
 }
+
diff --git a/src/gallium/drivers/r300/r300_screen_buffer.h b/src/gallium/drivers/r300/r300_screen_buffer.h
index 0cf349c25cd..93009ea02fd 100644
--- a/src/gallium/drivers/r300/r300_screen_buffer.h
+++ b/src/gallium/drivers/r300/r300_screen_buffer.h
@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include "pipe/p_compiler.h"
 #include "pipe/p_state.h"
+#include "util/u_transfer.h"
 #include "r300_screen.h"
 
 #include "r300_winsys.h"
@@ -18,7 +19,7 @@ struct r300_buffer_range {
 
 struct r300_buffer
 {
-    struct pipe_buffer base;
+    struct u_resource b;
 
     uint32_t magic;
 
@@ -32,7 +33,7 @@ struct r300_buffer
 };
 
 static INLINE struct r300_buffer *
-r300_buffer(struct pipe_buffer *buffer)
+r300_buffer(struct pipe_resource *buffer)
 {
     if (buffer) {
 	assert(((struct r300_buffer *)buffer)->magic == R300_BUFFER_MAGIC);
@@ -42,13 +43,13 @@ r300_buffer(struct pipe_buffer *buffer)
 }
 
 static INLINE boolean 
-r300_buffer_is_user_buffer(struct pipe_buffer *buffer)
+r300_buffer_is_user_buffer(struct pipe_resource *buffer)
 {
     return r300_buffer(buffer)->user_buffer ? true : false;
 }
 
 static INLINE boolean r300_add_buffer(struct r300_winsys_screen *rws,
-				      struct pipe_buffer *buffer,
+				      struct pipe_resource *buffer,
 				      int rd, int wr)
 {
     struct r300_buffer *buf = r300_buffer(buffer);
@@ -67,7 +68,6 @@ static INLINE boolean r300_add_texture(struct r300_winsys_screen *rws,
     return rws->add_buffer(rws, tex->buffer, rd, wr);
 }
 
-void r300_screen_init_buffer_functions(struct r300_screen *r300screen);
 
 static INLINE void r300_buffer_write_reloc(struct r300_winsys_screen *rws,
 				      struct r300_buffer *buf,
@@ -89,11 +89,18 @@ static INLINE void r300_texture_write_reloc(struct r300_winsys_screen *rws,
 int r300_upload_user_buffers(struct r300_context *r300);
 
 int r300_upload_index_buffer(struct r300_context *r300,
-			     struct pipe_buffer **index_buffer,
+			     struct pipe_resource **index_buffer,
 			     unsigned index_size,
 			     unsigned start,
 			     unsigned count);
 
-boolean r300_buffer_is_referenced(struct r300_context *r300,
-				  struct pipe_buffer *buf);
+
+struct pipe_resource *r300_buffer_create(struct pipe_screen *screen,
+					 const struct pipe_resource *template);
+
+struct pipe_resource *r300_user_buffer_create(struct pipe_screen *screen,
+					      void *ptr,
+					      unsigned bytes,
+					      unsigned usage);
+
 #endif
diff --git a/src/gallium/drivers/r300/r300_state.c b/src/gallium/drivers/r300/r300_state.c
index 39e05583dd4..371e52d2089 100644
--- a/src/gallium/drivers/r300/r300_state.c
+++ b/src/gallium/drivers/r300/r300_state.c
@@ -32,11 +32,14 @@
 #include "pipe/p_config.h"
 
 #include "r300_context.h"
+#include "r300_emit.h"
 #include "r300_reg.h"
 #include "r300_screen.h"
 #include "r300_screen_buffer.h"
+#include "r300_state.h"
 #include "r300_state_inlines.h"
 #include "r300_fs.h"
+#include "r300_texture.h"
 #include "r300_vs.h"
 #include "r300_winsys.h"
 
@@ -219,7 +222,7 @@ static void* r300_create_blend_state(struct pipe_context* pipe,
             /* Enable reading from the colorbuffer. */
             blend->blend_control |= R300_READ_ENABLE;
 
-            if (r300_screen(r300_context(pipe)->context.screen)->caps->is_r500) {
+            if (r300screen->caps.is_r500) {
                 /* Optimization: Depending on incoming pixels, we can
                  * conditionally disable the reading in hardware... */
                 if (eqRGB != PIPE_BLEND_MIN && eqA != PIPE_BLEND_MIN &&
@@ -308,7 +311,7 @@ static void* r300_create_blend_state(struct pipe_context* pipe,
 
     /* Color channel masks for all MRTs. */
     blend->color_channel_mask = bgra_cmask(state->rt[0].colormask);
-    if (r300screen->caps->is_r500 && state->independent_blend_enable) {
+    if (r300screen->caps.is_r500 && state->independent_blend_enable) {
         if (state->rt[1].blend_enable) {
             blend->color_channel_mask |= bgra_cmask(state->rt[1].colormask) << 4;
         }
@@ -320,10 +323,17 @@ static void* r300_create_blend_state(struct pipe_context* pipe,
         }
     }
 
+    /* Neither fglrx nor classic r300 ever set this, regardless of dithering
+     * state. Since it's an optional implementation detail, we can leave it
+     * out and never dither.
+     *
+     * This could be revisited if we ever get quality or conformance hints.
+     *
     if (state->dither) {
         blend->dither = R300_RB3D_DITHER_CTL_DITHER_MODE_LUT |
-                R300_RB3D_DITHER_CTL_ALPHA_DITHER_MODE_LUT;
+                        R300_RB3D_DITHER_CTL_ALPHA_DITHER_MODE_LUT;
     }
+    */
 
     return (void*)blend;
 }
@@ -356,7 +366,6 @@ static void r300_set_blend_color(struct pipe_context* pipe,
                                  const struct pipe_blend_color* color)
 {
     struct r300_context* r300 = r300_context(pipe);
-    struct r300_screen* r300screen = r300_screen(pipe->screen);
     struct r300_blend_color_state* state =
         (struct r300_blend_color_state*)r300->blend_color_state.state;
     union util_color uc;
@@ -372,7 +381,7 @@ static void r300_set_blend_color(struct pipe_context* pipe,
         float_to_fixed10(color->color[2]) |
         (float_to_fixed10(color->color[1]) << 16);
 
-    r300->blend_color_state.size = r300screen->caps->is_r500 ? 3 : 2;
+    r300->blend_color_state.size = r300->screen->caps.is_r500 ? 3 : 2;
     r300->blend_color_state.dirty = TRUE;
 }
 
@@ -383,7 +392,7 @@ static void r300_set_clip_state(struct pipe_context* pipe,
 
     r300->clip = *state;
 
-    if (r300_screen(pipe->screen)->caps->has_tcl) {
+    if (r300->screen->caps.has_tcl) {
         memcpy(r300->clip_state.state, state, sizeof(struct pipe_clip_state));
         r300->clip_state.size = 29;
     } else {
@@ -404,8 +413,7 @@ static void*
         r300_create_dsa_state(struct pipe_context* pipe,
                               const struct pipe_depth_stencil_alpha_state* state)
 {
-    struct r300_capabilities *caps =
-        r300_screen(r300_context(pipe)->context.screen)->caps;
+    struct r300_capabilities *caps = &r300_screen(pipe->screen)->caps;
     struct r300_dsa_state* dsa = CALLOC_STRUCT(r300_dsa_state);
 
     /* Depth test setup. */
@@ -439,6 +447,8 @@ static void*
                 (state->stencil[0].writemask << R300_STENCILWRITEMASK_SHIFT);
 
         if (state->stencil[1].enabled) {
+            dsa->two_sided = TRUE;
+
             dsa->z_buffer_control |= R300_STENCIL_FRONT_BACK;
             dsa->z_stencil_control |=
             (r300_translate_depth_stencil_function(state->stencil[1].func) <<
@@ -450,14 +460,16 @@ static void*
             (r300_translate_stencil_op(state->stencil[1].zfail_op) <<
                 R300_S_BACK_ZFAIL_OP_SHIFT);
 
-            if (caps->is_r500)
-            {
+            dsa->stencil_ref_bf =
+                (state->stencil[1].valuemask << R300_STENCILMASK_SHIFT) |
+                (state->stencil[1].writemask << R300_STENCILWRITEMASK_SHIFT);
+
+            if (caps->is_r500) {
                 dsa->z_buffer_control |= R500_STENCIL_REFMASK_FRONT_BACK;
-                dsa->stencil_ref_bf =
-                    (state->stencil[1].valuemask <<
-                    R300_STENCILMASK_SHIFT) |
-                    (state->stencil[1].writemask <<
-                    R300_STENCILWRITEMASK_SHIFT);
+            } else {
+                dsa->stencil_ref_bf_fallback =
+                  (state->stencil[0].valuemask != state->stencil[1].valuemask ||
+                   state->stencil[0].writemask != state->stencil[1].writemask);
             }
         }
     }
@@ -478,13 +490,33 @@ static void*
     return (void*)dsa;
 }
 
+static void r300_update_stencil_ref_fallback_status(struct r300_context *r300)
+{
+    struct r300_dsa_state *dsa = (struct r300_dsa_state*)r300->dsa_state.state;
+
+    if (r300->screen->caps.is_r500) {
+        return;
+    }
+
+    r300->stencil_ref_bf_fallback =
+        dsa->stencil_ref_bf_fallback ||
+        (dsa->two_sided &&
+         r300->stencil_ref.ref_value[0] != r300->stencil_ref.ref_value[1]);
+}
+
 /* Bind DSA state. */
 static void r300_bind_dsa_state(struct pipe_context* pipe,
                                 void* state)
 {
     struct r300_context* r300 = r300_context(pipe);
 
+    if (!state) {
+        return;
+    }
+
     UPDATE_STATE(state, r300->dsa_state);
+
+    r300_update_stencil_ref_fallback_status(r300);
 }
 
 /* Free DSA state. */
@@ -498,8 +530,11 @@ static void r300_set_stencil_ref(struct pipe_context* pipe,
                                  const struct pipe_stencil_ref* sr)
 {
     struct r300_context* r300 = r300_context(pipe);
+
     r300->stencil_ref = *sr;
     r300->dsa_state.dirty = TRUE;
+
+    r300_update_stencil_ref_fallback_status(r300);
 }
 
 /* This switcheroo is needed just because of goddamned MACRO_SWITCH. */
@@ -522,7 +557,7 @@ static void r300_fb_update_tiling_flags(struct r300_context *r300,
             continue;
         }
 
-        tex = (struct r300_texture*)old_state->cbufs[i]->texture;
+        tex = r300_texture(old_state->cbufs[i]->texture);
 
         if (tex) {
             r300->rws->buffer_set_tiling(r300->rws, tex->buffer,
@@ -534,7 +569,7 @@ static void r300_fb_update_tiling_flags(struct r300_context *r300,
     if (old_state->zsbuf &&
         (!new_state->zsbuf ||
          old_state->zsbuf->texture != new_state->zsbuf->texture)) {
-        tex = (struct r300_texture*)old_state->zsbuf->texture;
+        tex = r300_texture(old_state->zsbuf->texture);
 
         if (tex) {
             r300->rws->buffer_set_tiling(r300->rws, tex->buffer,
@@ -546,7 +581,7 @@ static void r300_fb_update_tiling_flags(struct r300_context *r300,
 
     /* Set tiling flags for new surfaces. */
     for (i = 0; i < new_state->nr_cbufs; i++) {
-        tex = (struct r300_texture*)new_state->cbufs[i]->texture;
+        tex = r300_texture(new_state->cbufs[i]->texture);
         level = new_state->cbufs[i]->level;
 
         r300->rws->buffer_set_tiling(r300->rws, tex->buffer,
@@ -555,7 +590,7 @@ static void r300_fb_update_tiling_flags(struct r300_context *r300,
                                         tex->mip_macrotile[level]);
     }
     if (new_state->zsbuf) {
-        tex = (struct r300_texture*)new_state->zsbuf->texture;
+        tex = r300_texture(new_state->zsbuf->texture);
         level = new_state->zsbuf->level;
 
         r300->rws->buffer_set_tiling(r300->rws, tex->buffer,
@@ -570,7 +605,6 @@ static void
                                const struct pipe_framebuffer_state* state)
 {
     struct r300_context* r300 = r300_context(pipe);
-    struct r300_screen* r300screen = r300_screen(pipe->screen);
     struct pipe_framebuffer_state *old_state = r300->fb_state.state;
     unsigned max_width, max_height;
     uint32_t zbuffer_bpp = 0;
@@ -581,9 +615,9 @@ static void
         return;
     }
 
-    if (r300screen->caps->is_r500) {
+    if (r300->screen->caps.is_r500) {
         max_width = max_height = 4096;
-    } else if (r300screen->caps->is_r400) {
+    } else if (r300->screen->caps.is_r400) {
         max_width = max_height = 4021;
     } else {
         max_width = max_height = 2560;
@@ -609,16 +643,13 @@ static void
     if (!!old_state->zsbuf != !!state->zsbuf) {
         r300->dsa_state.dirty = TRUE;
     }
-    if (!r300->scissor_enabled) {
-        r300->scissor_state.dirty = TRUE;
-    }
 
     r300_fb_update_tiling_flags(r300, r300->fb_state.state, state);
 
     memcpy(r300->fb_state.state, state, sizeof(struct pipe_framebuffer_state));
 
     r300->fb_state.size = (10 * state->nr_cbufs) + (2 * (4 - state->nr_cbufs)) +
-                          (state->zsbuf ? 10 : 0) + 8;
+                          (state->zsbuf ? 10 : 0) + 11;
 
     /* Polygon offset depends on the zbuffer bit depth. */
     if (state->zsbuf && r300->polygon_offset_enabled) {
@@ -650,12 +681,28 @@ static void* r300_create_fs_state(struct pipe_context* pipe,
     fs->state = *shader;
     fs->state.tokens = tgsi_dup_tokens(shader->tokens);
 
-    tgsi_scan_shader(shader->tokens, &fs->info);
-    r300_shader_read_fs_inputs(&fs->info, &fs->inputs);
-
     return (void*)fs;
 }
 
+void r300_mark_fs_code_dirty(struct r300_context *r300)
+{
+    struct r300_fragment_shader* fs = r300_fs(r300);
+
+    r300->fs.dirty = TRUE;
+    r300->fs_rc_constant_state.dirty = TRUE;
+    r300->fs_constants.dirty = TRUE;
+
+    if (r300->screen->caps.is_r500) {
+        r300->fs.size = r500_get_fs_atom_size(r300);
+        r300->fs_rc_constant_state.size = fs->shader->rc_state_count * 7;
+        r300->fs_constants.size = fs->shader->externals_count * 4 + 3;
+    } else {
+        r300->fs.size = r300_get_fs_atom_size(r300);
+        r300->fs_rc_constant_state.size = fs->shader->rc_state_count * 5;
+        r300->fs_constants.size = fs->shader->externals_count * 4 + 1;
+    }
+}
+
 /* Bind fragment shader state. */
 static void r300_bind_fs_state(struct pipe_context* pipe, void* shader)
 {
@@ -663,20 +710,19 @@ static void r300_bind_fs_state(struct pipe_context* pipe, void* shader)
     struct r300_fragment_shader* fs = (struct r300_fragment_shader*)shader;
 
     if (fs == NULL) {
-        r300->fs = NULL;
+        r300->fs.state = NULL;
         return;
     }
 
-    r300->fs = fs;
+    r300->fs.state = fs;
     r300_pick_fragment_shader(r300);
+    r300_mark_fs_code_dirty(r300);
 
     r300->rs_block_state.dirty = TRUE; /* Will be updated before the emission. */
 
     if (r300->vs_state.state && r300_vertex_shader_setup_wpos(r300)) {
         r300->vap_output_state.dirty = TRUE;
     }
-
-    r300->dirty_state |= R300_NEW_FRAGMENT_SHADER | R300_NEW_FRAGMENT_SHADER_CONSTANTS;
 }
 
 /* Delete fragment shader state. */
@@ -711,8 +757,8 @@ static void r300_set_polygon_stipple(struct pipe_context* pipe,
 static void* r300_create_rs_state(struct pipe_context* pipe,
                                   const struct pipe_rasterizer_state* state)
 {
-    struct r300_screen* r300screen = r300_screen(pipe->screen);
     struct r300_rs_state* rs = CALLOC_STRUCT(r300_rs_state);
+    int i;
 
     /* Copy rasterizer state for Draw. */
     rs->rs = *state;
@@ -724,7 +770,7 @@ static void* r300_create_rs_state(struct pipe_context* pipe,
 #endif
 
     /* If no TCL engine is present, turn off the HW TCL. */
-    if (!r300screen->caps->has_tcl) {
+    if (!r300_screen(pipe->screen)->caps.has_tcl) {
         rs->vap_control_status |= R300_VAP_TCL_BYPASS;
     }
 
@@ -805,6 +851,32 @@ static void* r300_create_rs_state(struct pipe_context* pipe,
         rs->color_control = R300_SHADE_MODEL_SMOOTH;
     }
 
+    rs->clip_rule = state->scissor ? 0xAAAA : 0xFFFF;
+
+    /* Point sprites */
+    if (state->sprite_coord_enable) {
+        rs->stuffing_enable = R300_GB_POINT_STUFF_ENABLE;
+	for (i = 0; i < 8; i++) {
+	    if (state->sprite_coord_enable & (1 << i))
+		rs->stuffing_enable |=
+		    R300_GB_TEX_STR << (R300_GB_TEX0_SOURCE_SHIFT + (i*2));
+	}
+
+        rs->point_texcoord_left = 0.0f;
+        rs->point_texcoord_right = 1.0f;
+
+        switch (state->sprite_coord_mode) {
+            case PIPE_SPRITE_COORD_UPPER_LEFT:
+                rs->point_texcoord_top = 0.0f;
+                rs->point_texcoord_bottom = 1.0f;
+                break;
+            case PIPE_SPRITE_COORD_LOWER_LEFT:
+                rs->point_texcoord_top = 1.0f;
+                rs->point_texcoord_bottom = 0.0f;
+                break;
+        }
+    }
+
     return (void*)rs;
 }
 
@@ -813,7 +885,7 @@ static void r300_bind_rs_state(struct pipe_context* pipe, void* state)
 {
     struct r300_context* r300 = r300_context(pipe);
     struct r300_rs_state* rs = (struct r300_rs_state*)state;
-    boolean scissor_was_enabled = r300->scissor_enabled;
+    int last_sprite_coord_enable = r300->sprite_coord_enable;
 
     if (r300->draw) {
         draw_flush(r300->draw);
@@ -822,17 +894,17 @@ static void r300_bind_rs_state(struct pipe_context* pipe, void* state)
 
     if (rs) {
         r300->polygon_offset_enabled = rs->rs.offset_cw || rs->rs.offset_ccw;
-        r300->scissor_enabled = rs->rs.scissor;
+        r300->sprite_coord_enable = rs->rs.sprite_coord_enable;
     } else {
         r300->polygon_offset_enabled = FALSE;
-        r300->scissor_enabled = FALSE;
+        r300->sprite_coord_enable = 0;
     }
 
     UPDATE_STATE(state, r300->rs_state);
-    r300->rs_state.size = 17 + (r300->polygon_offset_enabled ? 5 : 0);
+    r300->rs_state.size = 26 + (r300->polygon_offset_enabled ? 5 : 0);
 
-    if (scissor_was_enabled != r300->scissor_enabled) {
-        r300->scissor_state.dirty = TRUE;
+    if (last_sprite_coord_enable != r300->sprite_coord_enable) {
+        r300->rs_block_state.dirty = TRUE;
     }
 }
 
@@ -848,7 +920,7 @@ static void*
 {
     struct r300_context* r300 = r300_context(pipe);
     struct r300_sampler_state* sampler = CALLOC_STRUCT(r300_sampler_state);
-    boolean is_r500 = r300_screen(pipe->screen)->caps->is_r500;
+    boolean is_r500 = r300->screen->caps.is_r500;
     int lod_bias;
     union util_color uc;
 
@@ -887,7 +959,7 @@ static void*
     sampler->border_color = uc.ui;
 
     /* R500-specific fixups and optimizations */
-    if (r300_screen(r300->context.screen)->caps->is_r500) {
+    if (r300->screen->caps.is_r500) {
         sampler->filter1 |= R500_BORDER_FIX;
     }
 
@@ -901,23 +973,16 @@ static void r300_bind_sampler_states(struct pipe_context* pipe,
     struct r300_context* r300 = r300_context(pipe);
     struct r300_textures_state* state =
         (struct r300_textures_state*)r300->textures_state.state;
+    unsigned tex_units = r300->screen->caps.num_tex_units;
 
-    if (count > 8) {
+    if (count > tex_units) {
         return;
     }
 
     memcpy(state->sampler_states, states, sizeof(void*) * count);
-    state->sampler_count = count;
+    state->sampler_state_count = count;
 
     r300->textures_state.dirty = TRUE;
-
-    /* Pick a fragment shader based on the texture compare state. */
-    if (r300->fs && count) {
-        if (r300_pick_fragment_shader(r300)) {
-            r300->dirty_state |= R300_NEW_FRAGMENT_SHADER |
-                                 R300_NEW_FRAGMENT_SHADER_CONSTANTS;
-        }
-    }
 }
 
 static void r300_lacks_vertex_textures(struct pipe_context* pipe,
@@ -940,18 +1005,18 @@ static void r300_set_fragment_sampler_views(struct pipe_context* pipe,
         (struct r300_textures_state*)r300->textures_state.state;
     struct r300_texture *texture;
     unsigned i;
-    boolean is_r500 = r300_screen(r300->context.screen)->caps->is_r500;
+    unsigned tex_units = r300->screen->caps.num_tex_units;
     boolean dirty_tex = FALSE;
 
-    /* XXX magic num */
-    if (count > 8) {
+    if (count > tex_units) {
         return;
     }
 
     for (i = 0; i < count; i++) {
-        if (state->fragment_sampler_views[i] != views[i]) {
-            pipe_sampler_view_reference(&state->fragment_sampler_views[i],
-                                        views[i]);
+        if (&state->sampler_views[i]->base != views[i]) {
+            pipe_sampler_view_reference(
+                    (struct pipe_sampler_view**)&state->sampler_views[i],
+                    views[i]);
 
             if (!views[i]) {
                 continue;
@@ -960,24 +1025,24 @@ static void r300_set_fragment_sampler_views(struct pipe_context* pipe,
             /* A new sampler view (= texture)... */
             dirty_tex = TRUE;
 
-            /* R300-specific - set the texrect factor in the fragment shader */
-            texture = (struct r300_texture *)views[i]->texture;
-            if (!is_r500 && texture->is_npot) {
-                /* XXX It would be nice to re-emit just 1 constant,
-                 * XXX not all of them */
-                r300->dirty_state |= R300_NEW_FRAGMENT_SHADER_CONSTANTS;
+            /* Set the texrect factor in the fragment shader.
+             * Needed for RECT and NPOT fallback. */
+            texture = r300_texture(views[i]->texture);
+            if (texture->uses_pitch) {
+                r300->fs_rc_constant_state.dirty = TRUE;
             }
         }
     }
 
-    for (i = count; i < 8; i++) {
-        if (state->fragment_sampler_views[i]) {
-            pipe_sampler_view_reference(&state->fragment_sampler_views[i],
-                                        NULL);
+    for (i = count; i < tex_units; i++) {
+        if (state->sampler_views[i]) {
+            pipe_sampler_view_reference(
+                    (struct pipe_sampler_view**)&state->sampler_views[i],
+                    NULL);
         }
     }
 
-    state->texture_count = count;
+    state->sampler_view_count = count;
 
     r300->textures_state.dirty = TRUE;
 
@@ -988,27 +1053,43 @@ static void r300_set_fragment_sampler_views(struct pipe_context* pipe,
 
 static struct pipe_sampler_view *
 r300_create_sampler_view(struct pipe_context *pipe,
-                         struct pipe_texture *texture,
+                         struct pipe_resource *texture,
                          const struct pipe_sampler_view *templ)
 {
-   struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
-
-   if (view) {
-      *view = *templ;
-      view->reference.count = 1;
-      view->texture = NULL;
-      pipe_texture_reference(&view->texture, texture);
-      view->context = pipe;
-   }
+    struct r300_sampler_view *view = CALLOC_STRUCT(r300_sampler_view);
+    struct r300_texture *tex = r300_texture(texture);
+    unsigned char swizzle[4];
+
+    if (view) {
+        view->base = *templ;
+        view->base.reference.count = 1;
+        view->base.context = pipe;
+        view->base.texture = NULL;
+        pipe_resource_reference(&view->base.texture, texture);
+
+        swizzle[0] = templ->swizzle_r;
+        swizzle[1] = templ->swizzle_g;
+        swizzle[2] = templ->swizzle_b;
+        swizzle[3] = templ->swizzle_a;
+
+        /* XXX Enable swizzles when they become supported. Now we get RGBA
+         * everywhere. And do testing! */
+        view->format = tex->tx_format;
+        view->format.format1 |= r300_translate_texformat(templ->format,
+                                                         0); /*swizzle);*/
+        if (r300_screen(pipe->screen)->caps.is_r500) {
+            view->format.format2 |= r500_tx_format_msb_bit(templ->format);
+        }
+    }
 
-   return view;
+    return (struct pipe_sampler_view*)view;
 }
 
 static void
 r300_sampler_view_destroy(struct pipe_context *pipe,
                           struct pipe_sampler_view *view)
 {
-   pipe_texture_reference(&view->texture, NULL);
+   pipe_resource_reference(&view->texture, NULL);
    FREE(view);
 }
 
@@ -1020,9 +1101,7 @@ static void r300_set_scissor_state(struct pipe_context* pipe,
     memcpy(r300->scissor_state.state, state,
         sizeof(struct pipe_scissor_state));
 
-    if (r300->scissor_enabled) {
-        r300->scissor_state.dirty = TRUE;
-    }
+    r300->scissor_state.dirty = TRUE;
 }
 
 static void r300_set_viewport_state(struct pipe_context* pipe,
@@ -1063,8 +1142,8 @@ static void r300_set_viewport_state(struct pipe_context* pipe,
     }
 
     r300->viewport_state.dirty = TRUE;
-    if (r300->fs && r300->fs->inputs.wpos != ATTR_UNUSED) {
-        r300->dirty_state |= R300_NEW_FRAGMENT_SHADER_CONSTANTS;
+    if (r300->fs.state && r300_fs(r300)->shader->inputs.wpos != ATTR_UNUSED) {
+        r300->fs_rc_constant_state.dirty = TRUE;
     }
 }
 
@@ -1088,10 +1167,9 @@ static void r300_set_vertex_buffers(struct pipe_context* pipe,
         if (buffers[i].buffer) {
             if (buffers[i].stride % 4 != 0) {
                 // XXX Shouldn't we align the buffer?
-                fprintf(stderr, "r300_set_vertex_buffers: "
+                fprintf(stderr, "r300: set_vertex_buffers: "
                         "Unaligned buffer stride %i isn't supported.\n",
                         buffers[i].stride);
-                assert(0);
                 abort();
             }
         }
@@ -1102,7 +1180,7 @@ static void r300_set_vertex_buffers(struct pipe_context* pipe,
         vbo = (struct pipe_vertex_buffer*)&buffers[i];
 
         /* Reference our buffer. */
-        pipe_buffer_reference(&r300->vertex_buffer[i].buffer, vbo->buffer);
+        pipe_resource_reference(&r300->vertex_buffer[i].buffer, vbo->buffer);
 
         /* Skip NULL buffers */
         if (!buffers[i].buffer) {
@@ -1115,8 +1193,13 @@ static void r300_set_vertex_buffers(struct pipe_context* pipe,
 
         if (vbo->max_index == ~0) {
             /* Bogus value from broken state tracker; hax it. */
+	    /* TODO - more hax - fixes doom3 from almos on irc */
+	    if (!vbo->stride) {
+		fprintf(stderr, "r300: got a VBO with stride 0 fixing up to stide 4\n");
+		vbo->stride = 4;
+	    }
             vbo->max_index =
-                (vbo->buffer->size - vbo->buffer_offset) / vbo->stride;
+                (vbo->buffer->width0 - vbo->buffer_offset) / vbo->stride;
         }
 
         max_index = MIN2(vbo->max_index, max_index);
@@ -1124,7 +1207,7 @@ static void r300_set_vertex_buffers(struct pipe_context* pipe,
 
     for (; i < r300->vertex_buffer_count; i++) {
         /* Dereference any old buffers. */
-        pipe_buffer_reference(&r300->vertex_buffer[i].buffer, NULL);
+        pipe_resource_reference(&r300->vertex_buffer[i].buffer, NULL);
     }
 
     memcpy(r300->vertex_buffer, buffers,
@@ -1148,7 +1231,11 @@ static void r300_vertex_psc(struct r300_vertex_element_state *velems)
     enum pipe_format format;
     unsigned i;
 
-    assert(velems->count <= 16);
+    if (velems->count > 16) {
+        fprintf(stderr, "r300: More than 16 vertex elements are not supported,"
+                " requested %i, using 16.\n", velems->count);
+        velems->count = 16;
+    }
 
     /* Vertex shaders have no semantics on their inputs,
      * so PSC should just route stuff based on the vertex elements,
@@ -1183,7 +1270,6 @@ static void* r300_create_vertex_elements_state(struct pipe_context* pipe,
                                                unsigned count,
                                                const struct pipe_vertex_element* attribs)
 {
-    struct r300_screen* r300screen = r300_screen(pipe->screen);
     struct r300_vertex_element_state *velems;
     unsigned i, size;
 
@@ -1193,7 +1279,7 @@ static void* r300_create_vertex_elements_state(struct pipe_context* pipe,
         velems->count = count;
         memcpy(velems->velem, attribs, sizeof(struct pipe_vertex_element) * count);
 
-        if (r300screen->caps->has_tcl) {
+        if (r300_screen(pipe->screen)->caps.has_tcl) {
             /* Check if the format is aligned to the size of DWORD. */
             for (i = 0; i < count; i++) {
                 size = util_format_get_blocksize(attribs[i].src_format);
@@ -1246,10 +1332,13 @@ static void* r300_create_vs_state(struct pipe_context* pipe,
     struct r300_context* r300 = r300_context(pipe);
 
     struct r300_vertex_shader* vs = CALLOC_STRUCT(r300_vertex_shader);
-    r300_vertex_shader_common_init(vs, shader);
 
-    if (r300_screen(pipe->screen)->caps->has_tcl) {
-        r300_translate_vertex_shader(r300, vs);
+    /* Copy state directly into shader. */
+    vs->state = *shader;
+    vs->state.tokens = tgsi_dup_tokens(shader->tokens);
+
+    if (r300->screen->caps.has_tcl) {
+        r300_translate_vertex_shader(r300, vs, vs->state.tokens);
     } else {
         vs->draw_vs = draw_create_vertex_shader(r300->draw, shader);
     }
@@ -1272,7 +1361,7 @@ static void r300_bind_vs_state(struct pipe_context* pipe, void* shader)
     r300->vs_state.state = vs;
 
     // VS output mapping for HWTCL or stream mapping for SWTCL to the RS block
-    if (r300->fs) {
+    if (r300->fs.state) {
         r300_vertex_shader_setup_wpos(r300);
     }
     memcpy(r300->vap_output_state.state, &vs->vap_out,
@@ -1282,13 +1371,20 @@ static void r300_bind_vs_state(struct pipe_context* pipe, void* shader)
     /* The majority of the RS block bits is dependent on the vertex shader. */
     r300->rs_block_state.dirty = TRUE; /* Will be updated before the emission. */
 
-    if (r300_screen(pipe->screen)->caps->has_tcl) {
+    if (r300->screen->caps.has_tcl) {
         r300->vs_state.dirty = TRUE;
-        r300->vs_state.size = vs->code.length + 9;
+        r300->vs_state.size =
+                vs->code.length + 9 +
+                (vs->immediates_count ? vs->immediates_count * 4 + 3 : 0);
 
-        r300->pvs_flush.dirty = TRUE;
+        if (vs->externals_count) {
+            r300->vs_constants.dirty = TRUE;
+            r300->vs_constants.size = vs->externals_count * 4 + 3;
+        } else {
+            r300->vs_constants.size = 0;
+        }
 
-        r300->dirty_state |= R300_NEW_VERTEX_SHADER_CONSTANTS;
+        r300->pvs_flush.dirty = TRUE;
     } else {
         draw_flush(r300->draw);
         draw_bind_vertex_shader(r300->draw,
@@ -1301,7 +1397,7 @@ static void r300_delete_vs_state(struct pipe_context* pipe, void* shader)
     struct r300_context* r300 = r300_context(pipe);
     struct r300_vertex_shader* vs = (struct r300_vertex_shader*)shader;
 
-    if (r300_screen(pipe->screen)->caps->has_tcl) {
+    if (r300->screen->caps.has_tcl) {
         rc_constants_destroy(&vs->code.constants);
     } else {
         draw_delete_vertex_shader(r300->draw,
@@ -1314,63 +1410,66 @@ static void r300_delete_vs_state(struct pipe_context* pipe, void* shader)
 
 static void r300_set_constant_buffer(struct pipe_context *pipe,
                                      uint shader, uint index,
-                                     struct pipe_buffer *buf)
+                                     struct pipe_resource *buf)
 {
     struct r300_context* r300 = r300_context(pipe);
-    struct r300_screen *r300screen = r300_screen(pipe->screen);
+    struct r300_constant_buffer *cbuf;
+    struct pipe_transfer *tr;
     void *mapped;
     int max_size = 0;
 
-    if (buf == NULL || buf->size == 0 ||
-        (mapped = pipe_buffer_map(pipe->screen, buf, PIPE_BUFFER_USAGE_CPU_READ)) == NULL)
-    {
-        r300->shader_constants[shader].count = 0;
-        return;
-    }
-
-    assert((buf->size % 4 * sizeof(float)) == 0);
-
-    /* Check the size of the constant buffer. */
     switch (shader) {
         case PIPE_SHADER_VERTEX:
+            cbuf = (struct r300_constant_buffer*)r300->vs_constants.state;
             max_size = 256;
             break;
         case PIPE_SHADER_FRAGMENT:
-            if (r300screen->caps->is_r500) {
+            cbuf = (struct r300_constant_buffer*)r300->fs_constants.state;
+            if (r300->screen->caps.is_r500) {
                 max_size = 256;
-            /* XXX Implement emission of r400's extended constant buffer. */
-            /*} else if (r300screen->caps->is_r400) {
-                max_size = 64;*/
             } else {
                 max_size = 32;
             }
             break;
         default:
             assert(0);
+            return;
+    }
+
+    if (buf == NULL || buf->width0 == 0 ||
+        (mapped = pipe_buffer_map(pipe, buf, PIPE_TRANSFER_READ, &tr)) == NULL)
+    {
+        cbuf->count = 0;
+        return;
     }
 
+    assert((buf->width0 % 4 * sizeof(float)) == 0);
+
+    /* Check the size of the constant buffer. */
     /* XXX Subtract immediates and RC_STATE_* variables. */
-    if (buf->size > (sizeof(float) * 4 * max_size)) {
+    if (buf->width0 > (sizeof(float) * 4 * max_size)) {
         fprintf(stderr, "r300: Max size of the constant buffer is "
                       "%i*4 floats.\n", max_size);
         abort();
     }
 
-    memcpy(r300->shader_constants[shader].constants, mapped, buf->size);
-    r300->shader_constants[shader].count = buf->size / (4 * sizeof(float));
-    pipe_buffer_unmap(pipe->screen, buf);
+    memcpy(cbuf->constants, mapped, buf->width0);
+    cbuf->count = buf->width0 / (4 * sizeof(float));
+    pipe_buffer_unmap(pipe, buf, tr);
 
     if (shader == PIPE_SHADER_VERTEX) {
-        if (r300screen->caps->has_tcl) {
-            r300->dirty_state |= R300_NEW_VERTEX_SHADER_CONSTANTS;
+        if (r300->screen->caps.has_tcl) {
+            if (r300->vs_constants.size) {
+                r300->vs_constants.dirty = TRUE;
+            }
             r300->pvs_flush.dirty = TRUE;
         } else if (r300->draw) {
             draw_set_mapped_constant_buffer(r300->draw, PIPE_SHADER_VERTEX,
-                0, r300->shader_constants[PIPE_SHADER_VERTEX].constants,
-                buf->size);
+                0, cbuf->constants,
+                buf->width0);
         }
     } else if (shader == PIPE_SHADER_FRAGMENT) {
-        r300->dirty_state |= R300_NEW_FRAGMENT_SHADER_CONSTANTS;
+        r300->fs_constants.dirty = TRUE;
     }
 }
 
diff --git a/src/gallium/drivers/r300/r300_state.h b/src/gallium/drivers/r300/r300_state.h
new file mode 100644
index 00000000000..1d557506cf3
--- /dev/null
+++ b/src/gallium/drivers/r300/r300_state.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2008 Marek Olšák <maraeo@gmail.com>
+ *
+ * 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
+ * on 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
+ * THE AUTHOR(S) AND/OR THEIR 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 R300_STATE_H
+#define R300_STATE_H
+
+struct r300_context;
+
+void r300_mark_fs_code_dirty(struct r300_context *r300);
+
+#endif /* R300_STATE_H */
diff --git a/src/gallium/drivers/r300/r300_state_derived.c b/src/gallium/drivers/r300/r300_state_derived.c
index bc5431c802d..a36cff98c38 100644
--- a/src/gallium/drivers/r300/r300_state_derived.c
+++ b/src/gallium/drivers/r300/r300_state_derived.c
@@ -30,6 +30,7 @@
 #include "r300_fs.h"
 #include "r300_screen.h"
 #include "r300_shader_semantics.h"
+#include "r300_state.h"
 #include "r300_state_derived.h"
 #include "r300_state_inlines.h"
 #include "r300_vs.h"
@@ -37,6 +38,12 @@
 /* r300_state_derived: Various bits of state which are dependent upon
  * currently bound CSO data. */
 
+enum r300_rs_swizzle {
+    SWIZ_XYZW = 0,
+    SWIZ_X001,
+    SWIZ_XY01,
+};
+
 static void r300_draw_emit_attrib(struct r300_context* r300,
                                   enum attrib_emit emit,
                                   enum interp_mode interp,
@@ -83,8 +90,10 @@ static void r300_draw_emit_all_attribs(struct r300_context* r300)
     /* XXX Back-face colors. */
 
     /* Texture coordinates. */
+    /* Only 8 generic vertex attributes can be used. If there are more,
+     * they won't be rasterized. */
     gen_count = 0;
-    for (i = 0; i < ATTR_GENERIC_COUNT; i++) {
+    for (i = 0; i < ATTR_GENERIC_COUNT && gen_count < 8; i++) {
         if (vs_outputs->generic[i] != ATTR_UNUSED) {
             r300_draw_emit_attrib(r300, EMIT_4F, INTERP_PERSPECTIVE,
                                   vs_outputs->generic[i]);
@@ -93,14 +102,11 @@ static void r300_draw_emit_all_attribs(struct r300_context* r300)
     }
 
     /* Fog coordinates. */
-    if (vs_outputs->fog != ATTR_UNUSED) {
+    if (gen_count < 8 && vs_outputs->fog != ATTR_UNUSED) {
         r300_draw_emit_attrib(r300, EMIT_4F, INTERP_PERSPECTIVE,
                               vs_outputs->fog);
         gen_count++;
     }
-
-    /* XXX magic */
-    assert(gen_count <= 8);
 }
 
 /* Update the PSC tables for SW TCL, using Draw. */
@@ -181,14 +187,20 @@ static void r300_rs_col_write(struct r300_rs_block* rs, int id, int fp_offset)
 }
 
 static void r300_rs_tex(struct r300_rs_block* rs, int id, int ptr,
-                        boolean swizzle_X001)
+                        enum r300_rs_swizzle swiz)
 {
-    if (swizzle_X001) {
+    if (swiz == SWIZ_X001) {
         rs->ip[id] |= R300_RS_TEX_PTR(ptr*4) |
                       R300_RS_SEL_S(R300_RS_SEL_C0) |
                       R300_RS_SEL_T(R300_RS_SEL_K0) |
                       R300_RS_SEL_R(R300_RS_SEL_K0) |
                       R300_RS_SEL_Q(R300_RS_SEL_K1);
+    } else if (swiz == SWIZ_XY01) {
+        rs->ip[id] |= R300_RS_TEX_PTR(ptr*4) |
+                      R300_RS_SEL_S(R300_RS_SEL_C0) |
+                      R300_RS_SEL_T(R300_RS_SEL_C1) |
+                      R300_RS_SEL_R(R300_RS_SEL_K0) |
+                      R300_RS_SEL_Q(R300_RS_SEL_K1);
     } else {
         rs->ip[id] |= R300_RS_TEX_PTR(ptr*4) |
                       R300_RS_SEL_S(R300_RS_SEL_C0) |
@@ -224,15 +236,20 @@ static void r500_rs_col_write(struct r300_rs_block* rs, int id, int fp_offset)
 }
 
 static void r500_rs_tex(struct r300_rs_block* rs, int id, int ptr,
-                        boolean swizzle_X001)
+			enum r300_rs_swizzle swiz)
 {
     int rs_tex_comp = ptr*4;
 
-    if (swizzle_X001) {
+    if (swiz == SWIZ_X001) {
         rs->ip[id] |= R500_RS_SEL_S(rs_tex_comp) |
                       R500_RS_SEL_T(R500_RS_IP_PTR_K0) |
                       R500_RS_SEL_R(R500_RS_IP_PTR_K0) |
                       R500_RS_SEL_Q(R500_RS_IP_PTR_K1);
+    } else if (swiz == SWIZ_XY01) {
+        rs->ip[id] |= R500_RS_SEL_S(rs_tex_comp) |
+                      R500_RS_SEL_T(rs_tex_comp + 1) |
+                      R500_RS_SEL_R(R500_RS_IP_PTR_K0) |
+                      R500_RS_SEL_Q(R500_RS_IP_PTR_K1);
     } else {
         rs->ip[id] |= R500_RS_SEL_S(rs_tex_comp) |
                       R500_RS_SEL_T(rs_tex_comp + 1) |
@@ -261,12 +278,12 @@ static void r300_update_rs_block(struct r300_context* r300,
     int i, col_count = 0, tex_count = 0, fp_offset = 0, count;
     void (*rX00_rs_col)(struct r300_rs_block*, int, int, boolean);
     void (*rX00_rs_col_write)(struct r300_rs_block*, int, int);
-    void (*rX00_rs_tex)(struct r300_rs_block*, int, int, boolean);
+    void (*rX00_rs_tex)(struct r300_rs_block*, int, int, enum r300_rs_swizzle);
     void (*rX00_rs_tex_write)(struct r300_rs_block*, int, int);
     boolean any_bcolor_used = vs_outputs->bcolor[0] != ATTR_UNUSED ||
                               vs_outputs->bcolor[1] != ATTR_UNUSED;
 
-    if (r300_screen(r300->context.screen)->caps->is_r500) {
+    if (r300->screen->caps.is_r500) {
         rX00_rs_col       = r500_rs_col;
         rX00_rs_col_write = r500_rs_col_write;
         rX00_rs_tex       = r500_rs_tex;
@@ -303,14 +320,19 @@ static void r300_update_rs_block(struct r300_context* r300,
 
     /* Rasterize texture coordinates. */
     for (i = 0; i < ATTR_GENERIC_COUNT; i++) {
-        if (vs_outputs->generic[i] != ATTR_UNUSED) {
+	bool sprite_coord = !!(r300->sprite_coord_enable & (1 << i));
+
+        if (vs_outputs->generic[i] != ATTR_UNUSED || sprite_coord) {
             /* Always rasterize if it's written by the VS,
              * otherwise it locks up. */
-            rX00_rs_tex(&rs, tex_count, tex_count, FALSE);
+            rX00_rs_tex(&rs, tex_count, tex_count,
+			sprite_coord ? SWIZ_XY01 : SWIZ_XYZW);
 
             /* Write it to the FS input register if it's used by the FS. */
             if (fs_inputs->generic[i] != ATTR_UNUSED) {
                 rX00_rs_tex_write(&rs, tex_count, fp_offset);
+                if (sprite_coord)
+                    debug_printf("r300: SpriteCoord (generic index %i) is being written to reg %i\n", i, fp_offset);
                 fp_offset++;
             }
             tex_count++;
@@ -327,7 +349,7 @@ static void r300_update_rs_block(struct r300_context* r300,
     if (vs_outputs->fog != ATTR_UNUSED) {
         /* Always rasterize if it's written by the VS,
          * otherwise it locks up. */
-        rX00_rs_tex(&rs, tex_count, tex_count, TRUE);
+        rX00_rs_tex(&rs, tex_count, tex_count, SWIZ_X001);
 
         /* Write it to the FS input register if it's used by the FS. */
         if (fs_inputs->fog != ATTR_UNUSED) {
@@ -345,8 +367,8 @@ static void r300_update_rs_block(struct r300_context* r300,
 
     /* Rasterize WPOS. */
     /* If the FS doesn't need it, it's not written by the VS. */
-    if (fs_inputs->wpos != ATTR_UNUSED) {
-        rX00_rs_tex(&rs, tex_count, tex_count, FALSE);
+    if (vs_outputs->wpos != ATTR_UNUSED && fs_inputs->wpos != ATTR_UNUSED) {
+        rX00_rs_tex(&rs, tex_count, tex_count, SWIZ_XYZW);
         rX00_rs_tex_write(&rs, tex_count, fp_offset);
 
         fp_offset++;
@@ -377,7 +399,7 @@ static void r300_update_derived_shader_state(struct r300_context* r300)
 {
     struct r300_vertex_shader* vs = r300->vs_state.state;
 
-    r300_update_rs_block(r300, &vs->outputs, &r300->fs->inputs);
+    r300_update_rs_block(r300, &vs->outputs, &r300_fs(r300)->shader->inputs);
 }
 
 static boolean r300_dsa_writes_depth_stencil(struct r300_dsa_state* dsa)
@@ -437,12 +459,12 @@ static void r300_update_ztop(struct r300_context* r300)
 
     /* ZS writes */
     if (r300_dsa_writes_depth_stencil(r300->dsa_state.state) &&
-           (r300_dsa_alpha_test_enabled(r300->dsa_state.state) ||/* (1) */
-            r300->fs->info.uses_kill)) {                         /* (2) */
+           (r300_dsa_alpha_test_enabled(r300->dsa_state.state) ||  /* (1) */
+            r300_fs(r300)->shader->info.uses_kill)) {              /* (2) */
         ztop_state->z_buffer_top = R300_ZTOP_DISABLE;
-    } else if (r300_fragment_shader_writes_depth(r300->fs)) {    /* (5) */
+    } else if (r300_fragment_shader_writes_depth(r300_fs(r300))) { /* (5) */
         ztop_state->z_buffer_top = R300_ZTOP_DISABLE;
-    } else if (r300->query_current) {                            /* (6) */
+    } else if (r300->query_current) {                              /* (6) */
         ztop_state->z_buffer_top = R300_ZTOP_DISABLE;
     } else {
         ztop_state->z_buffer_top = R300_ZTOP_ENABLE;
@@ -457,55 +479,71 @@ static void r300_merge_textures_and_samplers(struct r300_context* r300)
         (struct r300_textures_state*)r300->textures_state.state;
     struct r300_texture_sampler_state *texstate;
     struct r300_sampler_state *sampler;
-    struct pipe_sampler_view *view;
+    struct r300_sampler_view *view;
     struct r300_texture *tex;
     unsigned min_level, max_level, i, size;
-    unsigned count = MIN2(state->texture_count, state->sampler_count);
+    unsigned count = MIN2(state->sampler_view_count,
+                          state->sampler_state_count);
 
     state->tx_enable = 0;
     state->count = 0;
     size = 2;
 
     for (i = 0; i < count; i++) {
-        if (state->fragment_sampler_views[i] && state->sampler_states[i]) {
+        if (state->sampler_views[i] && state->sampler_states[i]) {
             state->tx_enable |= 1 << i;
 
-            view = state->fragment_sampler_views[i];
-            tex = (struct r300_texture *)view->texture;
+            view = state->sampler_views[i];
+            tex = r300_texture(view->base.texture);
             sampler = state->sampler_states[i];
 
-            assert(view->format == tex->tex.format);
-
             texstate = &state->regs[i];
-            memcpy(texstate->format, &tex->state, sizeof(uint32_t)*3);
-            texstate->filter[0] = sampler->filter0;
-            texstate->filter[1] = sampler->filter1;
+            texstate->format = view->format;
+            texstate->filter0 = sampler->filter0;
+            texstate->filter1 = sampler->filter1;
             texstate->border_color = sampler->border_color;
-            texstate->tile_config = R300_TXO_MACRO_TILE(tex->macrotile) |
-                                    R300_TXO_MICRO_TILE(tex->microtile);
 
             /* to emulate 1D textures through 2D ones correctly */
-            if (tex->tex.target == PIPE_TEXTURE_1D) {
-                texstate->filter[0] &= ~R300_TX_WRAP_T_MASK;
-                texstate->filter[0] |= R300_TX_WRAP_T(R300_TX_CLAMP_TO_EDGE);
+            if (tex->b.b.target == PIPE_TEXTURE_1D) {
+                texstate->filter0 &= ~R300_TX_WRAP_T_MASK;
+                texstate->filter0 |= R300_TX_WRAP_T(R300_TX_CLAMP_TO_EDGE);
             }
 
-            if (tex->is_npot) {
+            if (tex->uses_pitch) {
                 /* NPOT textures don't support mip filter, unfortunately.
                  * This prevents incorrect rendering. */
-                texstate->filter[0] &= ~R300_TX_MIN_FILTER_MIP_MASK;
+                texstate->filter0 &= ~R300_TX_MIN_FILTER_MIP_MASK;
+
+                /* Set repeat or mirrored-repeat to clamp-to-edge. */
+                /* Wrap S. */
+                if ((texstate->filter0 & R300_TX_WRAP_S_MASK) ==
+                     R300_TX_WRAP_S(R300_TX_REPEAT) ||
+                    (texstate->filter0 & R300_TX_WRAP_S_MASK) ==
+                     R300_TX_WRAP_S(R300_TX_MIRRORED)) {
+                    texstate->filter0 &= ~R300_TX_WRAP_S_MASK;
+                    texstate->filter0 |= R300_TX_WRAP_S(R300_TX_CLAMP_TO_EDGE);
+                }
+
+                /* Wrap T. */
+                if ((texstate->filter0 & R300_TX_WRAP_T_MASK) ==
+                     R300_TX_WRAP_T(R300_TX_REPEAT) ||
+                    (texstate->filter0 & R300_TX_WRAP_T_MASK) ==
+                     R300_TX_WRAP_T(R300_TX_MIRRORED)) {
+                    texstate->filter0 &= ~R300_TX_WRAP_T_MASK;
+                    texstate->filter0 |= R300_TX_WRAP_T(R300_TX_CLAMP_TO_EDGE);
+                }
             } else {
                 /* determine min/max levels */
                 /* the MAX_MIP level is the largest (finest) one */
-                max_level = MIN3(sampler->max_lod + view->first_level,
-                                 tex->tex.last_level, view->last_level);
-                min_level = MIN2(sampler->min_lod + view->first_level,
+                max_level = MIN3(sampler->max_lod + view->base.first_level,
+                                 tex->b.b.last_level, view->base.last_level);
+                min_level = MIN2(sampler->min_lod + view->base.first_level,
                                  max_level);
-                texstate->format[0] |= R300_TX_NUM_LEVELS(max_level);
-                texstate->filter[0] |= R300_TX_MAX_MIP_LEVEL(min_level);
+                texstate->format.format0 |= R300_TX_NUM_LEVELS(max_level);
+                texstate->filter0 |= R300_TX_MAX_MIP_LEVEL(min_level);
             }
 
-            texstate->filter[0] |= i << 28;
+            texstate->filter0 |= i << 28;
 
             size += 16;
             state->count = i+1;
@@ -513,18 +551,26 @@ static void r300_merge_textures_and_samplers(struct r300_context* r300)
     }
 
     r300->textures_state.size = size;
+
+    /* Pick a fragment shader based on either the texture compare state
+     * or the uses_pitch flag. */
+    if (r300->fs.state && count) {
+        if (r300_pick_fragment_shader(r300)) {
+            r300_mark_fs_code_dirty(r300);
+        }
+    }
 }
 
 void r300_update_derived_state(struct r300_context* r300)
 {
-    if (r300->rs_block_state.dirty) {
-        r300_update_derived_shader_state(r300);
-    }
-
     if (r300->textures_state.dirty) {
         r300_merge_textures_and_samplers(r300);
     }
 
+    if (r300->rs_block_state.dirty) {
+        r300_update_derived_shader_state(r300);
+    }
+
     if (r300->draw) {
         memset(&r300->vertex_info, 0, sizeof(struct vertex_info));
         r300_draw_emit_all_attribs(r300);
diff --git a/src/gallium/drivers/r300/r300_state_inlines.h b/src/gallium/drivers/r300/r300_state_inlines.h
index 8a690039b6b..044d70cbe82 100644
--- a/src/gallium/drivers/r300/r300_state_inlines.h
+++ b/src/gallium/drivers/r300/r300_state_inlines.h
@@ -338,7 +338,7 @@ static INLINE uint32_t r500_anisotropy(unsigned max_aniso)
 
     // Map the range [0, 15] to [0, 63].
     return R500_TX_MAX_ANISO(MIN2((unsigned)(max_aniso*4.2001), 63)) |
-           R500_TX_ANISO_HIGH_QUALITY;;
+           R500_TX_ANISO_HIGH_QUALITY;
 }
 
 /* Non-CSO state. (For now.) */
diff --git a/src/gallium/drivers/r300/r300_state_invariant.c b/src/gallium/drivers/r300/r300_state_invariant.c
index 88ae75bb816..ffb175febf1 100644
--- a/src/gallium/drivers/r300/r300_state_invariant.c
+++ b/src/gallium/drivers/r300/r300_state_invariant.c
@@ -41,16 +41,12 @@ struct pipe_viewport_state r300_viewport_identity = {
 void r300_emit_invariant_state(struct r300_context* r300,
                                unsigned size, void* state)
 {
-    struct r300_capabilities* caps = r300_screen(r300->context.screen)->caps;
+    struct r300_capabilities* caps = &r300_screen(r300->context.screen)->caps;
     CS_LOCALS(r300);
 
-    BEGIN_CS(14 + (caps->has_tcl ? 2: 0));
+    BEGIN_CS(12 + (caps->has_tcl ? 2: 0));
 
     /*** Graphics Backend (GB) ***/
-    /* Various GB enables */
-    OUT_CS_REG(R300_GB_ENABLE, R300_GB_POINT_STUFF_ENABLE |
-                               R300_GB_LINE_STUFF_ENABLE  |
-                               R300_GB_TRIANGLE_STUFF_ENABLE);
     /* Subpixel multisampling for AA
      * These are commented out because glisse's CS checker doesn't like them.
      * I presume these will be re-enabled later.
@@ -78,7 +74,7 @@ void r300_emit_invariant_state(struct r300_context* r300,
     END_CS;
 
     /* XXX unsorted stuff from surface_fill */
-    BEGIN_CS(44 + (caps->has_tcl ? 7 : 0) +
+    BEGIN_CS(38 + (caps->has_tcl ? 7 : 0) +
              (caps->family >= CHIP_FAMILY_RV350 ? 4 : 0));
 
     if (caps->has_tcl) {
@@ -90,11 +86,6 @@ void r300_emit_invariant_state(struct r300_context* r300,
         OUT_CS_32F(1.0);
         OUT_CS_32F(1.0);
     }
-    /* XXX point tex stuffing */
-    OUT_CS_REG_SEQ(R300_GA_POINT_S0, 1);
-    OUT_CS_32F(0.0);
-    OUT_CS_REG_SEQ(R300_GA_POINT_S1, 1);
-    OUT_CS_32F(1.0);
     /* XXX line tex stuffing */
     OUT_CS_REG_SEQ(R300_GA_LINE_S0, 1);
     OUT_CS_32F(0.0);
@@ -125,9 +116,5 @@ void r300_emit_invariant_state(struct r300_context* r300,
     OUT_CS_REG(R300_ZB_DEPTHCLEARVALUE, 0x00000000);
     OUT_CS_REG(R300_ZB_HIZ_OFFSET, 0x00000000);
     OUT_CS_REG(R300_ZB_HIZ_PITCH, 0x00000000);
-
-    /* XXX */
-    OUT_CS_REG(R300_SC_CLIP_RULE, 0xFFFF);
-
     END_CS;
 }
diff --git a/src/gallium/drivers/r300/r300_texture.c b/src/gallium/drivers/r300/r300_texture.c
index e7bac615dff..4439e35d670 100644
--- a/src/gallium/drivers/r300/r300_texture.c
+++ b/src/gallium/drivers/r300/r300_texture.c
@@ -28,7 +28,9 @@
 #include "util/u_memory.h"
 
 #include "r300_context.h"
+#include "r300_reg.h"
 #include "r300_texture.h"
+#include "r300_transfer.h"
 #include "r300_screen.h"
 #include "r300_winsys.h"
 
@@ -71,7 +73,8 @@ static boolean r300_format_is_plain(enum pipe_format format)
  *
  * The FORMAT specifies how the texture sampler will treat the texture, and
  * makes available X, Y, Z, W, ZERO, and ONE for swizzling. */
-static uint32_t r300_translate_texformat(enum pipe_format format)
+uint32_t r300_translate_texformat(enum pipe_format format,
+                                  const unsigned char *swizzle)
 {
     uint32_t result = 0;
     const struct util_format_description *desc;
@@ -83,7 +86,7 @@ static uint32_t r300_translate_texformat(enum pipe_format format)
         R300_TX_FORMAT_B_SHIFT,
         R300_TX_FORMAT_A_SHIFT
     };
-    const uint32_t swizzle[4] = {
+    const uint32_t swizzle_bit[4] = {
         R300_TX_FORMAT_X,
         R300_TX_FORMAT_Y,
         R300_TX_FORMAT_Z,
@@ -130,24 +133,50 @@ static uint32_t r300_translate_texformat(enum pipe_format format)
             result |= R300_TX_FORMAT_GAMMA;
             break;
 
-        default:;
+        default:
+            switch (format) {
+                /* Same as YUV but without the YUR->RGB conversion. */
+                case PIPE_FORMAT_R8G8_B8G8_UNORM:
+                    return R300_EASY_TX_FORMAT(X, Y, Z, ONE, YVYU422) | result;
+                case PIPE_FORMAT_G8R8_G8B8_UNORM:
+                    return R300_EASY_TX_FORMAT(X, Y, Z, ONE, VYUY422) | result;
+                default:;
+            }
     }
 
     /* Add swizzle. */
+    if (!swizzle) {
+        swizzle = desc->swizzle;
+    } /*else {
+        if (swizzle[0] != desc->swizzle[0] ||
+            swizzle[1] != desc->swizzle[1] ||
+            swizzle[2] != desc->swizzle[2] ||
+            swizzle[3] != desc->swizzle[3])
+        {
+            const char n[6] = "RGBA01";
+            fprintf(stderr, "Got different swizzling! Format: %c%c%c%c, "
+                    "View: %c%c%c%c\n",
+                    n[desc->swizzle[0]], n[desc->swizzle[1]],
+                    n[desc->swizzle[2]], n[desc->swizzle[3]],
+                    n[swizzle[0]], n[swizzle[1]], n[swizzle[2]],
+                    n[swizzle[3]]);
+        }
+    }*/
+
     for (i = 0; i < 4; i++) {
-        switch (desc->swizzle[i]) {
+        switch (swizzle[i]) {
             case UTIL_FORMAT_SWIZZLE_X:
             case UTIL_FORMAT_SWIZZLE_NONE:
-                result |= swizzle[0] << swizzle_shift[i];
+                result |= swizzle_bit[0] << swizzle_shift[i];
                 break;
             case UTIL_FORMAT_SWIZZLE_Y:
-                result |= swizzle[1] << swizzle_shift[i];
+                result |= swizzle_bit[1] << swizzle_shift[i];
                 break;
             case UTIL_FORMAT_SWIZZLE_Z:
-                result |= swizzle[2] << swizzle_shift[i];
+                result |= swizzle_bit[2] << swizzle_shift[i];
                 break;
             case UTIL_FORMAT_SWIZZLE_W:
-                result |= swizzle[3] << swizzle_shift[i];
+                result |= swizzle_bit[3] << swizzle_shift[i];
                 break;
             case UTIL_FORMAT_SWIZZLE_0:
                 result |= R300_TX_FORMAT_ZERO << swizzle_shift[i];
@@ -186,6 +215,13 @@ static uint32_t r300_translate_texformat(enum pipe_format format)
         }
     }
 
+    /* This is truly a special format.
+     * It stores R8G8 and B is computed using sqrt(1 - R^2 - G^2)
+     * in the sampler unit. Also known as D3DFMT_CxV8U8. */
+    if (format == PIPE_FORMAT_R8G8Bx_SNORM) {
+        return R300_TX_FORMAT_CxV8U8 | result;
+    }
+
     /* RGTC formats. */
     if (desc->layout == UTIL_FORMAT_LAYOUT_RGTC) {
         switch (format) {
@@ -310,7 +346,7 @@ static uint32_t r300_translate_texformat(enum pipe_format format)
     return ~0; /* Unsupported/unknown. */
 }
 
-static uint32_t r500_tx_format_msb_bit(enum pipe_format format)
+uint32_t r500_tx_format_msb_bit(enum pipe_format format)
 {
     switch (format) {
         case PIPE_FORMAT_RGTC1_UNORM:
@@ -339,10 +375,13 @@ static uint32_t r300_translate_colorformat(enum pipe_format format)
         /* 16-bit buffers. */
         case PIPE_FORMAT_B5G6R5_UNORM:
             return R300_COLOR_FORMAT_RGB565;
+
         case PIPE_FORMAT_B5G5R5A1_UNORM:
         case PIPE_FORMAT_B5G5R5X1_UNORM:
             return R300_COLOR_FORMAT_ARGB1555;
+
         case PIPE_FORMAT_B4G4R4A4_UNORM:
+        case PIPE_FORMAT_B4G4R4X4_UNORM:
             return R300_COLOR_FORMAT_ARGB4444;
 
         /* 32-bit buffers. */
@@ -353,9 +392,14 @@ static uint32_t r300_translate_colorformat(enum pipe_format format)
         case PIPE_FORMAT_A8B8G8R8_UNORM:
         case PIPE_FORMAT_R8G8B8A8_SNORM:
         case PIPE_FORMAT_X8B8G8R8_UNORM:
+        case PIPE_FORMAT_R8G8B8X8_UNORM:
         case PIPE_FORMAT_R8SG8SB8UX8U_NORM:
             return R300_COLOR_FORMAT_ARGB8888;
+
         case PIPE_FORMAT_R10G10B10A2_UNORM:
+        case PIPE_FORMAT_R10G10B10X2_SNORM:
+        case PIPE_FORMAT_B10G10R10A2_UNORM:
+        case PIPE_FORMAT_R10SG10SB10SA2U_NORM:
             return R500_COLOR_FORMAT_ARGB2101010;  /* R5xx-only? */
 
         /* 64-bit buffers. */
@@ -457,8 +501,10 @@ static uint32_t r300_translate_out_fmt(enum pipe_format format)
         case PIPE_FORMAT_B5G5R5A1_UNORM:
         case PIPE_FORMAT_B5G5R5X1_UNORM:
         case PIPE_FORMAT_B4G4R4A4_UNORM:
+        case PIPE_FORMAT_B4G4R4X4_UNORM:
         case PIPE_FORMAT_B8G8R8A8_UNORM:
         case PIPE_FORMAT_B8G8R8X8_UNORM:
+        case PIPE_FORMAT_B10G10R10A2_UNORM:
             return modifier |
                 R300_C0_SEL_B | R300_C1_SEL_G |
                 R300_C2_SEL_R | R300_C3_SEL_A;
@@ -478,9 +524,12 @@ static uint32_t r300_translate_out_fmt(enum pipe_format format)
                 R300_C2_SEL_G | R300_C3_SEL_R;
 
         /* RGBA outputs. */
+        case PIPE_FORMAT_R8G8B8X8_UNORM:
         case PIPE_FORMAT_R8G8B8A8_SNORM:
         case PIPE_FORMAT_R8SG8SB8UX8U_NORM:
         case PIPE_FORMAT_R10G10B10A2_UNORM:
+        case PIPE_FORMAT_R10G10B10X2_SNORM:
+        case PIPE_FORMAT_R10SG10SB10SA2U_NORM:
         case PIPE_FORMAT_R16G16B16A16_UNORM:
         case PIPE_FORMAT_R16G16B16A16_SNORM:
         //case PIPE_FORMAT_R16G16B16A16_FLOAT: /* not in pipe_format */
@@ -507,75 +556,83 @@ boolean r300_is_zs_format_supported(enum pipe_format format)
 
 boolean r300_is_sampler_format_supported(enum pipe_format format)
 {
-    return r300_translate_texformat(format) != ~0;
+    return r300_translate_texformat(format, 0) != ~0;
 }
 
-static void r300_setup_texture_state(struct r300_screen* screen, struct r300_texture* tex)
+static void r300_texture_setup_immutable_state(struct r300_screen* screen,
+                                               struct r300_texture* tex)
 {
-    struct r300_texture_format_state* state = &tex->state;
-    struct pipe_texture *pt = &tex->tex;
-    unsigned i;
-    boolean is_r500 = screen->caps->is_r500;
+    struct r300_texture_format_state* f = &tex->tx_format;
+    struct pipe_resource *pt = &tex->b.b;
+    boolean is_r500 = screen->caps.is_r500;
 
     /* Set sampler state. */
-    state->format0 = R300_TX_WIDTH((pt->width0 - 1) & 0x7ff) |
-                     R300_TX_HEIGHT((pt->height0 - 1) & 0x7ff);
+    f->format0 = R300_TX_WIDTH((pt->width0 - 1) & 0x7ff) |
+                 R300_TX_HEIGHT((pt->height0 - 1) & 0x7ff);
 
-    if (tex->is_npot) {
+    if (tex->uses_pitch) {
         /* rectangles love this */
-        state->format0 |= R300_TX_PITCH_EN;
-        state->format2 = (tex->pitch[0] - 1) & 0x1fff;
+        f->format0 |= R300_TX_PITCH_EN;
+        f->format2 = (tex->pitch[0] - 1) & 0x1fff;
     } else {
         /* power of two textures (3D, mipmaps, and no pitch) */
-        state->format0 |= R300_TX_DEPTH(util_logbase2(pt->depth0) & 0xf);
+        f->format0 |= R300_TX_DEPTH(util_logbase2(pt->depth0) & 0xf);
     }
 
-    state->format1 = r300_translate_texformat(pt->format);
+    f->format1 = 0;
     if (pt->target == PIPE_TEXTURE_CUBE) {
-        state->format1 |= R300_TX_FORMAT_CUBIC_MAP;
+        f->format1 |= R300_TX_FORMAT_CUBIC_MAP;
     }
     if (pt->target == PIPE_TEXTURE_3D) {
-        state->format1 |= R300_TX_FORMAT_3D;
+        f->format1 |= R300_TX_FORMAT_3D;
     }
 
     /* large textures on r500 */
     if (is_r500)
     {
         if (pt->width0 > 2048) {
-            state->format2 |= R500_TXWIDTH_BIT11;
+            f->format2 |= R500_TXWIDTH_BIT11;
         }
         if (pt->height0 > 2048) {
-            state->format2 |= R500_TXHEIGHT_BIT11;
+            f->format2 |= R500_TXHEIGHT_BIT11;
         }
-        state->format2 |= r500_tx_format_msb_bit(pt->format);
     }
 
+    f->tile_config = R300_TXO_MACRO_TILE(tex->macrotile) |
+                     R300_TXO_MICRO_TILE(tex->microtile);
+
     SCREEN_DBG(screen, DBG_TEX, "r300: Set texture state (%dx%d, %d levels)\n",
                pt->width0, pt->height0, pt->last_level);
+}
+
+static void r300_texture_setup_fb_state(struct r300_screen* screen,
+                                        struct r300_texture* tex)
+{
+    unsigned i;
 
     /* Set framebuffer state. */
-    if (util_format_is_depth_or_stencil(tex->tex.format)) {
-        for (i = 0; i <= tex->tex.last_level; i++) {
+    if (util_format_is_depth_or_stencil(tex->b.b.format)) {
+        for (i = 0; i <= tex->b.b.last_level; i++) {
             tex->fb_state.depthpitch[i] =
                 tex->pitch[i] |
                 R300_DEPTHMACROTILE(tex->mip_macrotile[i]) |
                 R300_DEPTHMICROTILE(tex->microtile);
         }
-        tex->fb_state.zb_format = r300_translate_zsformat(tex->tex.format);
+        tex->fb_state.zb_format = r300_translate_zsformat(tex->b.b.format);
     } else {
-        for (i = 0; i <= tex->tex.last_level; i++) {
+        for (i = 0; i <= tex->b.b.last_level; i++) {
             tex->fb_state.colorpitch[i] =
                 tex->pitch[i] |
-                r300_translate_colorformat(tex->tex.format) |
+                r300_translate_colorformat(tex->b.b.format) |
                 R300_COLOR_TILE(tex->mip_macrotile[i]) |
                 R300_COLOR_MICROTILE(tex->microtile);
         }
-        tex->fb_state.us_out_fmt = r300_translate_out_fmt(tex->tex.format);
+        tex->fb_state.us_out_fmt = r300_translate_out_fmt(tex->b.b.format);
     }
 }
 
 void r300_texture_reinterpret_format(struct pipe_screen *screen,
-                                     struct pipe_texture *tex,
+                                     struct pipe_resource *tex,
                                      enum pipe_format new_format)
 {
     struct r300_screen *r300screen = r300_screen(screen);
@@ -585,7 +642,7 @@ void r300_texture_reinterpret_format(struct pipe_screen *screen,
 
     tex->format = new_format;
 
-    r300_setup_texture_state(r300_screen(screen), (struct r300_texture*)tex);
+    r300_texture_setup_fb_state(r300_screen(screen), r300_texture(tex));
 }
 
 unsigned r300_texture_get_offset(struct r300_texture* tex, unsigned level,
@@ -593,7 +650,7 @@ unsigned r300_texture_get_offset(struct r300_texture* tex, unsigned level,
 {
     unsigned offset = tex->offset[level];
 
-    switch (tex->tex.target) {
+    switch (tex->b.b.target) {
         case PIPE_TEXTURE_3D:
             assert(face == 0);
             return offset + zslice * tex->layer_size[level];
@@ -617,7 +674,7 @@ static unsigned r300_texture_get_tile_size(struct r300_texture* tex,
 {
     unsigned pixsize, tile_size;
 
-    pixsize = util_format_get_blocksize(tex->tex.format);
+    pixsize = util_format_get_blocksize(tex->b.b.format);
     tile_size = microblock_table[util_logbase2(pixsize)][tex->microtile][dim];
 
     if (macrotile) {
@@ -638,9 +695,9 @@ static boolean r300_texture_macro_switch(struct r300_texture *tex,
 
     tile = r300_texture_get_tile_size(tex, dim, TRUE);
     if (dim == TILE_WIDTH) {
-        texdim = u_minify(tex->tex.width0, level);
+        texdim = u_minify(tex->b.b.width0, level);
     } else {
-        texdim = u_minify(tex->tex.height0, level);
+        texdim = u_minify(tex->b.b.height0, level);
     }
 
     /* See TX_FILTER1_n.MACRO_SWITCH. */
@@ -664,22 +721,22 @@ unsigned r300_texture_get_stride(struct r300_screen* screen,
         return tex->stride_override;
 
     /* Check the level. */
-    if (level > tex->tex.last_level) {
+    if (level > tex->b.b.last_level) {
         SCREEN_DBG(screen, DBG_TEX, "%s: level (%u) > last_level (%u)\n",
-                   __FUNCTION__, level, tex->tex.last_level);
+                   __FUNCTION__, level, tex->b.b.last_level);
         return 0;
     }
 
-    width = u_minify(tex->tex.width0, level);
+    width = u_minify(tex->b.b.width0, level);
 
-    if (r300_format_is_plain(tex->tex.format)) {
+    if (r300_format_is_plain(tex->b.b.format)) {
         tile_width = r300_texture_get_tile_size(tex, TILE_WIDTH,
                                                 tex->mip_macrotile[level]);
         width = align(width, tile_width);
 
-        return util_format_get_stride(tex->tex.format, width);
+        return util_format_get_stride(tex->b.b.format, width);
     } else {
-        return align(util_format_get_stride(tex->tex.format, width), 32);
+        return align(util_format_get_stride(tex->b.b.format, width), 32);
     }
 }
 
@@ -688,23 +745,49 @@ static unsigned r300_texture_get_nblocksy(struct r300_texture* tex,
 {
     unsigned height, tile_height;
 
-    height = u_minify(tex->tex.height0, level);
+    height = u_minify(tex->b.b.height0, level);
 
-    if (r300_format_is_plain(tex->tex.format)) {
+    if (r300_format_is_plain(tex->b.b.format)) {
         tile_height = r300_texture_get_tile_size(tex, TILE_HEIGHT,
                                                  tex->mip_macrotile[level]);
         height = align(height, tile_height);
+
+        /* This is needed for the kernel checker, unfortunately. */
+        height = util_next_power_of_two(height);
     }
 
-    return util_format_get_nblocksy(tex->tex.format, height);
+    return util_format_get_nblocksy(tex->b.b.format, height);
+}
+
+static void r300_texture_3d_fix_mipmapping(struct r300_screen *screen,
+                                           struct r300_texture *tex)
+{
+    /* The kernels <= 2.6.34-rc3 compute the size of mipmapped 3D textures
+     * incorrectly. This is a workaround to prevent CS from being rejected. */
+
+    unsigned i, size;
+
+    if (screen->rws->get_value(screen->rws, R300_VID_TEX3D_MIP_BUG) &&
+        tex->b.b.target == PIPE_TEXTURE_3D &&
+        tex->b.b.last_level > 0) {
+        size = 0;
+
+        for (i = 0; i <= tex->b.b.last_level; i++) {
+            size += r300_texture_get_stride(screen, tex, i) *
+                    r300_texture_get_nblocksy(tex, i);
+        }
+
+        size *= tex->b.b.depth0;
+        tex->size = size;
+    }
 }
 
 static void r300_setup_miptree(struct r300_screen* screen,
                                struct r300_texture* tex)
 {
-    struct pipe_texture* base = &tex->tex;
+    struct pipe_resource* base = &tex->b.b;
     unsigned stride, size, layer_size, nblocksy, i;
-    boolean rv350_mode = screen->caps->family >= CHIP_FAMILY_RV350;
+    boolean rv350_mode = screen->caps.family >= CHIP_FAMILY_RV350;
 
     SCREEN_DBG(screen, DBG_TEX, "r300: Making miptree for texture, format %s\n",
                util_format_name(base->format));
@@ -741,23 +824,24 @@ static void r300_setup_miptree(struct r300_screen* screen,
 
 static void r300_setup_flags(struct r300_texture* tex)
 {
-    tex->is_npot = !util_is_power_of_two(tex->tex.width0) ||
-                   !util_is_power_of_two(tex->tex.height0);
+    tex->uses_pitch = !util_is_power_of_two(tex->b.b.width0) ||
+                      !util_is_power_of_two(tex->b.b.height0) ||
+                      tex->stride_override;
 }
 
 static void r300_setup_tiling(struct pipe_screen *screen,
                               struct r300_texture *tex)
 {
     struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
-    enum pipe_format format = tex->tex.format;
-    boolean rv350_mode = r300_screen(screen)->caps->family >= CHIP_FAMILY_RV350;
+    enum pipe_format format = tex->b.b.format;
+    boolean rv350_mode = r300_screen(screen)->caps.family >= CHIP_FAMILY_RV350;
 
     if (!r300_format_is_plain(format)) {
         return;
     }
 
-    if (tex->tex.width0 == 1 ||
-        tex->tex.height0 == 1) {
+    if (tex->b.b.width0 == 1 ||
+        tex->b.b.height0 == 1) {
         return;
     }
 
@@ -783,9 +867,72 @@ static void r300_setup_tiling(struct pipe_screen *screen,
     }
 }
 
+static unsigned r300_texture_is_referenced(struct pipe_context *context,
+					 struct pipe_resource *texture,
+					 unsigned face, unsigned level)
+{
+    struct r300_context *r300 = r300_context(context);
+    struct r300_texture *rtex = (struct r300_texture *)texture;
+
+    if (r300->rws->is_buffer_referenced(r300->rws, rtex->buffer))
+        return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+
+    return PIPE_UNREFERENCED;
+}
+
+static void r300_texture_destroy(struct pipe_screen *screen,
+				 struct pipe_resource* texture)
+{
+    struct r300_texture* tex = (struct r300_texture*)texture;
+    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)texture->screen->winsys;
+
+    rws->buffer_reference(rws, &tex->buffer, NULL);
+    FREE(tex);
+}
+
+
+
+
+static boolean
+    r300_texture_get_handle(struct pipe_screen* screen,
+                            struct pipe_resource *texture,
+                            struct winsys_handle *whandle)
+{
+    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
+    struct r300_texture* tex = (struct r300_texture*)texture;
+    unsigned stride;
+
+    if (!tex) {
+        return FALSE;
+    }
+
+    stride = r300_texture_get_stride(r300_screen(screen), tex, 0);
+
+    rws->buffer_get_handle(rws, tex->buffer, stride, whandle);
+
+    return TRUE;
+}
+
+
+
+struct u_resource_vtbl r300_texture_vtbl = 
+{
+   r300_texture_get_handle,	      /* get_handle */
+   r300_texture_destroy,	      /* resource_destroy */
+   r300_texture_is_referenced,	      /* is_resource_referenced */
+   r300_texture_get_transfer,	      /* get_transfer */
+   r300_texture_transfer_destroy,     /* transfer_destroy */
+   r300_texture_transfer_map,	      /* transfer_map */
+   u_default_transfer_flush_region,   /* transfer_flush_region */
+   r300_texture_transfer_unmap,	      /* transfer_unmap */
+   u_default_transfer_inline_write    /* transfer_inline_write */
+};
+
+
+
 /* Create a new texture. */
-static struct pipe_texture* r300_texture_create(struct pipe_screen* screen,
-                                         const struct pipe_texture* template)
+struct pipe_resource* r300_texture_create(struct pipe_screen* screen,
+                                          const struct pipe_resource* base)
 {
     struct r300_texture* tex = CALLOC_STRUCT(r300_texture);
     struct r300_screen* rscreen = r300_screen(screen);
@@ -795,19 +942,23 @@ static struct pipe_texture* r300_texture_create(struct pipe_screen* screen,
         return NULL;
     }
 
-    tex->tex = *template;
-    pipe_reference_init(&tex->tex.reference, 1);
-    tex->tex.screen = screen;
+    tex->b.b = *base;
+    tex->b.vtbl = &r300_texture_vtbl;
+    pipe_reference_init(&tex->b.b.reference, 1);
+    tex->b.b.screen = screen;
 
     r300_setup_flags(tex);
-    if (!(template->tex_usage & R300_TEXTURE_USAGE_TRANSFER)) {
+    if (!(base->flags & R300_RESOURCE_FLAG_TRANSFER) &&
+        !(base->bind & PIPE_BIND_SCANOUT)) {
         r300_setup_tiling(screen, tex);
     }
     r300_setup_miptree(rscreen, tex);
-    r300_setup_texture_state(rscreen, tex);
+    r300_texture_3d_fix_mipmapping(rscreen, tex);
+    r300_texture_setup_immutable_state(rscreen, tex);
+    r300_texture_setup_fb_state(rscreen, tex);
 
     tex->buffer = rws->buffer_create(rws, 2048,
-				     PIPE_BUFFER_USAGE_PIXEL,
+				     PIPE_BIND_SAMPLER_VIEW, /* XXX */
 				     tex->size);
     rws->buffer_set_tiling(rws, tex->buffer,
 			   tex->pitch[0],
@@ -819,26 +970,21 @@ static struct pipe_texture* r300_texture_create(struct pipe_screen* screen,
         return NULL;
     }
 
-    return (struct pipe_texture*)tex;
+    return (struct pipe_resource*)tex;
 }
 
-static void r300_texture_destroy(struct pipe_texture* texture)
-{
-    struct r300_texture* tex = (struct r300_texture*)texture;
-    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)texture->screen->winsys;
 
-    rws->buffer_reference(rws, &tex->buffer, NULL);
-    FREE(tex);
-}
 
-static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
-                                                 struct pipe_texture* texture,
-                                                 unsigned face,
-                                                 unsigned level,
-                                                 unsigned zslice,
-                                                 unsigned flags)
+/* Not required to implement u_resource_vtbl, consider moving to another file:
+ */
+struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
+					  struct pipe_resource* texture,
+					  unsigned face,
+					  unsigned level,
+					  unsigned zslice,
+					  unsigned flags)
 {
-    struct r300_texture* tex = (struct r300_texture*)texture;
+    struct r300_texture* tex = r300_texture(texture);
     struct pipe_surface* surface = CALLOC_STRUCT(pipe_surface);
     unsigned offset;
 
@@ -846,7 +992,7 @@ static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
 
     if (surface) {
         pipe_reference_init(&surface->reference, 1);
-        pipe_texture_reference(&surface->texture, texture);
+        pipe_resource_reference(&surface->texture, texture);
         surface->format = texture->format;
         surface->width = u_minify(texture->width0, level);
         surface->height = u_minify(texture->height0, level);
@@ -861,23 +1007,25 @@ static struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
     return surface;
 }
 
-static void r300_tex_surface_destroy(struct pipe_surface* s)
+/* Not required to implement u_resource_vtbl, consider moving to another file:
+ */
+void r300_tex_surface_destroy(struct pipe_surface* s)
 {
-    pipe_texture_reference(&s->texture, NULL);
+    pipe_resource_reference(&s->texture, NULL);
     FREE(s);
 }
 
-
-static struct pipe_texture*
-    r300_texture_from_handle(struct pipe_screen* screen,
-                             const struct pipe_texture* base,
-                             struct winsys_handle *whandle)
+struct pipe_resource*
+r300_texture_from_handle(struct pipe_screen* screen,
+			  const struct pipe_resource* base,
+			  struct winsys_handle *whandle)
 {
     struct r300_winsys_screen *rws = (struct r300_winsys_screen*)screen->winsys;
     struct r300_screen* rscreen = r300_screen(screen);
     struct r300_winsys_buffer *buffer;
     struct r300_texture* tex;
     unsigned stride;
+    boolean override_zb_flags;
 
     /* Support only 2D textures without mipmaps */
     if (base->target != PIPE_TEXTURE_2D ||
@@ -896,122 +1044,51 @@ static struct pipe_texture*
         return NULL;
     }
 
-    tex->tex = *base;
-    pipe_reference_init(&tex->tex.reference, 1);
-    tex->tex.screen = screen;
+    tex->b.b = *base;
+    tex->b.vtbl = &r300_texture_vtbl;
+    pipe_reference_init(&tex->b.b.reference, 1);
+    tex->b.b.screen = screen;
 
     tex->stride_override = stride;
-    tex->pitch[0] = stride / util_format_get_blocksize(base->format);
-
-    r300_setup_flags(tex);
-    r300_setup_texture_state(rscreen, tex);
 
     /* one ref already taken */
     tex->buffer = buffer;
 
-    return (struct pipe_texture*)tex;
-}
-
-static boolean
-    r300_texture_get_handle(struct pipe_screen* screen,
-                            struct pipe_texture *texture,
-                            struct winsys_handle *whandle)
-{
-    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
-    struct r300_texture* tex = (struct r300_texture*)texture;
-    unsigned stride;
-
-    if (!tex) {
-        return FALSE;
-    }
-
-    stride = r300_texture_get_stride(r300_screen(screen), tex, 0);
-
-    rws->buffer_get_handle(rws, tex->buffer, stride, whandle);
-
-    return TRUE;
-}
-
-static struct pipe_video_surface *
-r300_video_surface_create(struct pipe_screen *screen,
-                          enum pipe_video_chroma_format chroma_format,
-                          unsigned width, unsigned height)
-{
-    struct r300_video_surface *r300_vsfc;
-    struct pipe_texture template;
-
-    assert(screen);
-    assert(width && height);
-
-    r300_vsfc = CALLOC_STRUCT(r300_video_surface);
-    if (!r300_vsfc)
-       return NULL;
-
-    pipe_reference_init(&r300_vsfc->base.reference, 1);
-    r300_vsfc->base.screen = screen;
-    r300_vsfc->base.chroma_format = chroma_format;
-    r300_vsfc->base.width = width;
-    r300_vsfc->base.height = height;
-
-    memset(&template, 0, sizeof(struct pipe_texture));
-    template.target = PIPE_TEXTURE_2D;
-    template.format = PIPE_FORMAT_B8G8R8X8_UNORM;
-    template.last_level = 0;
-    template.width0 = util_next_power_of_two(width);
-    template.height0 = util_next_power_of_two(height);
-    template.depth0 = 1;
-    template.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER |
-                         PIPE_TEXTURE_USAGE_RENDER_TARGET;
-
-    r300_vsfc->tex = screen->texture_create(screen, &template);
-    if (!r300_vsfc->tex)
-    {
-        FREE(r300_vsfc);
-        return NULL;
-    }
-
-    return &r300_vsfc->base;
-}
+    rws->buffer_get_tiling(rws, buffer, &tex->microtile, &tex->macrotile);
+    r300_setup_flags(tex);
 
-static void r300_video_surface_destroy(struct pipe_video_surface *vsfc)
-{
-    struct r300_video_surface *r300_vsfc = r300_video_surface(vsfc);
-    pipe_texture_reference(&r300_vsfc->tex, NULL);
-    FREE(r300_vsfc);
-}
+    /* Enforce microtiled zbuffer. */
+    override_zb_flags = util_format_is_depth_or_stencil(base->format) &&
+                        tex->microtile == R300_BUFFER_LINEAR;
 
-void r300_init_screen_texture_functions(struct pipe_screen* screen)
-{
-    screen->texture_create = r300_texture_create;
-    screen->texture_from_handle = r300_texture_from_handle;
-    screen->texture_get_handle = r300_texture_get_handle;
-    screen->texture_destroy = r300_texture_destroy;
-    screen->get_tex_surface = r300_get_tex_surface;
-    screen->tex_surface_destroy = r300_tex_surface_destroy;
-
-    screen->video_surface_create = r300_video_surface_create;
-    screen->video_surface_destroy= r300_video_surface_destroy;
-}
+    if (override_zb_flags) {
+        switch (util_format_get_blocksize(base->format)) {
+            case 4:
+                tex->microtile = R300_BUFFER_TILED;
+                break;
 
-boolean r300_get_texture_buffer(struct pipe_screen* screen,
-                                struct pipe_texture* texture,
-                                struct r300_winsys_buffer** buffer,
-                                unsigned* stride)
-{
-    struct r300_texture* tex = (struct r300_texture*)texture;
-    struct r300_winsys_screen *rws = (struct r300_winsys_screen *)screen->winsys;
-    struct r300_winsys_buffer *buf;
+            case 2:
+                if (rws->get_value(rws, R300_VID_SQUARE_TILING_SUPPORT)) {
+                    tex->microtile = R300_BUFFER_SQUARETILED;
+                    break;
+                }
+                /* Pass through. */
 
-    if (!tex) {
-        return FALSE;
+            default:
+                override_zb_flags = FALSE;
+        }
     }
 
-    rws->buffer_reference(rws, &buf, tex->buffer);
-
-    if (stride) {
-        *stride = r300_texture_get_stride(r300_screen(screen), tex, 0);
+    r300_setup_miptree(rscreen, tex);
+    r300_texture_setup_immutable_state(rscreen, tex);
+    r300_texture_setup_fb_state(rscreen, tex);
+
+    if (override_zb_flags) {
+        rws->buffer_set_tiling(rws, tex->buffer,
+                               tex->pitch[0],
+                               tex->microtile,
+                               tex->macrotile);
     }
-
-    *buffer = buf;
-    return TRUE;
+    return (struct pipe_resource*)tex;
 }
+
diff --git a/src/gallium/drivers/r300/r300_texture.h b/src/gallium/drivers/r300/r300_texture.h
index 60c7fa83420..7b8b40551da 100644
--- a/src/gallium/drivers/r300/r300_texture.h
+++ b/src/gallium/drivers/r300/r300_texture.h
@@ -23,14 +23,14 @@
 #ifndef R300_TEXTURE_H
 #define R300_TEXTURE_H
 
-#include "pipe/p_video_state.h"
 #include "util/u_format.h"
 
-#include "r300_reg.h"
-
 struct r300_texture;
 
-void r300_init_screen_texture_functions(struct pipe_screen* screen);
+uint32_t r300_translate_texformat(enum pipe_format format,
+                                  const unsigned char *swizzle);
+
+uint32_t r500_tx_format_msb_bit(enum pipe_format format);
 
 unsigned r300_texture_get_stride(struct r300_screen* screen,
                                  struct r300_texture* tex, unsigned level);
@@ -39,7 +39,7 @@ unsigned r300_texture_get_offset(struct r300_texture* tex, unsigned level,
                                  unsigned zslice, unsigned face);
 
 void r300_texture_reinterpret_format(struct pipe_screen *screen,
-                                     struct pipe_texture *tex,
+                                     struct pipe_resource *tex,
                                      enum pipe_format new_format);
 
 boolean r300_is_colorbuffer_format_supported(enum pipe_format format);
@@ -48,23 +48,24 @@ boolean r300_is_zs_format_supported(enum pipe_format format);
 
 boolean r300_is_sampler_format_supported(enum pipe_format format);
 
-struct r300_video_surface
-{
-    struct pipe_video_surface   base;
-    struct pipe_texture         *tex;
-};
-
-static INLINE struct r300_video_surface *
-r300_video_surface(struct pipe_video_surface *pvs)
-{
-    return (struct r300_video_surface *)pvs;
-}
-
-/* Used internally for texture_is_referenced()
- */
-boolean r300_get_texture_buffer(struct pipe_screen* screen,
-                                struct pipe_texture *texture,
-                                struct r300_winsys_buffer** buffer,
-                                unsigned* stride);
+
+struct pipe_resource*
+r300_texture_from_handle(struct pipe_screen* screen,
+			 const struct pipe_resource* base,
+			 struct winsys_handle *whandle);
+
+struct pipe_resource*
+r300_texture_create(struct pipe_screen* screen,
+		    const struct pipe_resource* template);
+
+
+struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen,
+					  struct pipe_resource* texture,
+					  unsigned face,
+					  unsigned level,
+					  unsigned zslice,
+					  unsigned flags);
+
+void r300_tex_surface_destroy(struct pipe_surface* s);
 
 #endif /* R300_TEXTURE_H */
diff --git a/src/gallium/drivers/r300/r300_tgsi_to_rc.c b/src/gallium/drivers/r300/r300_tgsi_to_rc.c
index 3b3802ee2b2..21a1c45982d 100644
--- a/src/gallium/drivers/r300/r300_tgsi_to_rc.c
+++ b/src/gallium/drivers/r300/r300_tgsi_to_rc.c
@@ -383,4 +383,3 @@ void r300_tgsi_to_rc(struct tgsi_to_rc * ttr,
 
     rc_calculate_inputs_outputs(ttr->compiler);
 }
-
diff --git a/src/gallium/drivers/r300/r300_transfer.c b/src/gallium/drivers/r300/r300_transfer.c
index 987a040698f..e4df7504550 100644
--- a/src/gallium/drivers/r300/r300_transfer.c
+++ b/src/gallium/drivers/r300/r300_transfer.c
@@ -38,9 +38,6 @@ struct r300_transfer {
     /* Pipe context. */
     struct pipe_context *ctx;
 
-    /* Parameters of get_tex_transfer. */
-    unsigned x, y, level, zslice, face;
-
     /* Offset from start of buffer. */
     unsigned offset;
 
@@ -48,7 +45,7 @@ struct r300_transfer {
     struct r300_texture *detiled_texture;
 
     /* Transfer and format flags. */
-    unsigned buffer_usage, render_target_usage;
+    unsigned render_target_usage;
 };
 
 /* Convenience cast wrapper. */
@@ -64,22 +61,22 @@ static void r300_copy_from_tiled_texture(struct pipe_context *ctx,
 {
     struct pipe_screen *screen = ctx->screen;
     struct pipe_transfer *transfer = (struct pipe_transfer*)r300transfer;
-    struct pipe_texture *tex = transfer->texture;
+    struct pipe_resource *tex = transfer->resource;
     struct pipe_surface *src, *dst;
 
-    src = screen->get_tex_surface(screen, tex, r300transfer->face,
-                                  r300transfer->level, r300transfer->zslice,
-                                  PIPE_BUFFER_USAGE_GPU_READ |
-                                  PIPE_BUFFER_USAGE_PIXEL);
+    src = screen->get_tex_surface(screen, tex,
+				  transfer->sr.face,
+                                  transfer->sr.level,
+				  transfer->box.z,
+				  PIPE_BIND_BLIT_SOURCE);
 
-    dst = screen->get_tex_surface(screen, &r300transfer->detiled_texture->tex,
+    dst = screen->get_tex_surface(screen, &r300transfer->detiled_texture->b.b,
                                   0, 0, 0,
-                                  PIPE_BUFFER_USAGE_GPU_WRITE |
-                                  PIPE_BUFFER_USAGE_PIXEL |
-                                  r300transfer->buffer_usage);
+                                  PIPE_BIND_BLIT_DESTINATION);
 
-    ctx->surface_copy(ctx, dst, 0, 0, src, r300transfer->x, r300transfer->y,
-                      transfer->width, transfer->height);
+    ctx->surface_copy(ctx, dst, 0, 0, src, 
+		      transfer->box.x, transfer->box.y,
+                      transfer->box.width, transfer->box.height);
 
     pipe_surface_reference(&src, NULL);
     pipe_surface_reference(&dst, NULL);
@@ -91,26 +88,28 @@ static void r300_copy_into_tiled_texture(struct pipe_context *ctx,
 {
     struct pipe_screen *screen = ctx->screen;
     struct pipe_transfer *transfer = (struct pipe_transfer*)r300transfer;
-    struct pipe_texture *tex = transfer->texture;
+    struct pipe_resource *tex = transfer->resource;
     struct pipe_surface *src, *dst;
 
-    src = screen->get_tex_surface(screen, &r300transfer->detiled_texture->tex,
+    src = screen->get_tex_surface(screen, &r300transfer->detiled_texture->b.b,
                                   0, 0, 0,
-                                  PIPE_BUFFER_USAGE_GPU_READ |
-                                  PIPE_BUFFER_USAGE_PIXEL);
+                                  PIPE_BIND_BLIT_SOURCE);
 
-    dst = screen->get_tex_surface(screen, tex, r300transfer->face,
-                                  r300transfer->level, r300transfer->zslice,
-                                  PIPE_BUFFER_USAGE_GPU_WRITE |
-                                  PIPE_BUFFER_USAGE_PIXEL);
+    dst = screen->get_tex_surface(screen, tex,
+				  transfer->sr.face,
+                                  transfer->sr.level,
+				  transfer->box.z,
+                                  PIPE_BIND_BLIT_DESTINATION);
 
     /* XXX this flush prevents the following DRM error from occuring:
      * [drm:radeon_cs_ioctl] *ERROR* Failed to parse relocation !
      * Reproducible with perf/copytex. */
     ctx->flush(ctx, 0, NULL);
 
-    ctx->surface_copy(ctx, dst, r300transfer->x, r300transfer->y, src, 0, 0,
-                      transfer->width, transfer->height);
+    ctx->surface_copy(ctx, dst,
+		      transfer->box.x, transfer->box.y,
+		      src, 0, 0,
+                      transfer->box.width, transfer->box.height);
 
     /* XXX this flush fixes a few piglit tests (e.g. glean/pixelFormats). */
     ctx->flush(ctx, 0, NULL);
@@ -119,72 +118,72 @@ static void r300_copy_into_tiled_texture(struct pipe_context *ctx,
     pipe_surface_reference(&dst, NULL);
 }
 
-static struct pipe_transfer*
-r300_get_tex_transfer(struct pipe_context *ctx,
-                      struct pipe_texture *texture,
-                      unsigned face, unsigned level, unsigned zslice,
-                      enum pipe_transfer_usage usage, unsigned x, unsigned y,
-                      unsigned w, unsigned h)
+struct pipe_transfer*
+r300_texture_get_transfer(struct pipe_context *ctx,
+			  struct pipe_resource *texture,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box)
 {
-    struct r300_texture *tex = (struct r300_texture *)texture;
+    struct r300_texture *tex = r300_texture(texture);
     struct r300_screen *r300screen = r300_screen(ctx->screen);
     struct r300_transfer *trans;
-    struct pipe_texture template;
+    struct pipe_resource base;
 
     trans = CALLOC_STRUCT(r300_transfer);
     if (trans) {
         /* Initialize the transfer object. */
-        pipe_texture_reference(&trans->transfer.texture, texture);
+        pipe_resource_reference(&trans->transfer.resource, texture);
+        trans->transfer.sr = sr;
         trans->transfer.usage = usage;
-        trans->transfer.width = w;
-        trans->transfer.height = h;
+        trans->transfer.box = *box;
         trans->ctx = ctx;
-        trans->x = x;
-        trans->y = y;
-        trans->level = level;
-        trans->zslice = zslice;
-        trans->face = face;
 
         /* If the texture is tiled, we must create a temporary detiled texture
          * for this transfer. */
         if (tex->microtile || tex->macrotile) {
-            trans->buffer_usage = pipe_transfer_buffer_flags(&trans->transfer);
             trans->render_target_usage =
                 util_format_is_depth_or_stencil(texture->format) ?
-                PIPE_TEXTURE_USAGE_DEPTH_STENCIL :
-                PIPE_TEXTURE_USAGE_RENDER_TARGET;
-
-            template.target = PIPE_TEXTURE_2D;
-            template.format = texture->format;
-            template.width0 = w;
-            template.height0 = h;
-            template.depth0 = 0;
-            template.last_level = 0;
-            template.nr_samples = 0;
-            template.tex_usage = PIPE_TEXTURE_USAGE_DYNAMIC |
-                                 R300_TEXTURE_USAGE_TRANSFER;
+                PIPE_BIND_DEPTH_STENCIL :
+                PIPE_BIND_RENDER_TARGET;
+
+            base.target = PIPE_TEXTURE_2D;
+            base.format = texture->format;
+            base.width0 = box->width;
+            base.height0 = box->height;
+            base.depth0 = 0;
+            base.last_level = 0;
+            base.nr_samples = 0;
+            base._usage = PIPE_USAGE_DYNAMIC;
+            base.bind = 0;
+	    base.flags = R300_RESOURCE_FLAG_TRANSFER;
 
             /* For texture reading, the temporary (detiled) texture is used as
              * a render target when blitting from a tiled texture. */
             if (usage & PIPE_TRANSFER_READ) {
-                template.tex_usage |= trans->render_target_usage;
+                base.bind |= trans->render_target_usage;
             }
             /* For texture writing, the temporary texture is used as a sampler
              * when blitting into a tiled texture. */
             if (usage & PIPE_TRANSFER_WRITE) {
-                template.tex_usage |= PIPE_TEXTURE_USAGE_SAMPLER;
+                base.bind |= PIPE_BIND_SAMPLER_VIEW;
             }
 
             /* Create the temporary texture. */
-            trans->detiled_texture = (struct r300_texture*)
-               ctx->screen->texture_create(ctx->screen,
-                                           &template);
+            trans->detiled_texture = r300_texture(
+               ctx->screen->resource_create(ctx->screen,
+                                            &base));
 
             assert(!trans->detiled_texture->microtile &&
                    !trans->detiled_texture->macrotile);
 
             /* Set the stride.
-             * Parameters x, y, level, zslice, and face remain zero. */
+	     *
+	     * Even though we are using an internal texture for this,
+	     * the transfer sr, box and usage parameters still reflect
+	     * the arguments received to get_transfer.  We just do the
+	     * right thing internally.
+	     */
             trans->transfer.stride =
                 r300_texture_get_stride(r300screen, trans->detiled_texture, 0);
 
@@ -194,21 +193,16 @@ r300_get_tex_transfer(struct pipe_context *ctx,
                 r300_copy_from_tiled_texture(ctx, trans);
             }
         } else {
-            trans->transfer.x = x;
-            trans->transfer.y = y;
             trans->transfer.stride =
-                r300_texture_get_stride(r300screen, tex, level);
-            trans->transfer.level = level;
-            trans->transfer.zslice = zslice;
-            trans->transfer.face = face;
-            trans->offset = r300_texture_get_offset(tex, level, zslice, face);
+                r300_texture_get_stride(r300screen, tex, sr.level);
+            trans->offset = r300_texture_get_offset(tex, sr.level, box->z, sr.face);
         }
     }
     return &trans->transfer;
 }
 
-static void r300_tex_transfer_destroy(struct pipe_context *ctx,
-                                      struct pipe_transfer *trans)
+void r300_texture_transfer_destroy(struct pipe_context *ctx,
+				   struct pipe_transfer *trans)
 {
     struct r300_transfer *r300transfer = r300_transfer(trans);
 
@@ -217,49 +211,49 @@ static void r300_tex_transfer_destroy(struct pipe_context *ctx,
             r300_copy_into_tiled_texture(r300transfer->ctx, r300transfer);
         }
 
-        pipe_texture_reference(
-            (struct pipe_texture**)&r300transfer->detiled_texture, NULL);
+        pipe_resource_reference(
+            (struct pipe_resource**)&r300transfer->detiled_texture, NULL);
     }
-    pipe_texture_reference(&trans->texture, NULL);
+    pipe_resource_reference(&trans->resource, NULL);
     FREE(trans);
 }
 
-static void* r300_transfer_map(struct pipe_context *ctx,
-                               struct pipe_transfer *transfer)
+void* r300_texture_transfer_map(struct pipe_context *ctx,
+				struct pipe_transfer *transfer)
 {
     struct r300_winsys_screen *rws = (struct r300_winsys_screen *)ctx->winsys;
     struct r300_transfer *r300transfer = r300_transfer(transfer);
-    struct r300_texture *tex = (struct r300_texture*)transfer->texture;
+    struct r300_texture *tex = r300_texture(transfer->resource);
     char *map;
-    enum pipe_format format = tex->tex.format;
+    enum pipe_format format = tex->b.b.format;
 
     if (r300transfer->detiled_texture) {
         /* The detiled texture is of the same size as the region being mapped
          * (no offset needed). */
         return rws->buffer_map(rws,
                                r300transfer->detiled_texture->buffer,
-                               pipe_transfer_buffer_flags(transfer));
+                               transfer->usage);
     } else {
         /* Tiling is disabled. */
         map = rws->buffer_map(rws, tex->buffer,
-                              pipe_transfer_buffer_flags(transfer));
+                              transfer->usage);
 
         if (!map) {
             return NULL;
         }
 
         return map + r300_transfer(transfer)->offset +
-            transfer->y / util_format_get_blockheight(format) * transfer->stride +
-            transfer->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
+            transfer->box.y / util_format_get_blockheight(format) * transfer->stride +
+            transfer->box.x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
     }
 }
 
-static void r300_transfer_unmap(struct pipe_context *ctx,
-                                struct pipe_transfer *transfer)
+void r300_texture_transfer_unmap(struct pipe_context *ctx,
+				 struct pipe_transfer *transfer)
 {
     struct r300_winsys_screen *rws = (struct r300_winsys_screen *)ctx->winsys;
     struct r300_transfer *r300transfer = r300_transfer(transfer);
-    struct r300_texture *tex = (struct r300_texture*)transfer->texture;
+    struct r300_texture *tex = r300_texture(transfer->resource);
 
     if (r300transfer->detiled_texture) {
 	rws->buffer_unmap(rws, r300transfer->detiled_texture->buffer);
@@ -268,13 +262,3 @@ static void r300_transfer_unmap(struct pipe_context *ctx,
     }
 }
 
-
-void r300_init_transfer_functions( struct r300_context *r300ctx )
-{
-   struct pipe_context *ctx = &r300ctx->context;
-
-   ctx->get_tex_transfer = r300_get_tex_transfer;
-   ctx->tex_transfer_destroy = r300_tex_transfer_destroy;
-   ctx->transfer_map = r300_transfer_map;
-   ctx->transfer_unmap = r300_transfer_unmap;
-}
diff --git a/src/gallium/drivers/r300/r300_transfer.h b/src/gallium/drivers/r300/r300_transfer.h
index 79baf6d0480..d72e54e5ed9 100644
--- a/src/gallium/drivers/r300/r300_transfer.h
+++ b/src/gallium/drivers/r300/r300_transfer.h
@@ -28,6 +28,24 @@
 
 struct r300_context;
 
-void r300_init_transfer_functions(struct r300_context *r300ctx);
+struct pipe_transfer*
+r300_texture_get_transfer(struct pipe_context *ctx,
+			  struct pipe_resource *texture,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box);
+
+void
+r300_texture_transfer_destroy(struct pipe_context *ctx,
+			      struct pipe_transfer *trans);
+
+void*
+r300_texture_transfer_map(struct pipe_context *ctx,
+			  struct pipe_transfer *transfer);
+
+void
+r300_texture_transfer_unmap(struct pipe_context *ctx,
+			    struct pipe_transfer *transfer);
+
 
 #endif
diff --git a/src/gallium/drivers/r300/r300_vs.c b/src/gallium/drivers/r300/r300_vs.c
index d5690caa68e..bfab9c3b014 100644
--- a/src/gallium/drivers/r300/r300_vs.c
+++ b/src/gallium/drivers/r300/r300_vs.c
@@ -31,6 +31,7 @@
 
 #include "tgsi/tgsi_dump.h"
 #include "tgsi/tgsi_parse.h"
+#include "tgsi/tgsi_ureg.h"
 
 #include "radeon_compiler.h"
 
@@ -80,11 +81,12 @@ static void r300_shader_read_vs_outputs(
 
             case TGSI_SEMANTIC_EDGEFLAG:
                 assert(index == 0);
-                fprintf(stderr, "r300 VP: cannot handle edgeflag output\n");
-                assert(0);
+                fprintf(stderr, "r300 VP: cannot handle edgeflag output.\n");
                 break;
+
             default:
-                assert(0);
+                fprintf(stderr, "r300 VP: unknown vertex output semantic: %i.\n",
+                        info->output_semantic_name[i]);
         }
     }
 
@@ -148,35 +150,32 @@ static void r300_init_vs_output_mapping(struct r300_vertex_shader* vs)
 
     /* Texture coordinates. */
     gen_count = 0;
-    for (i = 0; i < ATTR_GENERIC_COUNT; i++) {
+    for (i = 0; i < ATTR_GENERIC_COUNT && gen_count < 8; i++) {
         if (vs_outputs->generic[i] != ATTR_UNUSED) {
             vap_out->vap_vsm_vtx_assm |= (R300_INPUT_CNTL_TC0 << gen_count);
             vap_out->vap_out_vtx_fmt[1] |= (4 << (3 * gen_count));
 
-            assert(tabi < 16);
             stream_loc[tabi++] = 6 + gen_count;
             gen_count++;
         }
     }
 
     /* Fog coordinates. */
-    if (vs_outputs->fog != ATTR_UNUSED) {
+    if (gen_count < 8 && vs_outputs->fog != ATTR_UNUSED) {
         vap_out->vap_vsm_vtx_assm |= (R300_INPUT_CNTL_TC0 << gen_count);
         vap_out->vap_out_vtx_fmt[1] |= (4 << (3 * gen_count));
 
-        assert(tabi < 16);
         stream_loc[tabi++] = 6 + gen_count;
         gen_count++;
     }
 
-    /* XXX magic */
-    assert(gen_count <= 8);
-
     /* WPOS. */
-    vs->wpos_tex_output = gen_count;
-
-    assert(tabi < 16);
-    stream_loc[tabi++] = 6 + gen_count;
+    if (gen_count < 8) {
+        vs->wpos_tex_output = gen_count;
+        stream_loc[tabi++] = 6 + gen_count;
+    } else {
+        vs_outputs->wpos = ATTR_UNUSED;
+    }
 
     for (; tabi < 16;) {
         stream_loc[tabi++] = -1;
@@ -252,24 +251,43 @@ static void set_vertex_inputs_outputs(struct r300_vertex_program_compiler * c)
     }
 }
 
-void r300_vertex_shader_common_init(struct r300_vertex_shader *vs,
-                                    const struct pipe_shader_state *shader)
+static void r300_dummy_vertex_shader(
+    struct r300_context* r300,
+    struct r300_vertex_shader* shader)
 {
-    /* Copy state directly into shader. */
-    vs->state = *shader;
-    vs->state.tokens = tgsi_dup_tokens(shader->tokens);
-    tgsi_scan_shader(shader->tokens, &vs->info);
+    struct pipe_shader_state state;
+    struct ureg_program *ureg;
+    struct ureg_dst dst;
+    struct ureg_src imm;
 
-    r300_shader_read_vs_outputs(&vs->info, &vs->outputs);
-    r300_init_vs_output_mapping(vs);
+    /* Make a simple vertex shader which outputs (0, 0, 0, 1),
+     * effectively rendering nothing. */
+    ureg = ureg_create(TGSI_PROCESSOR_VERTEX);
+    dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
+    imm = ureg_imm4f(ureg, 0, 0, 0, 1);
+
+    ureg_MOV(ureg, dst, imm);
+    ureg_END(ureg);
+
+    state.tokens = ureg_finalize(ureg);
+
+    shader->dummy = TRUE;
+    r300_translate_vertex_shader(r300, shader, state.tokens);
+
+    ureg_destroy(ureg);
 }
 
 void r300_translate_vertex_shader(struct r300_context* r300,
-                                  struct r300_vertex_shader* vs)
+                                  struct r300_vertex_shader* vs,
+                                  const struct tgsi_token *tokens)
 {
     struct r300_vertex_program_compiler compiler;
     struct tgsi_to_rc ttr;
 
+    tgsi_scan_shader(tokens, &vs->info);
+    r300_shader_read_vs_outputs(&vs->info, &vs->outputs);
+    r300_init_vs_output_mapping(vs);
+
     /* Setup the compiler */
     rc_init(&compiler.Base);
 
@@ -279,7 +297,7 @@ void r300_translate_vertex_shader(struct r300_context* r300,
 
     if (compiler.Base.Debug) {
         debug_printf("r300: Initial vertex program\n");
-        tgsi_dump(vs->state.tokens, 0);
+        tgsi_dump(tokens, 0);
     }
 
     /* Translate TGSI to our internal representation */
@@ -287,22 +305,41 @@ void r300_translate_vertex_shader(struct r300_context* r300,
     ttr.info = &vs->info;
     ttr.use_half_swizzles = FALSE;
 
-    r300_tgsi_to_rc(&ttr, vs->state.tokens);
+    r300_tgsi_to_rc(&ttr, tokens);
+
+    compiler.RequiredOutputs =
+        ~(~0 << (vs->info.num_outputs +
+                 (vs->outputs.wpos != ATTR_UNUSED ? 1 : 0)));
 
-    compiler.RequiredOutputs = ~(~0 << (vs->info.num_outputs+1));
     compiler.SetHwInputOutput = &set_vertex_inputs_outputs;
 
     /* Insert the WPOS output. */
-    rc_copy_output(&compiler.Base, 0, vs->outputs.wpos);
+    if (vs->outputs.wpos != ATTR_UNUSED) {
+        rc_copy_output(&compiler.Base, 0, vs->outputs.wpos);
+    }
 
     /* Invoke the compiler */
     r3xx_compile_vertex_program(&compiler);
     if (compiler.Base.Error) {
         /* XXX We should fallback using Draw. */
-        fprintf(stderr, "r300 VP: Compiler error:\n%s", compiler.Base.ErrorMsg);
-        abort();
+        fprintf(stderr, "r300 VP: Compiler error:\n%sUsing a dummy shader"
+                " instead.\n", compiler.Base.ErrorMsg);
+
+        if (vs->dummy) {
+            fprintf(stderr, "r300 VP: Cannot compile the dummy shader! "
+                    "Giving up...\n");
+            abort();
+        }
+
+        rc_destroy(&compiler.Base);
+        r300_dummy_vertex_shader(r300, vs);
+        return;
     }
 
+    /* Initialize numbers of constants for each type. */
+    vs->externals_count = ttr.immediate_offset;
+    vs->immediates_count = vs->code.constants.Count - vs->externals_count;
+
     /* And, finally... */
     rc_destroy(&compiler.Base);
 }
@@ -314,13 +351,15 @@ boolean r300_vertex_shader_setup_wpos(struct r300_context* r300)
     int tex_output = vs->wpos_tex_output;
     uint32_t tex_fmt = R300_INPUT_CNTL_TC0 << tex_output;
 
-    if (r300->fs->inputs.wpos != ATTR_UNUSED) {
+    if (vs->outputs.wpos == ATTR_UNUSED) {
+        return FALSE;
+    }
+
+    if (r300_fs(r300)->shader->inputs.wpos != ATTR_UNUSED) {
         /* Enable WPOS in VAP. */
         if (!(vap_out->vap_vsm_vtx_assm & tex_fmt)) {
             vap_out->vap_vsm_vtx_assm |= tex_fmt;
             vap_out->vap_out_vtx_fmt[1] |= (4 << (3 * tex_output));
-
-            assert(tex_output < 8);
             return TRUE;
         }
     } else {
diff --git a/src/gallium/drivers/r300/r300_vs.h b/src/gallium/drivers/r300/r300_vs.h
index f6f0b86b683..56bcc3b70b8 100644
--- a/src/gallium/drivers/r300/r300_vs.h
+++ b/src/gallium/drivers/r300/r300_vs.h
@@ -41,6 +41,14 @@ struct r300_vertex_shader {
     struct r300_shader_semantics outputs;
     struct r300_vap_output_state vap_out;
 
+    /* Whether the shader was replaced by a dummy one due to a shader
+     * compilation failure. */
+    boolean dummy;
+
+    /* Numbers of constants for each type. */
+    unsigned externals_count;
+    unsigned immediates_count;
+
     /* Stream locations for SWTCL or if TCL is bypassed. */
     int stream_loc_notcl[16];
 
@@ -55,11 +63,9 @@ struct r300_vertex_shader {
     void *draw_vs;
 };
 
-void r300_vertex_shader_common_init(struct r300_vertex_shader *vs,
-                                    const struct pipe_shader_state *shader);
-
 void r300_translate_vertex_shader(struct r300_context* r300,
-                                  struct r300_vertex_shader* vs);
+                                  struct r300_vertex_shader* vs,
+                                  const struct tgsi_token *tokens);
 
 /* Return TRUE if VAP (hwfmt) needs to be re-emitted. */
 boolean r300_vertex_shader_setup_wpos(struct r300_context* r300);
diff --git a/src/gallium/drivers/r300/r300_winsys.h b/src/gallium/drivers/r300/r300_winsys.h
index acfa5dbeb9c..5ac997c8680 100644
--- a/src/gallium/drivers/r300/r300_winsys.h
+++ b/src/gallium/drivers/r300/r300_winsys.h
@@ -39,17 +39,19 @@ struct pipe_screen* r300_create_screen(struct r300_winsys_screen *rws);
 
 struct r300_winsys_buffer;
 
+/* XXX: this is just a bandaid on larger problems in
+ * r300_screen_buffer.h which doesn't seem to be fully ported to
+ * gallium-resources.
+ */
+#define R300_BIND_OQBO  (1<<21)
 
-boolean r300_get_texture_buffer(struct pipe_screen* screen,
-                                struct pipe_texture* texture,
-                                struct r300_winsys_buffer** buffer,
-                                unsigned *stride);
 
 enum r300_value_id {
     R300_VID_PCI_ID,
     R300_VID_GB_PIPES,
     R300_VID_Z_PIPES,
-    R300_VID_SQUARE_TILING_SUPPORT
+    R300_VID_SQUARE_TILING_SUPPORT,
+    R300_VID_TEX3D_MIP_BUG,
 };
 
 struct r300_winsys_screen {
@@ -100,7 +102,7 @@ struct r300_winsys_screen {
 			       unsigned offset,
 			       unsigned length);
 
-    /* Add a pipe_buffer to the list of buffer objects to validate. */
+    /* Add a pipe_resource to the list of buffer objects to validate. */
     boolean (*add_buffer)(struct r300_winsys_screen *winsys,
                           struct r300_winsys_buffer *buf,
                           uint32_t rd,
@@ -146,6 +148,11 @@ struct r300_winsys_screen {
 
     void (*reset_bos)(struct r300_winsys_screen *winsys);
 
+    void (*buffer_get_tiling)(struct r300_winsys_screen *winsys,
+                              struct r300_winsys_buffer *buffer,
+                              enum r300_buffer_tiling *microtiled,
+                              enum r300_buffer_tiling *macrotiled);
+
     void (*buffer_set_tiling)(struct r300_winsys_screen *winsys,
                               struct r300_winsys_buffer *buffer,
                               uint32_t pitch,
diff --git a/src/gallium/drivers/softpipe/Makefile b/src/gallium/drivers/softpipe/Makefile
index 239655d628b..83f3e4a19b6 100644
--- a/src/gallium/drivers/softpipe/Makefile
+++ b/src/gallium/drivers/softpipe/Makefile
@@ -6,7 +6,6 @@ LIBNAME = softpipe
 C_SOURCES = \
 	sp_fs_exec.c \
 	sp_fs_sse.c \
-	sp_buffer.c \
 	sp_clear.c \
 	sp_fence.c \
 	sp_flush.c \
@@ -33,7 +32,6 @@ C_SOURCES = \
 	sp_tex_sample.c \
 	sp_tex_tile_cache.c \
 	sp_tile_cache.c \
-	sp_surface.c \
-	sp_video_context.c
+	sp_surface.c
 
 include ../../Makefile.template
diff --git a/src/gallium/drivers/softpipe/SConscript b/src/gallium/drivers/softpipe/SConscript
index 9949a53adfd..b80c6dea93a 100644
--- a/src/gallium/drivers/softpipe/SConscript
+++ b/src/gallium/drivers/softpipe/SConscript
@@ -7,7 +7,6 @@ softpipe = env.ConvenienceLibrary(
 	source = [
 		'sp_fs_exec.c',
 		'sp_fs_sse.c',
-		'sp_buffer.c',
 		'sp_clear.c',
 		'sp_context.c',
 		'sp_draw_arrays.c',
@@ -35,7 +34,6 @@ softpipe = env.ConvenienceLibrary(
 		'sp_tex_tile_cache.c',
 		'sp_texture.c',
 		'sp_tile_cache.c',
-		'sp_video_context.c'
 	])
 
 Export('softpipe')
diff --git a/src/gallium/drivers/softpipe/sp_buffer.c b/src/gallium/drivers/softpipe/sp_buffer.c
deleted file mode 100644
index 8f390250869..00000000000
--- a/src/gallium/drivers/softpipe/sp_buffer.c
+++ /dev/null
@@ -1,118 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.
- * 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 VMWARE 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.
- *
- **************************************************************************/
-
-
-#include "util/u_inlines.h"
-#include "util/u_memory.h"
-#include "util/u_math.h"
-
-#include "sp_screen.h"
-#include "sp_buffer.h"
-
-
-static void *
-softpipe_buffer_map(struct pipe_screen *screen,
-                    struct pipe_buffer *buf,
-                    unsigned flags)
-{
-   struct softpipe_buffer *softpipe_buf = softpipe_buffer(buf);
-   return softpipe_buf->data;
-}
-
-
-static void
-softpipe_buffer_unmap(struct pipe_screen *screen,
-                      struct pipe_buffer *buf)
-{
-}
-
-
-static void
-softpipe_buffer_destroy(struct pipe_buffer *buf)
-{
-   struct softpipe_buffer *sbuf = softpipe_buffer(buf);
-
-   if (!sbuf->userBuffer)
-      align_free(sbuf->data);
-      
-   FREE(sbuf);
-}
-
-
-static struct pipe_buffer *
-softpipe_buffer_create(struct pipe_screen *screen,
-                       unsigned alignment,
-                       unsigned usage,
-                       unsigned size)
-{
-   struct softpipe_buffer *buffer = CALLOC_STRUCT(softpipe_buffer);
-
-   pipe_reference_init(&buffer->base.reference, 1);
-   buffer->base.screen = screen;
-   buffer->base.alignment = MAX2(alignment, 16);
-   buffer->base.usage = usage;
-   buffer->base.size = size;
-
-   buffer->data = align_malloc(size, alignment);
-
-   return &buffer->base;
-}
-
-
-/**
- * Create buffer which wraps user-space data.
- */
-static struct pipe_buffer *
-softpipe_user_buffer_create(struct pipe_screen *screen,
-                            void *ptr,
-                            unsigned bytes)
-{
-   struct softpipe_buffer *buffer;
-
-   buffer = CALLOC_STRUCT(softpipe_buffer);
-   if(!buffer)
-      return NULL;
-
-   pipe_reference_init(&buffer->base.reference, 1);
-   buffer->base.screen = screen;
-   buffer->base.size = bytes;
-   buffer->userBuffer = TRUE;
-   buffer->data = ptr;
-
-   return &buffer->base;
-}
-
-
-void
-softpipe_init_screen_buffer_funcs(struct pipe_screen *screen)
-{
-   screen->buffer_create = softpipe_buffer_create;
-   screen->user_buffer_create = softpipe_user_buffer_create;
-   screen->buffer_map = softpipe_buffer_map;
-   screen->buffer_unmap = softpipe_buffer_unmap;
-   screen->buffer_destroy = softpipe_buffer_destroy;
-}
diff --git a/src/gallium/drivers/softpipe/sp_buffer.h b/src/gallium/drivers/softpipe/sp_buffer.h
deleted file mode 100644
index 9d8e56a176b..00000000000
--- a/src/gallium/drivers/softpipe/sp_buffer.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.
- * 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 VMWARE 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 SP_BUFFER_H
-#define SP_BUFFER_H
-
-#include "pipe/p_compiler.h"
-#include "pipe/p_state.h"
-
-
-struct softpipe_buffer
-{
-   struct pipe_buffer base;
-   boolean userBuffer;  /** Is this a user-space buffer? */
-   void *data;
-};
-
-
-/** Cast wrapper */
-static INLINE struct softpipe_buffer *
-softpipe_buffer( struct pipe_buffer *buf )
-{
-   return (struct softpipe_buffer *)buf;
-}
-
-
-void
-softpipe_init_screen_buffer_funcs(struct pipe_screen *screen);
-
-
-#endif /* SP_BUFFER_H */
diff --git a/src/gallium/drivers/softpipe/sp_context.c b/src/gallium/drivers/softpipe/sp_context.c
index 937a573092f..d0c2978c246 100644
--- a/src/gallium/drivers/softpipe/sp_context.c
+++ b/src/gallium/drivers/softpipe/sp_context.c
@@ -117,7 +117,7 @@ softpipe_destroy( struct pipe_context *pipe )
 
       for (j = 0; j < PIPE_MAX_CONSTANT_BUFFERS; j++) {
          if (softpipe->constants[i][j]) {
-            pipe_buffer_reference(&softpipe->constants[i][j], NULL);
+            pipe_resource_reference(&softpipe->constants[i][j], NULL);
          }
       }
    }
@@ -135,13 +135,16 @@ softpipe_destroy( struct pipe_context *pipe )
  *    return PIPE_UNREFERENCED
  */
 static unsigned int
-softpipe_is_texture_referenced( struct pipe_context *pipe,
-				struct pipe_texture *texture,
+softpipe_is_resource_referenced( struct pipe_context *pipe,
+				struct pipe_resource *texture,
 				unsigned face, unsigned level)
 {
    struct softpipe_context *softpipe = softpipe_context( pipe );
    unsigned i;
 
+   if (texture->target == PIPE_BUFFER)
+      return PIPE_UNREFERENCED;
+   
    /* check if any of the bound drawing surfaces are this texture */
    if (softpipe->dirty_render_cache) {
       for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++) {
@@ -172,12 +175,6 @@ softpipe_is_texture_referenced( struct pipe_context *pipe,
 }
 
 
-static unsigned int
-softpipe_is_buffer_referenced( struct pipe_context *pipe,
-			       struct pipe_buffer *buf)
-{
-   return PIPE_UNREFERENCED;
-}
 
 
 static void
@@ -274,8 +271,7 @@ softpipe_create_context( struct pipe_screen *screen,
    softpipe->pipe.clear = softpipe_clear;
    softpipe->pipe.flush = softpipe_flush;
 
-   softpipe->pipe.is_texture_referenced = softpipe_is_texture_referenced;
-   softpipe->pipe.is_buffer_referenced = softpipe_is_buffer_referenced;
+   softpipe->pipe.is_resource_referenced = softpipe_is_resource_referenced;
 
    softpipe_init_query_funcs( softpipe );
    softpipe_init_texture_funcs( &softpipe->pipe );
diff --git a/src/gallium/drivers/softpipe/sp_context.h b/src/gallium/drivers/softpipe/sp_context.h
index 75e03c8ae6b..be8f2cb3e04 100644
--- a/src/gallium/drivers/softpipe/sp_context.h
+++ b/src/gallium/drivers/softpipe/sp_context.h
@@ -66,7 +66,7 @@ struct softpipe_context {
    struct pipe_blend_color blend_color;
    struct pipe_stencil_ref stencil_ref;
    struct pipe_clip_state clip;
-   struct pipe_buffer *constants[PIPE_SHADER_TYPES][PIPE_MAX_CONSTANT_BUFFERS];
+   struct pipe_resource *constants[PIPE_SHADER_TYPES][PIPE_MAX_CONSTANT_BUFFERS];
    struct pipe_framebuffer_state framebuffer;
    struct pipe_poly_stipple poly_stipple;
    struct pipe_scissor_state scissor;
diff --git a/src/gallium/drivers/softpipe/sp_draw_arrays.c b/src/gallium/drivers/softpipe/sp_draw_arrays.c
index 7b77eb239fd..461c9a6c4d4 100644
--- a/src/gallium/drivers/softpipe/sp_draw_arrays.c
+++ b/src/gallium/drivers/softpipe/sp_draw_arrays.c
@@ -39,7 +39,7 @@
 #include "sp_context.h"
 #include "sp_query.h"
 #include "sp_state.h"
-#include "sp_buffer.h"
+#include "sp_texture.h"
 
 #include "draw/draw_context.h"
 
@@ -55,7 +55,7 @@
  */
 static void
 softpipe_draw_range_elements_instanced(struct pipe_context *pipe,
-                                       struct pipe_buffer *indexBuffer,
+                                       struct pipe_resource *indexBuffer,
                                        unsigned indexSize,
                                        unsigned minIndex,
                                        unsigned maxIndex,
@@ -85,7 +85,7 @@ softpipe_draw_arrays(struct pipe_context *pipe, unsigned mode,
 
 void
 softpipe_draw_range_elements(struct pipe_context *pipe,
-                             struct pipe_buffer *indexBuffer,
+                             struct pipe_resource *indexBuffer,
                              unsigned indexSize,
                              unsigned min_index,
                              unsigned max_index,
@@ -106,7 +106,7 @@ softpipe_draw_range_elements(struct pipe_context *pipe,
 
 void
 softpipe_draw_elements(struct pipe_context *pipe,
-                       struct pipe_buffer *indexBuffer,
+                       struct pipe_resource *indexBuffer,
                        unsigned indexSize,
                        unsigned mode, unsigned start, unsigned count)
 {
@@ -144,7 +144,7 @@ softpipe_draw_arrays_instanced(struct pipe_context *pipe,
 
 void
 softpipe_draw_elements_instanced(struct pipe_context *pipe,
-                                 struct pipe_buffer *indexBuffer,
+                                 struct pipe_resource *indexBuffer,
                                  unsigned indexSize,
                                  unsigned mode,
                                  unsigned start,
@@ -166,7 +166,7 @@ softpipe_draw_elements_instanced(struct pipe_context *pipe,
 
 static void
 softpipe_draw_range_elements_instanced(struct pipe_context *pipe,
-                                       struct pipe_buffer *indexBuffer,
+                                       struct pipe_resource *indexBuffer,
                                        unsigned indexSize,
                                        unsigned minIndex,
                                        unsigned maxIndex,
@@ -193,13 +193,13 @@ softpipe_draw_range_elements_instanced(struct pipe_context *pipe,
 
    /* Map vertex buffers */
    for (i = 0; i < sp->num_vertex_buffers; i++) {
-      void *buf = softpipe_buffer(sp->vertex_buffer[i].buffer)->data;
+      void *buf = softpipe_resource(sp->vertex_buffer[i].buffer)->data;
       draw_set_mapped_vertex_buffer(draw, i, buf);
    }
 
    /* Map index buffer, if present */
    if (indexBuffer) {
-      void *mapped_indexes = softpipe_buffer(indexBuffer)->data;
+      void *mapped_indexes = softpipe_resource(indexBuffer)->data;
       draw_set_mapped_element_buffer_range(draw,
                                            indexSize,
                                            minIndex,
diff --git a/src/gallium/drivers/softpipe/sp_quad_blend.c b/src/gallium/drivers/softpipe/sp_quad_blend.c
index d65307b7f60..ead489393ef 100644
--- a/src/gallium/drivers/softpipe/sp_quad_blend.c
+++ b/src/gallium/drivers/softpipe/sp_quad_blend.c
@@ -744,6 +744,8 @@ blend_fallback(struct quad_stage *qs,
 
    for (cbuf = 0; cbuf < softpipe->framebuffer.nr_cbufs; cbuf++) 
    {
+      /* which blend/mask state index to use: */
+      const uint blend_buf = blend->independent_blend_enable ? cbuf : 0;
       float dest[4][QUAD_SIZE];
       struct softpipe_cached_tile *tile
          = sp_get_cached_tile(softpipe->cbuf_cache[cbuf],
@@ -771,11 +773,11 @@ blend_fallback(struct quad_stage *qs,
          if (blend->logicop_enable) {
             logicop_quad( qs, quadColor, dest );
          }
-         else if (blend->rt[cbuf].blend_enable) {
+         else if (blend->rt[blend_buf].blend_enable) {
             blend_quad( qs, quadColor, dest, cbuf );
          }
 
-         if (blend->rt[cbuf].colormask != 0xf)
+         if (blend->rt[blend_buf].colormask != 0xf)
             colormask_quad( blend->rt[cbuf].colormask, quadColor, dest);
    
          /* Output color values
diff --git a/src/gallium/drivers/softpipe/sp_screen.c b/src/gallium/drivers/softpipe/sp_screen.c
index ddc53b336fb..7b1e058ac83 100644
--- a/src/gallium/drivers/softpipe/sp_screen.c
+++ b/src/gallium/drivers/softpipe/sp_screen.c
@@ -27,7 +27,6 @@
 
 
 #include "util/u_memory.h"
-#include "util/u_format.h"
 #include "util/u_format_s3tc.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_screen.h"
@@ -37,7 +36,6 @@
 #include "sp_texture.h"
 #include "sp_screen.h"
 #include "sp_context.h"
-#include "sp_buffer.h"
 #include "sp_fence.h"
 #include "sp_public.h"
 
@@ -156,16 +154,34 @@ softpipe_is_format_supported( struct pipe_screen *screen,
           target == PIPE_TEXTURE_3D ||
           target == PIPE_TEXTURE_CUBE);
 
-   if(!util_format_is_supported(format))
+   switch(format) {
+   case PIPE_FORMAT_YUYV:
+   case PIPE_FORMAT_UYVY:
       return FALSE;
 
-   if(tex_usage & (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                   PIPE_TEXTURE_USAGE_SCANOUT |
-                   PIPE_TEXTURE_USAGE_SHARED)) {
+   case PIPE_FORMAT_DXT1_RGB:
+   case PIPE_FORMAT_DXT1_RGBA:
+   case PIPE_FORMAT_DXT3_RGBA:
+   case PIPE_FORMAT_DXT5_RGBA:
+      return util_format_s3tc_enabled;
+
+   case PIPE_FORMAT_Z32_FLOAT:
+   case PIPE_FORMAT_NONE:
+      return FALSE;
+
+   default:
+      break;
+   }
+
+   if(tex_usage & (PIPE_BIND_DISPLAY_TARGET |
+                   PIPE_BIND_SCANOUT |
+                   PIPE_BIND_SHARED)) {
       if(!winsys->is_displaytarget_format_supported(winsys, tex_usage, format))
          return FALSE;
    }
 
+   /* XXX: this is often a lie.  Pull in logic from llvmpipe to fix.
+    */
    return TRUE;
 }
 
@@ -192,7 +208,7 @@ softpipe_flush_frontbuffer(struct pipe_screen *_screen,
 {
    struct softpipe_screen *screen = softpipe_screen(_screen);
    struct sw_winsys *winsys = screen->winsys;
-   struct softpipe_texture *texture = softpipe_texture(surface->texture);
+   struct softpipe_resource *texture = softpipe_resource(surface->texture);
 
    assert(texture->dt);
    if (texture->dt)
@@ -224,8 +240,9 @@ softpipe_create_screen(struct sw_winsys *winsys)
    screen->base.context_create = softpipe_create_context;
    screen->base.flush_frontbuffer = softpipe_flush_frontbuffer;
 
+   util_format_s3tc_init();
+
    softpipe_init_screen_texture_funcs(&screen->base);
-   softpipe_init_screen_buffer_funcs(&screen->base);
    softpipe_init_screen_fence_funcs(&screen->base);
 
    return &screen->base;
diff --git a/src/gallium/drivers/softpipe/sp_state.h b/src/gallium/drivers/softpipe/sp_state.h
index ade96b0fd4c..3c04c8bb07e 100644
--- a/src/gallium/drivers/softpipe/sp_state.h
+++ b/src/gallium/drivers/softpipe/sp_state.h
@@ -150,7 +150,7 @@ void softpipe_set_clip_state( struct pipe_context *,
 
 void softpipe_set_constant_buffer(struct pipe_context *,
                                   uint shader, uint index,
-                                  struct pipe_buffer *buf);
+                                  struct pipe_resource *buf);
 
 void *softpipe_create_fs_state(struct pipe_context *,
                                const struct pipe_shader_state *);
@@ -188,7 +188,7 @@ softpipe_set_vertex_sampler_views(struct pipe_context *,
 
 struct pipe_sampler_view *
 softpipe_create_sampler_view(struct pipe_context *pipe,
-                             struct pipe_texture *texture,
+                             struct pipe_resource *texture,
                              const struct pipe_sampler_view *templ);
 
 void
@@ -210,12 +210,12 @@ void softpipe_draw_arrays(struct pipe_context *pipe, unsigned mode,
                           unsigned start, unsigned count);
 
 void softpipe_draw_elements(struct pipe_context *pipe,
-                            struct pipe_buffer *indexBuffer,
+                            struct pipe_resource *indexBuffer,
                             unsigned indexSize,
                             unsigned mode, unsigned start, unsigned count);
 void
 softpipe_draw_range_elements(struct pipe_context *pipe,
-                             struct pipe_buffer *indexBuffer,
+                             struct pipe_resource *indexBuffer,
                              unsigned indexSize,
                              unsigned min_index,
                              unsigned max_index,
@@ -231,7 +231,7 @@ softpipe_draw_arrays_instanced(struct pipe_context *pipe,
 
 void
 softpipe_draw_elements_instanced(struct pipe_context *pipe,
-                                 struct pipe_buffer *indexBuffer,
+                                 struct pipe_resource *indexBuffer,
                                  unsigned indexSize,
                                  unsigned mode,
                                  unsigned start,
diff --git a/src/gallium/drivers/softpipe/sp_state_derived.c b/src/gallium/drivers/softpipe/sp_state_derived.c
index d2eda7324ca..4c6d4909f5b 100644
--- a/src/gallium/drivers/softpipe/sp_state_derived.c
+++ b/src/gallium/drivers/softpipe/sp_state_derived.c
@@ -202,7 +202,7 @@ update_tgsi_samplers( struct softpipe_context *softpipe )
    for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
       struct softpipe_tex_tile_cache *tc = softpipe->tex_cache[i];
       if (tc->texture) {
-         struct softpipe_texture *spt = softpipe_texture(tc->texture);
+         struct softpipe_resource *spt = softpipe_resource(tc->texture);
          if (spt->timestamp != tc->timestamp) {
 	    sp_tex_tile_cache_validate_texture( tc );
             /*
@@ -217,7 +217,7 @@ update_tgsi_samplers( struct softpipe_context *softpipe )
       struct softpipe_tex_tile_cache *tc = softpipe->vertex_tex_cache[i];
 
       if (tc->texture) {
-         struct softpipe_texture *spt = softpipe_texture(tc->texture);
+         struct softpipe_resource *spt = softpipe_resource(tc->texture);
 
          if (spt->timestamp != tc->timestamp) {
 	    sp_tex_tile_cache_validate_texture(tc);
diff --git a/src/gallium/drivers/softpipe/sp_state_fs.c b/src/gallium/drivers/softpipe/sp_state_fs.c
index d6f3229bed7..7f072f5a269 100644
--- a/src/gallium/drivers/softpipe/sp_state_fs.c
+++ b/src/gallium/drivers/softpipe/sp_state_fs.c
@@ -28,7 +28,7 @@
 #include "sp_context.h"
 #include "sp_state.h"
 #include "sp_fs.h"
-#include "sp_buffer.h"
+#include "sp_texture.h"
 
 #include "pipe/p_defines.h"
 #include "util/u_memory.h"
@@ -167,11 +167,11 @@ softpipe_delete_vs_state(struct pipe_context *pipe, void *vs)
 void
 softpipe_set_constant_buffer(struct pipe_context *pipe,
                              uint shader, uint index,
-                             struct pipe_buffer *constants)
+                             struct pipe_resource *constants)
 {
    struct softpipe_context *softpipe = softpipe_context(pipe);
-   unsigned size = constants ? constants->size : 0;
-   const void *data = constants ? softpipe_buffer(constants)->data : NULL;
+   unsigned size = constants ? constants->width0 : 0;
+   const void *data = constants ? softpipe_resource(constants)->data : NULL;
 
    assert(shader < PIPE_SHADER_TYPES);
    assert(index == 0);
@@ -179,7 +179,7 @@ softpipe_set_constant_buffer(struct pipe_context *pipe,
    draw_flush(softpipe->draw);
 
    /* note: reference counting */
-   pipe_buffer_reference(&softpipe->constants[shader][index], constants);
+   pipe_resource_reference(&softpipe->constants[shader][index], constants);
 
    if (shader == PIPE_SHADER_VERTEX || shader == PIPE_SHADER_GEOMETRY) {
       draw_set_mapped_constant_buffer(softpipe->draw, shader, index, data, size);
diff --git a/src/gallium/drivers/softpipe/sp_state_sampler.c b/src/gallium/drivers/softpipe/sp_state_sampler.c
index d501952bba9..2692f06c927 100644
--- a/src/gallium/drivers/softpipe/sp_state_sampler.c
+++ b/src/gallium/drivers/softpipe/sp_state_sampler.c
@@ -30,6 +30,7 @@
  */
 
 #include "util/u_memory.h"
+#include "util/u_inlines.h"
 
 #include "draw/draw_context.h"
 #include "draw/draw_context.h"
@@ -123,7 +124,7 @@ softpipe_bind_vertex_sampler_states(struct pipe_context *pipe,
 
 struct pipe_sampler_view *
 softpipe_create_sampler_view(struct pipe_context *pipe,
-                             struct pipe_texture *texture,
+                             struct pipe_resource *resource,
                              const struct pipe_sampler_view *templ)
 {
    struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
@@ -132,7 +133,7 @@ softpipe_create_sampler_view(struct pipe_context *pipe,
       *view = *templ;
       view->reference.count = 1;
       view->texture = NULL;
-      pipe_texture_reference(&view->texture, texture);
+      pipe_resource_reference(&view->texture, resource);
       view->context = pipe;
    }
 
@@ -144,7 +145,7 @@ void
 softpipe_sampler_view_destroy(struct pipe_context *pipe,
                               struct pipe_sampler_view *view)
 {
-   pipe_texture_reference(&view->texture, NULL);
+   pipe_resource_reference(&view->texture, NULL);
    FREE(view);
 }
 
@@ -223,10 +224,10 @@ softpipe_set_vertex_sampler_views(struct pipe_context *pipe,
 static struct sp_sampler_varient *
 get_sampler_varient( unsigned unit,
                      struct sp_sampler *sampler,
-                     struct pipe_texture *texture,
+                     struct pipe_resource *resource,
                      unsigned processor )
 {
-   struct softpipe_texture *sp_texture = softpipe_texture(texture);
+   struct softpipe_resource *sp_texture = softpipe_resource(resource);
    struct sp_sampler_varient *v = NULL;
    union sp_sampler_key key;
 
@@ -274,7 +275,7 @@ softpipe_reset_sampler_varients(struct softpipe_context *softpipe)
     */
    for (i = 0; i <= softpipe->vs->max_sampler; i++) {
       if (softpipe->vertex_samplers[i]) {
-         struct pipe_texture *texture = NULL;
+         struct pipe_resource *texture = NULL;
 
          if (softpipe->vertex_sampler_views[i]) {
             texture = softpipe->vertex_sampler_views[i]->texture;
@@ -294,7 +295,7 @@ softpipe_reset_sampler_varients(struct softpipe_context *softpipe)
 
    for (i = 0; i <= softpipe->fs->info.file_max[TGSI_FILE_SAMPLER]; i++) {
       if (softpipe->sampler[i]) {
-         struct pipe_texture *texture = NULL;
+         struct pipe_resource *texture = NULL;
 
          if (softpipe->sampler_views[i]) {
             texture = softpipe->sampler_views[i]->texture;
diff --git a/src/gallium/drivers/softpipe/sp_tex_sample.c b/src/gallium/drivers/softpipe/sp_tex_sample.c
index fa9e19b282b..ff83c66d8b2 100644
--- a/src/gallium/drivers/softpipe/sp_tex_sample.c
+++ b/src/gallium/drivers/softpipe/sp_tex_sample.c
@@ -547,7 +547,7 @@ compute_lambda_1d(const struct sp_sampler_varient *samp,
                   const float t[QUAD_SIZE],
                   const float p[QUAD_SIZE])
 {
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    float dsdx = fabsf(s[QUAD_BOTTOM_RIGHT] - s[QUAD_BOTTOM_LEFT]);
    float dsdy = fabsf(s[QUAD_TOP_LEFT]     - s[QUAD_BOTTOM_LEFT]);
    float rho = MAX2(dsdx, dsdy) * texture->width0;
@@ -562,7 +562,7 @@ compute_lambda_2d(const struct sp_sampler_varient *samp,
                   const float t[QUAD_SIZE],
                   const float p[QUAD_SIZE])
 {
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    float dsdx = fabsf(s[QUAD_BOTTOM_RIGHT] - s[QUAD_BOTTOM_LEFT]);
    float dsdy = fabsf(s[QUAD_TOP_LEFT]     - s[QUAD_BOTTOM_LEFT]);
    float dtdx = fabsf(t[QUAD_BOTTOM_RIGHT] - t[QUAD_BOTTOM_LEFT]);
@@ -581,7 +581,7 @@ compute_lambda_3d(const struct sp_sampler_varient *samp,
                   const float t[QUAD_SIZE],
                   const float p[QUAD_SIZE])
 {
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    float dsdx = fabsf(s[QUAD_BOTTOM_RIGHT] - s[QUAD_BOTTOM_LEFT]);
    float dsdy = fabsf(s[QUAD_TOP_LEFT]     - s[QUAD_BOTTOM_LEFT]);
    float dtdx = fabsf(t[QUAD_BOTTOM_RIGHT] - t[QUAD_BOTTOM_LEFT]);
@@ -651,7 +651,7 @@ static INLINE const float *
 get_texel_2d(const struct sp_sampler_varient *samp,
 	     union tex_tile_address addr, int x, int y)
 {
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    unsigned level = addr.bits.level;
 
    if (x < 0 || x >= (int) u_minify(texture->width0, level) ||
@@ -744,7 +744,7 @@ static INLINE const float *
 get_texel_3d(const struct sp_sampler_varient *samp,
 	     union tex_tile_address addr, int x, int y, int z)
 {
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    unsigned level = addr.bits.level;
 
    if (x < 0 || x >= (int) u_minify(texture->width0, level) ||
@@ -932,7 +932,7 @@ img_filter_1d_nearest(struct tgsi_sampler *tgsi_sampler,
                         float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    const struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    unsigned level0, j;
    int width;
    int x[4];
@@ -968,7 +968,7 @@ img_filter_2d_nearest(struct tgsi_sampler *tgsi_sampler,
                       float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    const struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    unsigned level0, j;
    int width, height;
    int x[4], y[4];
@@ -1016,7 +1016,7 @@ img_filter_cube_nearest(struct tgsi_sampler *tgsi_sampler,
                         float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    const struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    const unsigned *faces = samp->faces; /* zero when not cube-mapping */
    unsigned level0, j;
    int width, height;
@@ -1056,7 +1056,7 @@ img_filter_3d_nearest(struct tgsi_sampler *tgsi_sampler,
                       float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    const struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    unsigned level0, j;
    int width, height, depth;
    int x[4], y[4], z[4];
@@ -1098,7 +1098,7 @@ img_filter_1d_linear(struct tgsi_sampler *tgsi_sampler,
                      float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    const struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    unsigned level0, j;
    int width;
    int x0[4], x1[4];
@@ -1138,7 +1138,7 @@ img_filter_2d_linear(struct tgsi_sampler *tgsi_sampler,
                      float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    const struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    unsigned level0, j;
    int width, height;
    int x0[4], y0[4], x1[4], y1[4];
@@ -1185,7 +1185,7 @@ img_filter_cube_linear(struct tgsi_sampler *tgsi_sampler,
                        float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    const struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    const unsigned *faces = samp->faces; /* zero when not cube-mapping */
    unsigned level0, j;
    int width, height;
@@ -1234,7 +1234,7 @@ img_filter_3d_linear(struct tgsi_sampler *tgsi_sampler,
                      float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    const struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    unsigned level0, j;
    int width, height, depth;
    int x0[4], x1[4], y0[4], y1[4], z0[4], z1[4];
@@ -1310,7 +1310,7 @@ mip_filter_linear(struct tgsi_sampler *tgsi_sampler,
                   float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    int level0;
    float lambda;
    float lod[QUAD_SIZE];
@@ -1373,7 +1373,7 @@ mip_filter_nearest(struct tgsi_sampler *tgsi_sampler,
                    float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    float lambda;
    float lod[QUAD_SIZE];
 
@@ -1461,7 +1461,7 @@ mip_filter_linear_2d_linear_repeat_POT(
    float rgba[NUM_CHANNELS][QUAD_SIZE])
 {
    struct sp_sampler_varient *samp = sp_sampler_varient(tgsi_sampler);
-   const struct pipe_texture *texture = samp->texture;
+   const struct pipe_resource *texture = samp->texture;
    int level0;
    float lambda;
    float lod[QUAD_SIZE];
@@ -1867,7 +1867,7 @@ get_img_filter(const union sp_sampler_key key,
 void
 sp_sampler_varient_bind_texture( struct sp_sampler_varient *samp,
                                  struct softpipe_tex_tile_cache *tex_cache,
-                                 const struct pipe_texture *texture )
+                                 const struct pipe_resource *texture )
 {
    const struct pipe_sampler_state *sampler = samp->sampler;
 
diff --git a/src/gallium/drivers/softpipe/sp_tex_sample.h b/src/gallium/drivers/softpipe/sp_tex_sample.h
index b6e66c998ae..6114acf7371 100644
--- a/src/gallium/drivers/softpipe/sp_tex_sample.h
+++ b/src/gallium/drivers/softpipe/sp_tex_sample.h
@@ -85,7 +85,7 @@ struct sp_sampler_varient
 
    /* Currently bound texture:
     */
-   const struct pipe_texture *texture;
+   const struct pipe_resource *texture;
    struct softpipe_tex_tile_cache *cache;
 
    unsigned processor;
@@ -129,7 +129,7 @@ sp_create_sampler_varient( const struct pipe_sampler_state *sampler,
 
 void sp_sampler_varient_bind_texture( struct sp_sampler_varient *varient,
                                       struct softpipe_tex_tile_cache *tex_cache,
-                                      const struct pipe_texture *tex );
+                                      const struct pipe_resource *tex );
 
 void sp_sampler_varient_destroy( struct sp_sampler_varient * );
 
diff --git a/src/gallium/drivers/softpipe/sp_tex_tile_cache.c b/src/gallium/drivers/softpipe/sp_tex_tile_cache.c
index 6594514c38f..c79f5fb05a1 100644
--- a/src/gallium/drivers/softpipe/sp_tex_tile_cache.c
+++ b/src/gallium/drivers/softpipe/sp_tex_tile_cache.c
@@ -69,10 +69,10 @@ sp_destroy_tex_tile_cache(struct softpipe_tex_tile_cache *tc)
       /*assert(tc->entries[pos].x < 0);*/
    }
    if (tc->transfer) {
-      tc->pipe->tex_transfer_destroy(tc->pipe, tc->transfer);
+      tc->pipe->transfer_destroy(tc->pipe, tc->transfer);
    }
    if (tc->tex_trans) {
-      tc->pipe->tex_transfer_destroy(tc->pipe, tc->tex_trans);
+      tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
    }
 
    FREE( tc );
@@ -122,13 +122,13 @@ void
 sp_tex_tile_cache_set_sampler_view(struct softpipe_tex_tile_cache *tc,
                                    struct pipe_sampler_view *view)
 {
-   struct pipe_texture *texture = view ? view->texture : NULL;
+   struct pipe_resource *texture = view ? view->texture : NULL;
    uint i;
 
    assert(!tc->transfer);
 
    if (tc->texture != texture) {
-      pipe_texture_reference(&tc->texture, texture);
+      pipe_resource_reference(&tc->texture, texture);
 
       if (tc->tex_trans) {
          if (tc->tex_trans_map) {
@@ -136,7 +136,7 @@ sp_tex_tile_cache_set_sampler_view(struct softpipe_tex_tile_cache *tc,
             tc->tex_trans_map = NULL;
          }
 
-         tc->pipe->tex_transfer_destroy(tc->pipe, tc->tex_trans);
+         tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
          tc->tex_trans = NULL;
       }
 
@@ -239,18 +239,18 @@ sp_find_cached_tile_tex(struct softpipe_tex_tile_cache *tc,
                tc->tex_trans_map = NULL;
             }
 
-            tc->pipe->tex_transfer_destroy(tc->pipe, tc->tex_trans);
+            tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
             tc->tex_trans = NULL;
          }
 
          tc->tex_trans = 
-            tc->pipe->get_tex_transfer(tc->pipe, tc->texture, 
-                                     addr.bits.face, 
-                                     addr.bits.level, 
-                                     addr.bits.z, 
-                                     PIPE_TRANSFER_READ, 0, 0,
-                                     u_minify(tc->texture->width0, addr.bits.level),
-                                     u_minify(tc->texture->height0, addr.bits.level));
+            pipe_get_transfer(tc->pipe, tc->texture, 
+			      addr.bits.face, 
+			      addr.bits.level, 
+			      addr.bits.z, 
+			      PIPE_TRANSFER_READ, 0, 0,
+			      u_minify(tc->texture->width0, addr.bits.level),
+			      u_minify(tc->texture->height0, addr.bits.level));
          
          tc->tex_trans_map = tc->pipe->transfer_map(tc->pipe, tc->tex_trans);
 
diff --git a/src/gallium/drivers/softpipe/sp_tex_tile_cache.h b/src/gallium/drivers/softpipe/sp_tex_tile_cache.h
index 12ae7ba12d6..0794ffa0c53 100644
--- a/src/gallium/drivers/softpipe/sp_tex_tile_cache.h
+++ b/src/gallium/drivers/softpipe/sp_tex_tile_cache.h
@@ -74,7 +74,7 @@ struct softpipe_tex_tile_cache
    struct pipe_transfer *transfer;
    void *transfer_map;
 
-   struct pipe_texture *texture;  /**< if caching a texture */
+   struct pipe_resource *texture;  /**< if caching a texture */
    unsigned timestamp;
 
    struct softpipe_tex_cached_tile entries[NUM_ENTRIES];
diff --git a/src/gallium/drivers/softpipe/sp_texture.c b/src/gallium/drivers/softpipe/sp_texture.c
index f4983b7c8e8..27cc6f27b2e 100644
--- a/src/gallium/drivers/softpipe/sp_texture.c
+++ b/src/gallium/drivers/softpipe/sp_texture.c
@@ -36,6 +36,7 @@
 #include "util/u_format.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
+#include "util/u_transfer.h"
 
 #include "sp_context.h"
 #include "sp_texture.h"
@@ -49,10 +50,10 @@
  * Use a simple, maximally packed layout.
  */
 static boolean
-softpipe_texture_layout(struct pipe_screen *screen,
-                        struct softpipe_texture * spt)
+softpipe_resource_layout(struct pipe_screen *screen,
+                        struct softpipe_resource * spt)
 {
-   struct pipe_texture *pt = &spt->base;
+   struct pipe_resource *pt = &spt->base;
    unsigned level;
    unsigned width = pt->width0;
    unsigned height = pt->height0;
@@ -84,14 +85,14 @@ softpipe_texture_layout(struct pipe_screen *screen,
  */
 static boolean
 softpipe_displaytarget_layout(struct pipe_screen *screen,
-                              struct softpipe_texture * spt)
+                              struct softpipe_resource * spt)
 {
    struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
 
    /* Round up the surface size to a multiple of the tile size?
     */
    spt->dt = winsys->displaytarget_create(winsys,
-                                          spt->base.tex_usage,
+                                          spt->base.bind,
                                           spt->base.format,
                                           spt->base.width0, 
                                           spt->base.height0,
@@ -103,16 +104,18 @@ softpipe_displaytarget_layout(struct pipe_screen *screen,
 
 
 /**
- * Create new pipe_texture given the template information.
+ * Create new pipe_resource given the template information.
  */
-static struct pipe_texture *
-softpipe_texture_create(struct pipe_screen *screen,
-                        const struct pipe_texture *template)
+static struct pipe_resource *
+softpipe_resource_create(struct pipe_screen *screen,
+                        const struct pipe_resource *template)
 {
-   struct softpipe_texture *spt = CALLOC_STRUCT(softpipe_texture);
+   struct softpipe_resource *spt = CALLOC_STRUCT(softpipe_resource);
    if (!spt)
       return NULL;
 
+   assert(template->format != PIPE_FORMAT_NONE);
+
    spt->base = *template;
    pipe_reference_init(&spt->base.reference, 1);
    spt->base.screen = screen;
@@ -121,14 +124,14 @@ softpipe_texture_create(struct pipe_screen *screen,
                util_is_power_of_two(template->height0) &&
                util_is_power_of_two(template->depth0));
 
-   if (spt->base.tex_usage & (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                              PIPE_TEXTURE_USAGE_SCANOUT |
-                              PIPE_TEXTURE_USAGE_SHARED)) {
+   if (spt->base.bind & (PIPE_BIND_DISPLAY_TARGET |
+			 PIPE_BIND_SCANOUT |
+			 PIPE_BIND_SHARED)) {
       if (!softpipe_displaytarget_layout(screen, spt))
          goto fail;
    }
    else {
-      if (!softpipe_texture_layout(screen, spt))
+      if (!softpipe_resource_layout(screen, spt))
          goto fail;
    }
     
@@ -141,17 +144,18 @@ softpipe_texture_create(struct pipe_screen *screen,
 
 
 static void
-softpipe_texture_destroy(struct pipe_texture *pt)
+softpipe_resource_destroy(struct pipe_screen *pscreen,
+			  struct pipe_resource *pt)
 {
-   struct softpipe_screen *screen = softpipe_screen(pt->screen);
-   struct softpipe_texture *spt = softpipe_texture(pt);
+   struct softpipe_screen *screen = softpipe_screen(pscreen);
+   struct softpipe_resource *spt = softpipe_resource(pt);
 
    if (spt->dt) {
       /* display target */
       struct sw_winsys *winsys = screen->winsys;
       winsys->displaytarget_destroy(winsys, spt->dt);
    }
-   else {
+   else if (!spt->userBuffer) {
       /* regular texture */
       align_free(spt->data);
    }
@@ -160,13 +164,13 @@ softpipe_texture_destroy(struct pipe_texture *pt)
 }
 
 
-static struct pipe_texture *
-softpipe_texture_from_handle(struct pipe_screen *screen,
-                             const struct pipe_texture *template,
+static struct pipe_resource *
+softpipe_resource_from_handle(struct pipe_screen *screen,
+                             const struct pipe_resource *template,
                              struct winsys_handle *whandle)
 {
    struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
-   struct softpipe_texture *spt = CALLOC_STRUCT(softpipe_texture);
+   struct softpipe_resource *spt = CALLOC_STRUCT(softpipe_resource);
    if (!spt)
       return NULL;
 
@@ -194,12 +198,12 @@ softpipe_texture_from_handle(struct pipe_screen *screen,
 
 
 static boolean
-softpipe_texture_get_handle(struct pipe_screen *screen,
-                            struct pipe_texture *pt,
+softpipe_resource_get_handle(struct pipe_screen *screen,
+                            struct pipe_resource *pt,
                             struct winsys_handle *whandle)
 {
    struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
-   struct softpipe_texture *spt = softpipe_texture(pt);
+   struct softpipe_resource *spt = softpipe_resource(pt);
 
    assert(spt->dt);
    if (!spt->dt)
@@ -214,11 +218,11 @@ softpipe_texture_get_handle(struct pipe_screen *screen,
  */
 static struct pipe_surface *
 softpipe_get_tex_surface(struct pipe_screen *screen,
-                         struct pipe_texture *pt,
+                         struct pipe_resource *pt,
                          unsigned face, unsigned level, unsigned zslice,
                          unsigned usage)
 {
-   struct softpipe_texture *spt = softpipe_texture(pt);
+   struct softpipe_resource *spt = softpipe_resource(pt);
    struct pipe_surface *ps;
 
    assert(level <= pt->last_level);
@@ -226,33 +230,13 @@ softpipe_get_tex_surface(struct pipe_screen *screen,
    ps = CALLOC_STRUCT(pipe_surface);
    if (ps) {
       pipe_reference_init(&ps->reference, 1);
-      pipe_texture_reference(&ps->texture, pt);
+      pipe_resource_reference(&ps->texture, pt);
       ps->format = pt->format;
       ps->width = u_minify(pt->width0, level);
       ps->height = u_minify(pt->height0, level);
       ps->offset = spt->level_offset[level];
       ps->usage = usage;
 
-      /* Because we are softpipe, anything that the state tracker
-       * thought was going to be done with the GPU will actually get
-       * done with the CPU.  Let's adjust the flags to take that into
-       * account.
-       */
-      if (ps->usage & PIPE_BUFFER_USAGE_GPU_WRITE) {
-         /* GPU_WRITE means "render" and that can involve reads (blending) */
-         ps->usage |= PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_CPU_READ;
-      }
-
-      if (ps->usage & PIPE_BUFFER_USAGE_GPU_READ)
-         ps->usage |= PIPE_BUFFER_USAGE_CPU_READ;
-
-      if (ps->usage & (PIPE_BUFFER_USAGE_CPU_WRITE |
-                       PIPE_BUFFER_USAGE_GPU_WRITE)) {
-         /* Mark the surface as dirty.  The tile cache will look for this. */
-         spt->timestamp++;
-         softpipe_screen(screen)->timestamp++;
-      }
-
       ps->face = face;
       ps->level = level;
       ps->zslice = zslice;
@@ -285,7 +269,7 @@ softpipe_tex_surface_destroy(struct pipe_surface *surf)
     * where it would happen.  For softpipe, nothing to do.
     */
    assert(surf->texture);
-   pipe_texture_reference(&surf->texture, NULL);
+   pipe_resource_reference(&surf->texture, NULL);
    FREE(surf);
 }
 
@@ -303,49 +287,52 @@ softpipe_tex_surface_destroy(struct pipe_surface *surf)
  * \param height  height of region to read/write
  */
 static struct pipe_transfer *
-softpipe_get_tex_transfer(struct pipe_context *pipe,
-                          struct pipe_texture *texture,
-                          unsigned face, unsigned level, unsigned zslice,
-                          enum pipe_transfer_usage usage,
-                          unsigned x, unsigned y, unsigned w, unsigned h)
+softpipe_get_transfer(struct pipe_context *pipe,
+		      struct pipe_resource *resource,
+		      struct pipe_subresource sr,
+		      unsigned usage,
+		      const struct pipe_box *box)
 {
-   struct softpipe_texture *sptex = softpipe_texture(texture);
+   struct softpipe_resource *sptex = softpipe_resource(resource);
    struct softpipe_transfer *spt;
 
-   assert(texture);
-   assert(level <= texture->last_level);
+   assert(resource);
+   assert(sr.level <= resource->last_level);
 
    /* make sure the requested region is in the image bounds */
-   assert(x + w <= u_minify(texture->width0, level));
-   assert(y + h <= u_minify(texture->height0, level));
+   assert(box->x + box->width <= u_minify(resource->width0, sr.level));
+   assert(box->y + box->height <= u_minify(resource->height0, sr.level));
+   assert(box->z + box->depth <= u_minify(resource->depth0, sr.level));
 
    spt = CALLOC_STRUCT(softpipe_transfer);
    if (spt) {
       struct pipe_transfer *pt = &spt->base;
-      int nblocksy = util_format_get_nblocksy(texture->format, u_minify(texture->height0, level));
-      pipe_texture_reference(&pt->texture, texture);
-      pt->x = x;
-      pt->y = y;
-      pt->width = w;
-      pt->height = h;
-      pt->stride = sptex->stride[level];
+      enum pipe_format format = resource->format;
+      int nblocksy = util_format_get_nblocksy(resource->format, 
+					      u_minify(resource->height0, sr.level));
+      pipe_resource_reference(&pt->resource, resource);
+      pt->sr = sr;
       pt->usage = usage;
-      pt->face = face;
-      pt->level = level;
-      pt->zslice = zslice;
+      pt->box = *box;
+      pt->stride = sptex->stride[sr.level];
 
-      spt->offset = sptex->level_offset[level];
+      spt->offset = sptex->level_offset[sr.level];
 
-      if (texture->target == PIPE_TEXTURE_CUBE) {
-         spt->offset += face * nblocksy * pt->stride;
+      if (resource->target == PIPE_TEXTURE_CUBE) {
+         spt->offset += sr.face * nblocksy * pt->stride;
       }
-      else if (texture->target == PIPE_TEXTURE_3D) {
-         spt->offset += zslice * nblocksy * pt->stride;
+      else if (resource->target == PIPE_TEXTURE_3D) {
+         spt->offset += box->z * nblocksy * pt->stride;
       }
       else {
-         assert(face == 0);
-         assert(zslice == 0);
+         assert(sr.face == 0);
+         assert(box->z == 0);
       }
+      
+      spt->offset += 
+	 box->y / util_format_get_blockheight(format) * spt->base.stride +
+	 box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
+
       return pt;
    }
    return NULL;
@@ -354,18 +341,13 @@ softpipe_get_tex_transfer(struct pipe_context *pipe,
 
 /**
  * Free a pipe_transfer object which was created with
- * softpipe_get_tex_transfer().
+ * softpipe_get_transfer().
  */
 static void 
-softpipe_tex_transfer_destroy(struct pipe_context *pipe,
+softpipe_transfer_destroy(struct pipe_context *pipe,
                               struct pipe_transfer *transfer)
 {
-   /* Effectively do the texture_update work here - if texture images
-    * needed post-processing to put them into hardware layout, this is
-    * where it would happen.  For softpipe, nothing to do.
-    */
-   assert (transfer->texture);
-   pipe_texture_reference(&transfer->texture, NULL);
+   pipe_resource_reference(&transfer->resource, NULL);
    FREE(transfer);
 }
 
@@ -377,44 +359,26 @@ static void *
 softpipe_transfer_map( struct pipe_context *pipe,
                        struct pipe_transfer *transfer )
 {
-   ubyte *map, *xfer_map;
-   struct softpipe_texture *spt;
-   enum pipe_format format;
-
-   assert(transfer->texture);
-   spt = softpipe_texture(transfer->texture);
-   format = transfer->texture->format;
-
-   if (spt->dt) {
-      /* display target */
-      struct sw_winsys *winsys = softpipe_screen(pipe->screen)->winsys;
-
-      map = winsys->displaytarget_map(winsys, spt->dt,
-                                      pipe_transfer_buffer_flags(transfer));
-      if (map == NULL)
-         return NULL;
+   struct softpipe_transfer *sp_transfer = softpipe_transfer(transfer);
+   struct softpipe_resource *sp_resource = softpipe_resource(transfer->resource);
+   struct sw_winsys *winsys = softpipe_screen(pipe->screen)->winsys;
+   uint8_t *map;
+   
+   /* resources backed by display target treated specially:
+    */
+   if (sp_resource->dt) {
+      map = winsys->displaytarget_map(winsys,
+				      sp_resource->dt,
+                                      transfer->usage);
    }
    else {
-      map = spt->data;
-      if (map == NULL)
-         return NULL;
-   }
-
-   /* May want to different things here depending on read/write nature
-    * of the map:
-    */
-   if (transfer->texture && (transfer->usage & PIPE_TRANSFER_WRITE)) {
-      /* Do something to notify sharing contexts of a texture change.
-       * In softpipe, that would mean flushing the texture cache.
-       */
-      softpipe_screen(pipe->screen)->timestamp++;
+      map = sp_resource->data;
    }
 
-   xfer_map = map + softpipe_transfer(transfer)->offset +
-      transfer->y / util_format_get_blockheight(format) * transfer->stride +
-      transfer->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
-   /*printf("map = %p  xfer map = %p\n", map, xfer_map);*/
-   return xfer_map;
+   if (map == NULL)
+      return NULL;
+   else
+      return map + sp_transfer->offset;
 }
 
 
@@ -425,10 +389,10 @@ static void
 softpipe_transfer_unmap(struct pipe_context *pipe,
                         struct pipe_transfer *transfer)
 {
-   struct softpipe_texture *spt;
+   struct softpipe_resource *spt;
 
-   assert(transfer->texture);
-   spt = softpipe_texture(transfer->texture);
+   assert(transfer->resource);
+   spt = softpipe_resource(transfer->resource);
 
    if (spt->dt) {
       /* display target */
@@ -442,81 +406,64 @@ softpipe_transfer_unmap(struct pipe_context *pipe,
    }
 }
 
-
-static struct pipe_video_surface*
-softpipe_video_surface_create(struct pipe_screen *screen,
-                              enum pipe_video_chroma_format chroma_format,
-                              unsigned width, unsigned height)
+/**
+ * Create buffer which wraps user-space data.
+ */
+static struct pipe_resource *
+softpipe_user_buffer_create(struct pipe_screen *screen,
+                            void *ptr,
+                            unsigned bytes,
+			    unsigned bind_flags)
 {
-   struct softpipe_video_surface *sp_vsfc;
-   struct pipe_texture template;
+   struct softpipe_resource *buffer;
 
-   assert(screen);
-   assert(width && height);
-
-   sp_vsfc = CALLOC_STRUCT(softpipe_video_surface);
-   if (!sp_vsfc)
+   buffer = CALLOC_STRUCT(softpipe_resource);
+   if(!buffer)
       return NULL;
 
-   pipe_reference_init(&sp_vsfc->base.reference, 1);
-   sp_vsfc->base.screen = screen;
-   sp_vsfc->base.chroma_format = chroma_format;
-   /*sp_vsfc->base.surface_format = PIPE_VIDEO_SURFACE_FORMAT_VUYA;*/
-   sp_vsfc->base.width = width;
-   sp_vsfc->base.height = height;
-
-   memset(&template, 0, sizeof(struct pipe_texture));
-   template.target = PIPE_TEXTURE_2D;
-   template.format = PIPE_FORMAT_B8G8R8X8_UNORM;
-   template.last_level = 0;
-   /* vl_mpeg12_mc_renderer expects this when it's initialized with pot_buffers=true */
-   template.width0 = util_next_power_of_two(width);
-   template.height0 = util_next_power_of_two(height);
-   template.depth0 = 1;
-   template.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER | PIPE_TEXTURE_USAGE_RENDER_TARGET;
-
-   sp_vsfc->tex = screen->texture_create(screen, &template);
-   if (!sp_vsfc->tex) {
-      FREE(sp_vsfc);
-      return NULL;
-   }
-
-   return &sp_vsfc->base;
+   
+   pipe_reference_init(&buffer->base.reference, 1);
+   buffer->base.screen = screen;
+   buffer->base.format = PIPE_FORMAT_R8_UNORM; /* ?? */
+   buffer->base.bind = bind_flags;
+   buffer->base._usage = PIPE_USAGE_IMMUTABLE;
+   buffer->base.flags = 0;
+   buffer->base.width0 = bytes;
+   buffer->base.height0 = 1;
+   buffer->base.depth0 = 1;
+   buffer->userBuffer = TRUE;
+   buffer->data = ptr;
+
+   return &buffer->base;
 }
 
 
-static void
-softpipe_video_surface_destroy(struct pipe_video_surface *vsfc)
-{
-   struct softpipe_video_surface *sp_vsfc = softpipe_video_surface(vsfc);
 
-   pipe_texture_reference(&sp_vsfc->tex, NULL);
-   FREE(sp_vsfc);
-}
 
 
 void
 softpipe_init_texture_funcs(struct pipe_context *pipe)
 {
-   pipe->get_tex_transfer = softpipe_get_tex_transfer;
-   pipe->tex_transfer_destroy = softpipe_tex_transfer_destroy;
+   pipe->get_transfer = softpipe_get_transfer;
+   pipe->transfer_destroy = softpipe_transfer_destroy;
    pipe->transfer_map = softpipe_transfer_map;
    pipe->transfer_unmap = softpipe_transfer_unmap;
+
+   pipe->transfer_flush_region = u_default_transfer_flush_region;
+   pipe->transfer_inline_write = u_default_transfer_inline_write;
 }
 
 void
 softpipe_init_screen_texture_funcs(struct pipe_screen *screen)
 {
-   screen->texture_create = softpipe_texture_create;
-   screen->texture_destroy = softpipe_texture_destroy;
-   screen->texture_from_handle = softpipe_texture_from_handle;
-   screen->texture_get_handle = softpipe_texture_get_handle;
+   screen->resource_create = softpipe_resource_create;
+   screen->resource_destroy = softpipe_resource_destroy;
+   screen->resource_from_handle = softpipe_resource_from_handle;
+   screen->resource_get_handle = softpipe_resource_get_handle;
+   screen->user_buffer_create = softpipe_user_buffer_create;
 
    screen->get_tex_surface = softpipe_get_tex_surface;
    screen->tex_surface_destroy = softpipe_tex_surface_destroy;
-
-   screen->video_surface_create = softpipe_video_surface_create;
-   screen->video_surface_destroy = softpipe_video_surface_destroy;
 }
 
 
diff --git a/src/gallium/drivers/softpipe/sp_texture.h b/src/gallium/drivers/softpipe/sp_texture.h
index c0e6ba8a869..500f42fb0fd 100644
--- a/src/gallium/drivers/softpipe/sp_texture.h
+++ b/src/gallium/drivers/softpipe/sp_texture.h
@@ -30,7 +30,6 @@
 
 
 #include "pipe/p_state.h"
-#include "pipe/p_video_state.h"
 
 
 #define SP_MAX_TEXTURE_2D_LEVELS 13  /* 4K x 4K */
@@ -42,27 +41,28 @@ struct pipe_screen;
 struct softpipe_context;
 
 
-struct softpipe_texture
+struct softpipe_resource
 {
-   struct pipe_texture base;
+   struct pipe_resource base;
 
    unsigned long level_offset[SP_MAX_TEXTURE_2D_LEVELS];
    unsigned stride[SP_MAX_TEXTURE_2D_LEVELS];
 
    /**
-    * Display target, for textures with the PIPE_TEXTURE_USAGE_DISPLAY_TARGET
-    * usage.
+    * Display target, only valid for PIPE_TEXTURE_2D with the
+    * PIPE_BIND_DISPLAY_TARGET usage.
     */
    struct sw_displaytarget *dt;
 
    /**
-    * Malloc'ed data for regular textures, or a mapping to dt above.
+    * Malloc'ed data for regular buffers and textures, or a mapping to dt above.
     */
    void *data;
 
    /* True if texture images are power-of-two in all dimensions:
     */
    boolean pot;
+   boolean userBuffer;
 
    unsigned timestamp;
 };
@@ -74,21 +74,13 @@ struct softpipe_transfer
    unsigned long offset;
 };
 
-struct softpipe_video_surface
-{
-   struct pipe_video_surface base;
-
-   /* The data is held here:
-    */
-   struct pipe_texture *tex;
-};
 
 
 /** cast wrappers */
-static INLINE struct softpipe_texture *
-softpipe_texture(struct pipe_texture *pt)
+static INLINE struct softpipe_resource *
+softpipe_resource(struct pipe_resource *pt)
 {
-   return (struct softpipe_texture *) pt;
+   return (struct softpipe_resource *) pt;
 }
 
 static INLINE struct softpipe_transfer *
@@ -97,12 +89,6 @@ softpipe_transfer(struct pipe_transfer *pt)
    return (struct softpipe_transfer *) pt;
 }
 
-static INLINE struct softpipe_video_surface *
-softpipe_video_surface(struct pipe_video_surface *pvs)
-{
-   return (struct softpipe_video_surface *) pvs;
-}
-
 
 extern void
 softpipe_init_screen_texture_funcs(struct pipe_screen *screen);
diff --git a/src/gallium/drivers/softpipe/sp_tile_cache.c b/src/gallium/drivers/softpipe/sp_tile_cache.c
index 7551b923fb7..d996c2a3427 100644
--- a/src/gallium/drivers/softpipe/sp_tile_cache.c
+++ b/src/gallium/drivers/softpipe/sp_tile_cache.c
@@ -121,7 +121,7 @@ sp_destroy_tile_cache(struct softpipe_tile_cache *tc)
       /*assert(tc->entries[pos].x < 0);*/
    }
    if (tc->transfer) {
-      tc->pipe->tex_transfer_destroy(tc->pipe, tc->transfer);
+      tc->pipe->transfer_destroy(tc->pipe, tc->transfer);
    }
 
    FREE( tc );
@@ -146,17 +146,17 @@ sp_tile_cache_set_surface(struct softpipe_tile_cache *tc,
          tc->transfer_map = NULL;
       }
 
-      pipe->tex_transfer_destroy(pipe, tc->transfer);
+      pipe->transfer_destroy(pipe, tc->transfer);
       tc->transfer = NULL;
    }
 
    tc->surface = ps;
 
    if (ps) {
-      tc->transfer = pipe->get_tex_transfer(pipe, ps->texture, ps->face,
-                                              ps->level, ps->zslice,
-                                              PIPE_TRANSFER_READ_WRITE,
-                                              0, 0, ps->width, ps->height);
+      tc->transfer = pipe_get_transfer(pipe, ps->texture, ps->face,
+					   ps->level, ps->zslice,
+					   PIPE_TRANSFER_READ_WRITE,
+					   0, 0, ps->width, ps->height);
 
       tc->depth_stencil = (ps->format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
                            ps->format == PIPE_FORMAT_Z24X8_UNORM ||
@@ -276,14 +276,14 @@ static void
 sp_tile_cache_flush_clear(struct softpipe_tile_cache *tc)
 {
    struct pipe_transfer *pt = tc->transfer;
-   const uint w = tc->transfer->width;
-   const uint h = tc->transfer->height;
+   const uint w = tc->transfer->box.width;
+   const uint h = tc->transfer->box.height;
    uint x, y;
    uint numCleared = 0;
 
-   assert(pt->texture);
+   assert(pt->resource);
    /* clear the scratch tile to the clear value */
-   clear_tile(&tc->tile, pt->texture->format, tc->clear_val);
+   clear_tile(&tc->tile, pt->resource->format, tc->clear_val);
 
    /* push the tile to all positions marked as clear */
    for (y = 0; y < h; y += TILE_SIZE) {
@@ -372,7 +372,7 @@ sp_find_cached_tile(struct softpipe_tile_cache *tc,
 
    if (addr.value != tile->addr.value) {
 
-      assert(pt->texture);
+      assert(pt->resource);
       if (tile->addr.bits.invalid == 0) {
          /* put dirty tile back in framebuffer */
          if (tc->depth_stencil) {
@@ -396,10 +396,10 @@ sp_find_cached_tile(struct softpipe_tile_cache *tc,
       if (is_clear_flag_set(tc->clear_flags, addr)) {
          /* don't get tile from framebuffer, just clear it */
          if (tc->depth_stencil) {
-            clear_tile(tile, pt->texture->format, tc->clear_val);
+            clear_tile(tile, pt->resource->format, tc->clear_val);
          }
          else {
-            clear_tile_rgba(tile, pt->texture->format, tc->clear_color);
+            clear_tile_rgba(tile, pt->resource->format, tc->clear_color);
          }
          clear_clear_flag(tc->clear_flags, addr);
       }
diff --git a/src/gallium/drivers/softpipe/sp_video_context.c b/src/gallium/drivers/softpipe/sp_video_context.c
deleted file mode 100644
index 242aaac4665..00000000000
--- a/src/gallium/drivers/softpipe/sp_video_context.c
+++ /dev/null
@@ -1,304 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include "util/u_inlines.h"
-#include "util/u_memory.h"
-
-#include "sp_video_context.h"
-#include "sp_texture.h"
-
-
-static void
-sp_mpeg12_destroy(struct pipe_video_context *vpipe)
-{
-   struct sp_mpeg12_context *ctx = (struct sp_mpeg12_context*)vpipe;
-
-   assert(vpipe);
-	
-   /* Asserted in softpipe_delete_fs_state() for some reason */
-   ctx->pipe->bind_vs_state(ctx->pipe, NULL);
-   ctx->pipe->bind_fs_state(ctx->pipe, NULL);
-
-   ctx->pipe->delete_blend_state(ctx->pipe, ctx->blend);
-   ctx->pipe->delete_rasterizer_state(ctx->pipe, ctx->rast);
-   ctx->pipe->delete_depth_stencil_alpha_state(ctx->pipe, ctx->dsa);
-
-   pipe_video_surface_reference(&ctx->decode_target, NULL);
-   vl_compositor_cleanup(&ctx->compositor);
-   vl_mpeg12_mc_renderer_cleanup(&ctx->mc_renderer);
-   ctx->pipe->destroy(ctx->pipe);
-
-   FREE(ctx);
-}
-
-static void
-sp_mpeg12_decode_macroblocks(struct pipe_video_context *vpipe,
-                             struct pipe_video_surface *past,
-                             struct pipe_video_surface *future,
-                             unsigned num_macroblocks,
-                             struct pipe_macroblock *macroblocks,
-                             struct pipe_fence_handle **fence)
-{
-   struct sp_mpeg12_context *ctx = (struct sp_mpeg12_context*)vpipe;
-   struct pipe_mpeg12_macroblock *mpeg12_macroblocks = (struct pipe_mpeg12_macroblock*)macroblocks;
-
-   assert(vpipe);
-   assert(num_macroblocks);
-   assert(macroblocks);
-   assert(macroblocks->codec == PIPE_VIDEO_CODEC_MPEG12);
-   assert(ctx->decode_target);
-
-   vl_mpeg12_mc_renderer_render_macroblocks(&ctx->mc_renderer,
-                                            softpipe_video_surface(ctx->decode_target)->tex,
-                                            past ? softpipe_video_surface(past)->tex : NULL,
-                                            future ? softpipe_video_surface(future)->tex : NULL,
-                                            num_macroblocks, mpeg12_macroblocks, fence);
-}
-
-static void
-sp_mpeg12_clear_surface(struct pipe_video_context *vpipe,
-                        unsigned x, unsigned y,
-                        unsigned width, unsigned height,
-                        unsigned value,
-                        struct pipe_surface *surface)
-{
-   struct sp_mpeg12_context *ctx = (struct sp_mpeg12_context*)vpipe;
-
-   assert(vpipe);
-   assert(surface);
-
-   ctx->pipe->surface_fill(ctx->pipe, surface, x, y, width, height, value);
-}
-
-static void
-sp_mpeg12_render_picture(struct pipe_video_context     *vpipe,
-                         /*struct pipe_surface         *backround,
-                         struct pipe_video_rect        *backround_area,*/
-                         struct pipe_video_surface     *src_surface,
-                         enum pipe_mpeg12_picture_type picture_type,
-                         /*unsigned                    num_past_surfaces,
-                         struct pipe_video_surface     *past_surfaces,
-                         unsigned                      num_future_surfaces,
-                         struct pipe_video_surface     *future_surfaces,*/
-                         struct pipe_video_rect        *src_area,
-                         struct pipe_surface           *dst_surface,
-                         struct pipe_video_rect        *dst_area,
-                         /*unsigned                      num_layers,
-                         struct pipe_surface           *layers,
-                         struct pipe_video_rect        *layer_src_areas,
-                         struct pipe_video_rect        *layer_dst_areas*/
-                         struct pipe_fence_handle      **fence)
-{
-   struct sp_mpeg12_context *ctx = (struct sp_mpeg12_context*)vpipe;
-	
-   assert(vpipe);
-   assert(src_surface);
-   assert(src_area);
-   assert(dst_surface);
-   assert(dst_area);
-	
-   vl_compositor_render(&ctx->compositor, softpipe_video_surface(src_surface)->tex,
-                        picture_type, src_area, dst_surface->texture, dst_area, fence);
-}
-
-static void
-sp_mpeg12_set_decode_target(struct pipe_video_context *vpipe,
-                            struct pipe_video_surface *dt)
-{
-   struct sp_mpeg12_context *ctx = (struct sp_mpeg12_context*)vpipe;
-
-   assert(vpipe);
-   assert(dt);
-
-   pipe_video_surface_reference(&ctx->decode_target, dt);
-}
-
-static void sp_mpeg12_set_csc_matrix(struct pipe_video_context *vpipe, const float *mat)
-{
-   struct sp_mpeg12_context *ctx = (struct sp_mpeg12_context*)vpipe;
-
-   assert(vpipe);
-
-   vl_compositor_set_csc_matrix(&ctx->compositor, mat);
-}
-
-static bool
-init_pipe_state(struct sp_mpeg12_context *ctx)
-{
-   struct pipe_rasterizer_state rast;
-   struct pipe_blend_state blend;
-   struct pipe_depth_stencil_alpha_state dsa;
-   unsigned i;
-
-   assert(ctx);
-	
-   rast.flatshade = 1;
-   rast.flatshade_first = 0;
-   rast.light_twoside = 0;
-   rast.front_winding = PIPE_WINDING_CCW;
-   rast.cull_mode = PIPE_WINDING_CW;
-   rast.fill_cw = PIPE_POLYGON_MODE_FILL;
-   rast.fill_ccw = PIPE_POLYGON_MODE_FILL;
-   rast.offset_cw = 0;
-   rast.offset_ccw = 0;
-   rast.scissor = 0;
-   rast.poly_smooth = 0;
-   rast.poly_stipple_enable = 0;
-   rast.sprite_coord_enable = 0;
-   rast.point_size_per_vertex = 0;
-   rast.multisample = 0;
-   rast.line_smooth = 0;
-   rast.line_stipple_enable = 0;
-   rast.line_stipple_factor = 0;
-   rast.line_stipple_pattern = 0;
-   rast.line_last_pixel = 0;
-   rast.line_width = 1;
-   rast.point_smooth = 0;
-   rast.point_quad_rasterization = 0;
-   rast.point_size = 1;
-   rast.offset_units = 1;
-   rast.offset_scale = 1;
-   ctx->rast = ctx->pipe->create_rasterizer_state(ctx->pipe, &rast);
-   ctx->pipe->bind_rasterizer_state(ctx->pipe, ctx->rast);
-
-   blend.independent_blend_enable = 0;
-   blend.rt[0].blend_enable = 0;
-   blend.rt[0].rgb_func = PIPE_BLEND_ADD;
-   blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
-   blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
-   blend.rt[0].alpha_func = PIPE_BLEND_ADD;
-   blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
-   blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
-   blend.logicop_enable = 0;
-   blend.logicop_func = PIPE_LOGICOP_CLEAR;
-   /* Needed to allow color writes to FB, even if blending disabled */
-   blend.rt[0].colormask = PIPE_MASK_RGBA;
-   blend.dither = 0;
-   ctx->blend = ctx->pipe->create_blend_state(ctx->pipe, &blend);
-   ctx->pipe->bind_blend_state(ctx->pipe, ctx->blend);
-
-   dsa.depth.enabled = 0;
-   dsa.depth.writemask = 0;
-   dsa.depth.func = PIPE_FUNC_ALWAYS;
-   for (i = 0; i < 2; ++i) {
-      dsa.stencil[i].enabled = 0;
-      dsa.stencil[i].func = PIPE_FUNC_ALWAYS;
-      dsa.stencil[i].fail_op = PIPE_STENCIL_OP_KEEP;
-      dsa.stencil[i].zpass_op = PIPE_STENCIL_OP_KEEP;
-      dsa.stencil[i].zfail_op = PIPE_STENCIL_OP_KEEP;
-      dsa.stencil[i].valuemask = 0;
-      dsa.stencil[i].writemask = 0;
-   }
-   dsa.alpha.enabled = 0;
-   dsa.alpha.func = PIPE_FUNC_ALWAYS;
-   dsa.alpha.ref_value = 0;
-   ctx->dsa = ctx->pipe->create_depth_stencil_alpha_state(ctx->pipe, &dsa);
-   ctx->pipe->bind_depth_stencil_alpha_state(ctx->pipe, ctx->dsa);
-	
-   return true;
-}
-
-static struct pipe_video_context *
-sp_mpeg12_create(struct pipe_screen *screen, enum pipe_video_profile profile,
-                 enum pipe_video_chroma_format chroma_format,
-                 unsigned width, unsigned height)
-{
-   struct sp_mpeg12_context *ctx;
-
-   assert(u_reduce_video_profile(profile) == PIPE_VIDEO_CODEC_MPEG12);
-
-   ctx = CALLOC_STRUCT(sp_mpeg12_context);
-
-   if (!ctx)
-      return NULL;
-
-   ctx->base.profile = profile;
-   ctx->base.chroma_format = chroma_format;
-   ctx->base.width = width;
-   ctx->base.height = height;
-
-   ctx->base.screen = screen;
-   ctx->base.destroy = sp_mpeg12_destroy;
-   ctx->base.decode_macroblocks = sp_mpeg12_decode_macroblocks;
-   ctx->base.clear_surface = sp_mpeg12_clear_surface;
-   ctx->base.render_picture = sp_mpeg12_render_picture;
-   ctx->base.set_decode_target = sp_mpeg12_set_decode_target;
-   ctx->base.set_csc_matrix = sp_mpeg12_set_csc_matrix;
-
-   ctx->pipe = screen->context_create(screen, NULL);
-   if (!ctx->pipe) {
-      FREE(ctx);
-      return NULL;
-   }
-
-   /* TODO: Use slice buffering for softpipe when implemented, no advantage to buffering an entire picture */
-   if (!vl_mpeg12_mc_renderer_init(&ctx->mc_renderer, ctx->pipe,
-                                   width, height, chroma_format,
-                                   VL_MPEG12_MC_RENDERER_BUFFER_PICTURE,
-                                   /* TODO: Use XFER_NONE when implemented */
-                                   VL_MPEG12_MC_RENDERER_EMPTY_BLOCK_XFER_ONE,
-                                   true)) {
-      ctx->pipe->destroy(ctx->pipe);
-      FREE(ctx);
-      return NULL;
-   }
-	
-   if (!vl_compositor_init(&ctx->compositor, ctx->pipe)) {
-      vl_mpeg12_mc_renderer_cleanup(&ctx->mc_renderer);
-      ctx->pipe->destroy(ctx->pipe);
-      FREE(ctx);
-      return NULL;
-   }
-	
-   if (!init_pipe_state(ctx)) {
-      vl_compositor_cleanup(&ctx->compositor);
-      vl_mpeg12_mc_renderer_cleanup(&ctx->mc_renderer);
-      ctx->pipe->destroy(ctx->pipe);
-      FREE(ctx);
-      return NULL;
-   }
-
-   return &ctx->base;
-}
-
-struct pipe_video_context *
-sp_video_create(struct pipe_screen *screen, enum pipe_video_profile profile,
-                enum pipe_video_chroma_format chroma_format,
-                unsigned width, unsigned height)
-{
-   assert(screen);
-   assert(width && height);
-
-   switch (u_reduce_video_profile(profile)) {
-      case PIPE_VIDEO_CODEC_MPEG12:
-         return sp_mpeg12_create(screen, profile,
-                                 chroma_format,
-                                 width, height);
-      default:
-         return NULL;
-   }
-}
diff --git a/src/gallium/drivers/softpipe/sp_video_context.h b/src/gallium/drivers/softpipe/sp_video_context.h
deleted file mode 100644
index ccbd1ffe4c8..00000000000
--- a/src/gallium/drivers/softpipe/sp_video_context.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 SP_VIDEO_CONTEXT_H
-#define SP_VIDEO_CONTEXT_H
-
-#include <pipe/p_video_context.h>
-#include <vl/vl_mpeg12_mc_renderer.h>
-#include <vl/vl_compositor.h>
-
-struct pipe_screen;
-struct pipe_context;
-struct pipe_video_surface;
-
-struct sp_mpeg12_context
-{
-   struct pipe_video_context base;
-   struct pipe_context *pipe;
-   struct pipe_video_surface *decode_target;
-   struct vl_mpeg12_mc_renderer mc_renderer;
-   struct vl_compositor compositor;
-
-   void *rast;
-   void *dsa;
-   void *blend;
-};
-
-struct pipe_video_context *
-sp_video_create(struct pipe_screen *screen, enum pipe_video_profile profile,
-                enum pipe_video_chroma_format chroma_format,
-                unsigned width, unsigned height);
-
-#endif /* SP_VIDEO_CONTEXT_H */
diff --git a/src/gallium/drivers/svga/Makefile b/src/gallium/drivers/svga/Makefile
index f3619081875..27287793bda 100644
--- a/src/gallium/drivers/svga/Makefile
+++ b/src/gallium/drivers/svga/Makefile
@@ -27,8 +27,6 @@ C_SOURCES = \
 	svga_pipe_vertex.c \
 	svga_pipe_vs.c \
 	svga_screen.c \
-	svga_screen_buffer.c \
-	svga_screen_texture.c \
 	svga_screen_cache.c \
 	svga_state.c \
 	svga_state_need_swtnl.c \
@@ -45,7 +43,14 @@ C_SOURCES = \
 	svga_tgsi.c \
 	svga_tgsi_decl_sm20.c \
 	svga_tgsi_decl_sm30.c \
-	svga_tgsi_insn.c
+	svga_tgsi_insn.c \
+	svga_sampler_view.c \
+	svga_surface.c \
+	svga_resource.c \
+	svga_resource_texture.c \
+	svga_resource_buffer.c \
+	svga_resource_buffer_upload.c 
+
 
 LIBRARY_INCLUDES = \
 	-I$(TOP)/src/gallium/drivers/svga/include
diff --git a/src/gallium/drivers/svga/SConscript b/src/gallium/drivers/svga/SConscript
index 737b791ceb0..12ce4732d15 100644
--- a/src/gallium/drivers/svga/SConscript
+++ b/src/gallium/drivers/svga/SConscript
@@ -38,10 +38,13 @@ sources = [
     'svga_pipe_sampler.c',
     'svga_pipe_vertex.c',
     'svga_pipe_vs.c',
+    'svga_resource.c',
+    'svga_resource_buffer.c',
+    'svga_resource_buffer_upload.c',
+    'svga_resource_texture.c',
+    'svga_sampler_view.c',
     'svga_screen.c',
-    'svga_screen_buffer.c',
     'svga_screen_cache.c',
-    'svga_screen_texture.c',
     'svga_state.c',
     'svga_state_constants.c',
     'svga_state_framebuffer.c',
@@ -51,6 +54,7 @@ sources = [
     'svga_state_vdecl.c',
     'svga_state_fs.c',
     'svga_state_vs.c',
+    'svga_surface.c',
     'svga_swtnl_backend.c',
     'svga_swtnl_draw.c',
     'svga_swtnl_state.c',
diff --git a/src/gallium/drivers/svga/svga_cmd.c b/src/gallium/drivers/svga/svga_cmd.c
index 04307d17fe0..7b2dfe25496 100644
--- a/src/gallium/drivers/svga/svga_cmd.c
+++ b/src/gallium/drivers/svga/svga_cmd.c
@@ -31,8 +31,9 @@
  */
 
 #include "svga_winsys.h"
-#include "svga_screen_buffer.h"
-#include "svga_screen_texture.h"
+#include "svga_resource_buffer.h"
+#include "svga_resource_texture.h"
+#include "svga_surface.h"
 #include "svga_cmd.h"
 
 /*
@@ -279,7 +280,7 @@ SVGA3D_BeginDefineSurface(struct svga_winsys_context *swc,
    if(!cmd)
       return PIPE_ERROR_OUT_OF_MEMORY;
 
-   swc->surface_relocation(swc, &cmd->sid, sid, PIPE_BUFFER_USAGE_GPU_WRITE);
+   swc->surface_relocation(swc, &cmd->sid, sid, SVGA_RELOC_WRITE);
    cmd->surfaceFlags = flags;
    cmd->format = format;
 
@@ -365,7 +366,7 @@ SVGA3D_DestroySurface(struct svga_winsys_context *swc,
    if(!cmd)
       return PIPE_ERROR_OUT_OF_MEMORY;
    
-   swc->surface_relocation(swc, &cmd->sid, sid, PIPE_BUFFER_USAGE_GPU_READ);
+   swc->surface_relocation(swc, &cmd->sid, sid, SVGA_RELOC_READ);
    swc->commit(swc);;
    
    return PIPE_OK;
@@ -423,7 +424,7 @@ SVGA3D_SurfaceDMA(struct svga_winsys_context *swc,
                   const SVGA3dCopyBox *boxes,       // IN
                   uint32 numBoxes)                  // IN
 {
-   struct svga_texture *texture = svga_texture(st->base.texture); 
+   struct svga_texture *texture = svga_texture(st->base.resource); 
    SVGA3dCmdSurfaceDMA *cmd;
    SVGA3dCmdSurfaceDMASuffix *pSuffix;
    uint32 boxesSize = sizeof *boxes * numBoxes;
@@ -431,12 +432,12 @@ SVGA3D_SurfaceDMA(struct svga_winsys_context *swc,
    unsigned surface_flags;
    
    if(transfer == SVGA3D_WRITE_HOST_VRAM) {
-      region_flags = PIPE_BUFFER_USAGE_GPU_READ;
-      surface_flags = PIPE_BUFFER_USAGE_GPU_WRITE;
+      region_flags = SVGA_RELOC_READ;
+      surface_flags = SVGA_RELOC_WRITE;
    }
    else if(transfer == SVGA3D_READ_HOST_VRAM) {
-      region_flags = PIPE_BUFFER_USAGE_GPU_WRITE;
-      surface_flags = PIPE_BUFFER_USAGE_GPU_READ;
+      region_flags = SVGA_RELOC_WRITE;
+      surface_flags = SVGA_RELOC_READ;
    }
    else {
       assert(0);
@@ -454,8 +455,8 @@ SVGA3D_SurfaceDMA(struct svga_winsys_context *swc,
    cmd->guest.pitch = st->base.stride;
 
    swc->surface_relocation(swc, &cmd->host.sid, texture->handle, surface_flags);
-   cmd->host.face = st->base.face; /* PIPE_TEX_FACE_* and SVGA3D_CUBEFACE_* match */
-   cmd->host.mipmap = st->base.level;
+   cmd->host.face = st->base.sr.face; /* PIPE_TEX_FACE_* and SVGA3D_CUBEFACE_* match */
+   cmd->host.mipmap = st->base.sr.level;
 
    cmd->transfer = transfer;
 
@@ -489,12 +490,12 @@ SVGA3D_BufferDMA(struct svga_winsys_context *swc,
    unsigned surface_flags;
    
    if(transfer == SVGA3D_WRITE_HOST_VRAM) {
-      region_flags = PIPE_BUFFER_USAGE_GPU_READ;
-      surface_flags = PIPE_BUFFER_USAGE_GPU_WRITE;
+      region_flags = SVGA_RELOC_READ;
+      surface_flags = SVGA_RELOC_WRITE;
    }
    else if(transfer == SVGA3D_READ_HOST_VRAM) {
-      region_flags = PIPE_BUFFER_USAGE_GPU_WRITE;
-      surface_flags = PIPE_BUFFER_USAGE_GPU_READ;
+      region_flags = SVGA_RELOC_WRITE;
+      surface_flags = SVGA_RELOC_READ;
    }
    else {
       assert(0);
@@ -584,7 +585,7 @@ SVGA3D_SetRenderTarget(struct svga_winsys_context *swc,
 
    cmd->type = type;
 
-   surface_to_surfaceid(swc, surface, &cmd->target, PIPE_BUFFER_USAGE_GPU_WRITE);
+   surface_to_surfaceid(swc, surface, &cmd->target, SVGA_RELOC_WRITE);
 
    swc->commit(swc);
 
@@ -1000,8 +1001,8 @@ SVGA3D_BeginSurfaceCopy(struct svga_winsys_context *swc,
    if(!cmd)
       return PIPE_ERROR_OUT_OF_MEMORY;
 
-   surface_to_surfaceid(swc, src, &cmd->src, PIPE_BUFFER_USAGE_GPU_READ);
-   surface_to_surfaceid(swc, dest, &cmd->dest, PIPE_BUFFER_USAGE_GPU_WRITE);
+   surface_to_surfaceid(swc, src, &cmd->src, SVGA_RELOC_READ);
+   surface_to_surfaceid(swc, dest, &cmd->dest, SVGA_RELOC_WRITE);
    *boxes = (SVGA3dCopyBox*) &cmd[1];
 
    memset(*boxes, 0, boxesSize);
@@ -1043,8 +1044,8 @@ SVGA3D_SurfaceStretchBlt(struct svga_winsys_context *swc,
    if(!cmd)
       return PIPE_ERROR_OUT_OF_MEMORY;
 
-   surface_to_surfaceid(swc, src, &cmd->src, PIPE_BUFFER_USAGE_GPU_READ);
-   surface_to_surfaceid(swc, dest, &cmd->dest, PIPE_BUFFER_USAGE_GPU_WRITE);
+   surface_to_surfaceid(swc, src, &cmd->src, SVGA_RELOC_READ);
+   surface_to_surfaceid(swc, dest, &cmd->dest, SVGA_RELOC_WRITE);
    cmd->boxSrc = *boxSrc;
    cmd->boxDest = *boxDest;
    cmd->mode = mode;
@@ -1373,7 +1374,7 @@ SVGA3D_EndQuery(struct svga_winsys_context *swc,
    cmd->type = type;
 
    swc->region_relocation(swc, &cmd->guestResult, buffer, 0,
-                          PIPE_BUFFER_USAGE_GPU_WRITE);
+                          SVGA_RELOC_WRITE);
 
    swc->commit(swc);
    
@@ -1420,7 +1421,7 @@ SVGA3D_WaitForQuery(struct svga_winsys_context *swc,
    cmd->type = type;
    
    swc->region_relocation(swc, &cmd->guestResult, buffer, 0,
-                          PIPE_BUFFER_USAGE_GPU_WRITE);
+                          SVGA_RELOC_WRITE);
 
    swc->commit(swc);
    
diff --git a/src/gallium/drivers/svga/svga_cmd.h b/src/gallium/drivers/svga/svga_cmd.h
index da9fc4355fa..0e568d78e65 100644
--- a/src/gallium/drivers/svga/svga_cmd.h
+++ b/src/gallium/drivers/svga/svga_cmd.h
@@ -41,7 +41,6 @@
 #include "pipe/p_defines.h"
 
 
-struct pipe_buffer;
 struct pipe_surface;
 struct svga_transfer;
 struct svga_winsys_context;
diff --git a/src/gallium/drivers/svga/svga_context.c b/src/gallium/drivers/svga/svga_context.c
index adb7840182b..3228a6d3d7f 100644
--- a/src/gallium/drivers/svga/svga_context.c
+++ b/src/gallium/drivers/svga/svga_context.c
@@ -34,8 +34,9 @@
 
 #include "svga_context.h"
 #include "svga_screen.h"
-#include "svga_screen_texture.h"
-#include "svga_screen_buffer.h"
+#include "svga_resource_texture.h"
+#include "svga_resource_buffer.h"
+#include "svga_resource.h"
 #include "svga_winsys.h"
 #include "svga_swtnl.h"
 #include "svga_draw.h"
@@ -66,64 +67,11 @@ static void svga_destroy( struct pipe_context *pipe )
    util_bitmask_destroy( svga->fs_bm );
 
    for(shader = 0; shader < PIPE_SHADER_TYPES; ++shader)
-      pipe_buffer_reference( &svga->curr.cb[shader], NULL );
+      pipe_resource_reference( &svga->curr.cb[shader], NULL );
 
    FREE( svga );
 }
 
-static unsigned int
-svga_is_texture_referenced( struct pipe_context *pipe,
-			    struct pipe_texture *texture,
-			    unsigned face, unsigned level)
-{
-   struct svga_texture *tex = svga_texture(texture);
-   struct svga_screen *ss = svga_screen(pipe->screen);
-
-   /**
-    * The screen does not cache texture writes.
-    */
-
-   if (!tex->handle || ss->sws->surface_is_flushed(ss->sws, tex->handle))
-      return PIPE_UNREFERENCED;
-
-   /**
-    * sws->surface_is_flushed() does not distinguish between read references
-    * and write references. So assume a reference is both.
-    */
-
-   return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
-}
-
-static unsigned int
-svga_is_buffer_referenced( struct pipe_context *pipe,
-			   struct pipe_buffer *buf)
-
-{
-   struct svga_screen *ss = svga_screen(pipe->screen);
-   struct svga_buffer *sbuf = svga_buffer(buf);
-
-   /**
-    * XXX: Check this.
-    * The screen may cache buffer writes, but when we map, we map out
-    * of those cached writes, so we don't need to set a
-    * PIPE_REFERENCED_FOR_WRITE flag for cached buffers.
-    */
-
-   if (!sbuf->handle || ss->sws->surface_is_flushed(ss->sws, sbuf->handle))
-     return PIPE_UNREFERENCED;
-
-   /**
-    * sws->surface_is_flushed() does not distinguish between read references
-    * and write references. So assume a reference is both,
-    * however, we make an exception for index- and vertex buffers, to avoid
-    * a flush in st_bufferobj_get_subdata, during display list replay.
-    */
-
-   if (sbuf->base.usage & (PIPE_BUFFER_USAGE_VERTEX | PIPE_BUFFER_USAGE_INDEX))
-      return PIPE_REFERENCED_FOR_READ;
-
-   return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
-}
 
 
 struct pipe_context *svga_context_create( struct pipe_screen *screen,
@@ -143,13 +91,11 @@ struct pipe_context *svga_context_create( struct pipe_screen *screen,
    svga->pipe.destroy = svga_destroy;
    svga->pipe.clear = svga_clear;
 
-   svga->pipe.is_texture_referenced = svga_is_texture_referenced;
-   svga->pipe.is_buffer_referenced = svga_is_buffer_referenced;
-
    svga->swc = svgascreen->sws->context_create(svgascreen->sws);
    if(!svga->swc)
       goto no_swc;
 
+   svga_init_resource_functions(svga);
    svga_init_blend_functions(svga);
    svga_init_blit_functions(svga);
    svga_init_depth_stencil_functions(svga);
@@ -164,7 +110,6 @@ struct pipe_context *svga_context_create( struct pipe_screen *screen,
    svga_init_constbuffer_functions(svga);
    svga_init_query_functions(svga);
 
-   svga_init_texture_functions(&svga->pipe);
 
    /* debug */
    svga->debug.no_swtnl = debug_get_bool_option("SVGA_NO_SWTNL", FALSE);
@@ -183,17 +128,17 @@ struct pipe_context *svga_context_create( struct pipe_screen *screen,
    if (svga->vs_bm == NULL)
       goto no_vs_bm;
 
-   svga->upload_ib = u_upload_create( svga->pipe.screen,
+   svga->upload_ib = u_upload_create( &svga->pipe,
                                       32 * 1024,
                                       16,
-                                      PIPE_BUFFER_USAGE_INDEX );
+                                      PIPE_BIND_INDEX_BUFFER );
    if (svga->upload_ib == NULL)
       goto no_upload_ib;
 
-   svga->upload_vb = u_upload_create( svga->pipe.screen,
+   svga->upload_vb = u_upload_create( &svga->pipe,
                                       128 * 1024,
                                       16,
-                                      PIPE_BUFFER_USAGE_VERTEX );
+                                      PIPE_BIND_VERTEX_BUFFER );
    if (svga->upload_vb == NULL)
       goto no_upload_vb;
 
diff --git a/src/gallium/drivers/svga/svga_context.h b/src/gallium/drivers/svga/svga_context.h
index 1f66437dfe1..9a46de643fd 100644
--- a/src/gallium/drivers/svga/svga_context.h
+++ b/src/gallium/drivers/svga/svga_context.h
@@ -190,7 +190,7 @@ struct svga_state
    struct svga_vertex_shader *vs;
 
    struct pipe_vertex_buffer vb[PIPE_MAX_ATTRIBS];
-   struct pipe_buffer *cb[PIPE_SHADER_TYPES];
+   struct pipe_resource *cb[PIPE_SHADER_TYPES];
 
    struct pipe_framebuffer_state framebuffer;
    float depthscale;
@@ -254,7 +254,7 @@ struct svga_hw_clear_state
 
 struct svga_hw_view_state
 {
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct svga_sampler_view *v;
    unsigned min_lod;
    unsigned max_lod;
diff --git a/src/gallium/drivers/svga/svga_draw.c b/src/gallium/drivers/svga/svga_draw.c
index 8b7ca2e1123..81dd4778d0a 100644
--- a/src/gallium/drivers/svga/svga_draw.c
+++ b/src/gallium/drivers/svga/svga_draw.c
@@ -34,8 +34,9 @@
 #include "svga_draw_private.h"
 #include "svga_debug.h"
 #include "svga_screen.h"
-#include "svga_screen_buffer.h"
-#include "svga_screen_texture.h"
+#include "svga_resource_buffer.h"
+#include "svga_resource_texture.h"
+#include "svga_surface.h"
 #include "svga_winsys.h"
 #include "svga_cmd.h"
 
@@ -65,16 +66,16 @@ void svga_hwtnl_destroy( struct svga_hwtnl *hwtnl )
 
    for (i = 0; i < PIPE_PRIM_MAX; i++) {
       for (j = 0; j < IDX_CACHE_MAX; j++) {
-         pipe_buffer_reference( &hwtnl->index_cache[i][j].buffer,
+         pipe_resource_reference( &hwtnl->index_cache[i][j].buffer,
                                 NULL );
       }
    }
 
    for (i = 0; i < hwtnl->cmd.vdecl_count; i++)
-      pipe_buffer_reference(&hwtnl->cmd.vdecl_vb[i], NULL);
+      pipe_resource_reference(&hwtnl->cmd.vdecl_vb[i], NULL);
 
    for (i = 0; i < hwtnl->cmd.prim_count; i++)
-      pipe_buffer_reference(&hwtnl->cmd.prim_ib[i], NULL);
+      pipe_resource_reference(&hwtnl->cmd.prim_ib[i], NULL);
       
 
    FREE(hwtnl);
@@ -103,7 +104,7 @@ void svga_hwtnl_reset_vdecl( struct svga_hwtnl *hwtnl,
    assert(hwtnl->cmd.prim_count == 0);
 
    for (i = count; i < hwtnl->cmd.vdecl_count; i++) {
-      pipe_buffer_reference(&hwtnl->cmd.vdecl_vb[i],
+      pipe_resource_reference(&hwtnl->cmd.vdecl_vb[i],
                             NULL);
    }
 
@@ -112,9 +113,9 @@ void svga_hwtnl_reset_vdecl( struct svga_hwtnl *hwtnl,
 
 
 void svga_hwtnl_vdecl( struct svga_hwtnl *hwtnl,
-                          unsigned i,
-                          const SVGA3dVertexDecl *decl,
-                          struct pipe_buffer *vb)
+		       unsigned i,
+		       const SVGA3dVertexDecl *decl,
+		       struct pipe_resource *vb)
 {
    assert(hwtnl->cmd.prim_count == 0);
 
@@ -122,8 +123,7 @@ void svga_hwtnl_vdecl( struct svga_hwtnl *hwtnl,
 
    hwtnl->cmd.vdecl[i] = *decl;
 
-   pipe_buffer_reference(&hwtnl->cmd.vdecl_vb[i],
-                         vb);   
+   pipe_resource_reference(&hwtnl->cmd.vdecl_vb[i], vb);   
 }
 
 
@@ -198,7 +198,7 @@ svga_hwtnl_flush( struct svga_hwtnl *hwtnl )
          swc->surface_relocation(swc,
                                  &vdecl[i].array.surfaceId,
                                  vb_handle[i],
-                                 PIPE_BUFFER_USAGE_GPU_READ);
+                                 SVGA_RELOC_READ);
       }
 
       memcpy( prim,
@@ -209,8 +209,8 @@ svga_hwtnl_flush( struct svga_hwtnl *hwtnl )
          swc->surface_relocation(swc,
                                  &prim[i].indexArray.surfaceId,
                                  ib_handle[i],
-                                 PIPE_BUFFER_USAGE_GPU_READ);
-         pipe_buffer_reference(&hwtnl->cmd.prim_ib[i], NULL);
+                                 SVGA_RELOC_READ);
+         pipe_resource_reference(&hwtnl->cmd.prim_ib[i], NULL);
       }
       
       SVGA_FIFOCommitAll( swc );
@@ -232,7 +232,7 @@ enum pipe_error svga_hwtnl_prim( struct svga_hwtnl *hwtnl,
                                  const SVGA3dPrimitiveRange *range,
                                  unsigned min_index,
                                  unsigned max_index,
-                                 struct pipe_buffer *ib )
+                                 struct pipe_resource *ib )
 {
    int ret = PIPE_OK;
 
@@ -240,8 +240,8 @@ enum pipe_error svga_hwtnl_prim( struct svga_hwtnl *hwtnl,
    {
       unsigned i;
       for (i = 0; i < hwtnl->cmd.vdecl_count; i++) {
-         struct pipe_buffer *vb = hwtnl->cmd.vdecl_vb[i];
-         unsigned size = vb ? vb->size : 0;
+         struct pipe_resource *vb = hwtnl->cmd.vdecl_vb[i];
+         unsigned size = vb ? vb->width0 : 0;
          unsigned offset = hwtnl->cmd.vdecl[i].array.offset;
          unsigned stride = hwtnl->cmd.vdecl[i].array.stride;
          unsigned index_bias = range->indexBias;
@@ -324,7 +324,7 @@ enum pipe_error svga_hwtnl_prim( struct svga_hwtnl *hwtnl,
       assert(range->indexWidth == range->indexArray.stride);
 
       if(ib) {
-         unsigned size = ib->size;
+         unsigned size = ib->width0;
          unsigned offset = range->indexArray.offset;
          unsigned stride = range->indexArray.stride;
          unsigned count;
@@ -375,7 +375,7 @@ enum pipe_error svga_hwtnl_prim( struct svga_hwtnl *hwtnl,
 
    hwtnl->cmd.prim[hwtnl->cmd.prim_count] = *range;
 
-   pipe_buffer_reference(&hwtnl->cmd.prim_ib[hwtnl->cmd.prim_count], ib);
+   pipe_resource_reference(&hwtnl->cmd.prim_ib[hwtnl->cmd.prim_count], ib);
    hwtnl->cmd.prim_count++;
 
    return ret;
diff --git a/src/gallium/drivers/svga/svga_draw.h b/src/gallium/drivers/svga/svga_draw.h
index 14553b17b58..81c7f8377de 100644
--- a/src/gallium/drivers/svga/svga_draw.h
+++ b/src/gallium/drivers/svga/svga_draw.h
@@ -34,7 +34,7 @@ struct svga_hwtnl;
 struct svga_winsys_context;
 struct svga_screen;
 struct svga_context;
-struct pipe_buffer;
+struct pipe_resource;
 struct u_upload_mgr;
 
 struct svga_hwtnl *svga_hwtnl_create( struct svga_context *svga,
@@ -53,7 +53,7 @@ void svga_hwtnl_set_unfilled( struct svga_hwtnl *hwtnl,
 void svga_hwtnl_vdecl( struct svga_hwtnl *hwtnl,
                        unsigned i,
                        const SVGA3dVertexDecl *decl,
-                       struct pipe_buffer *vb);
+                       struct pipe_resource *vb);
 
 void svga_hwtnl_reset_vdecl( struct svga_hwtnl *hwtnl,
                              unsigned count );
@@ -67,7 +67,7 @@ svga_hwtnl_draw_arrays( struct svga_hwtnl *hwtnl,
 
 enum pipe_error
 svga_hwtnl_draw_range_elements( struct svga_hwtnl *hwtnl,
-                                struct pipe_buffer *indexBuffer,
+                                struct pipe_resource *indexBuffer,
                                 unsigned index_size,
                                 unsigned min_index,
                                 unsigned max_index,
diff --git a/src/gallium/drivers/svga/svga_draw_arrays.c b/src/gallium/drivers/svga/svga_draw_arrays.c
index 6192aa96b11..005996d05d3 100644
--- a/src/gallium/drivers/svga/svga_draw_arrays.c
+++ b/src/gallium/drivers/svga/svga_draw_arrays.c
@@ -43,40 +43,40 @@ static enum pipe_error generate_indices( struct svga_hwtnl *hwtnl,
                                          unsigned nr,
                                          unsigned index_size,
                                          u_generate_func generate,
-                                         struct pipe_buffer **out_buf )
+                                         struct pipe_resource **out_buf )
 {
-   struct pipe_screen *screen = hwtnl->svga->pipe.screen;
+   struct pipe_context *pipe = &hwtnl->svga->pipe;
+   struct pipe_transfer *transfer;
    unsigned size = index_size * nr;
-   struct pipe_buffer *dst = NULL;
+   struct pipe_resource *dst = NULL;
    void *dst_map = NULL;
 
-   dst = screen->buffer_create( screen, 32, 
-                                PIPE_BUFFER_USAGE_INDEX |
-                                PIPE_BUFFER_USAGE_CPU_WRITE |
-                                PIPE_BUFFER_USAGE_GPU_READ, 
-                                size );
+   dst = pipe_buffer_create( pipe->screen, 
+			     PIPE_BIND_INDEX_BUFFER, 
+			     size );
    if (dst == NULL)
       goto fail;
 
-   dst_map = pipe_buffer_map( screen, dst, PIPE_BUFFER_USAGE_CPU_WRITE );
+   dst_map = pipe_buffer_map( pipe, dst, PIPE_TRANSFER_WRITE,
+			      &transfer);
    if (dst_map == NULL)
       goto fail;
 
    generate( nr,
              dst_map );
 
-   pipe_buffer_unmap( screen, dst );
+   pipe_buffer_unmap( pipe, dst, transfer );
 
    *out_buf = dst;
    return PIPE_OK;
 
 fail:
    if (dst_map)
-      screen->buffer_unmap( screen, dst );
+      pipe_buffer_unmap( pipe, dst, transfer );
 
    if (dst)
-      screen->buffer_destroy( dst );
-
+      pipe->screen->resource_destroy( pipe->screen, dst );
+   
    return PIPE_ERROR_OUT_OF_MEMORY;
 }
 
@@ -96,7 +96,7 @@ static enum pipe_error retrieve_or_generate_indices( struct svga_hwtnl *hwtnl,
                                                      unsigned gen_nr,
                                                      unsigned gen_size,
                                                      u_generate_func generate,
-                                                     struct pipe_buffer **out_buf )
+                                                     struct pipe_resource **out_buf )
 {
    enum pipe_error ret = PIPE_OK;
    int i;
@@ -107,7 +107,7 @@ static enum pipe_error retrieve_or_generate_indices( struct svga_hwtnl *hwtnl,
       {
          if (compare(hwtnl->index_cache[prim][i].gen_nr, gen_nr, gen_type))
          {
-            pipe_buffer_reference( out_buf,
+            pipe_resource_reference( out_buf,
                                    hwtnl->index_cache[prim][i].buffer );
 
             if (DBG) 
@@ -117,7 +117,7 @@ static enum pipe_error retrieve_or_generate_indices( struct svga_hwtnl *hwtnl,
          }
          else if (gen_type == U_GENERATE_REUSABLE) 
          {
-            pipe_buffer_reference( &hwtnl->index_cache[prim][i].buffer,
+            pipe_resource_reference( &hwtnl->index_cache[prim][i].buffer,
                                    NULL );
 
             if (DBG) 
@@ -149,7 +149,7 @@ static enum pipe_error retrieve_or_generate_indices( struct svga_hwtnl *hwtnl,
 
       assert (smallest != IDX_CACHE_MAX);
 
-      pipe_buffer_reference( &hwtnl->index_cache[prim][smallest].buffer,
+      pipe_resource_reference( &hwtnl->index_cache[prim][smallest].buffer,
                              NULL );
 
       if (DBG)
@@ -171,7 +171,7 @@ static enum pipe_error retrieve_or_generate_indices( struct svga_hwtnl *hwtnl,
 
    hwtnl->index_cache[prim][i].generate = generate;
    hwtnl->index_cache[prim][i].gen_nr = gen_nr;
-   pipe_buffer_reference( &hwtnl->index_cache[prim][i].buffer,
+   pipe_resource_reference( &hwtnl->index_cache[prim][i].buffer,
                           *out_buf );
 
    if (DBG)
@@ -259,7 +259,7 @@ svga_hwtnl_draw_arrays( struct svga_hwtnl *hwtnl,
       return simple_draw_arrays( hwtnl, gen_prim, start, count );
    }
    else {
-      struct pipe_buffer *gen_buf = NULL;
+      struct pipe_resource *gen_buf = NULL;
 
       /* Need to draw as indexed primitive. 
        * Potentially need to run the gen func to build an index buffer.
@@ -288,7 +288,7 @@ svga_hwtnl_draw_arrays( struct svga_hwtnl *hwtnl,
 
    done:
       if (gen_buf)
-         pipe_buffer_reference( &gen_buf, NULL );
+         pipe_resource_reference( &gen_buf, NULL );
 
       return ret;
    }
diff --git a/src/gallium/drivers/svga/svga_draw_elements.c b/src/gallium/drivers/svga/svga_draw_elements.c
index e8097d82f16..7ec4a058fc7 100644
--- a/src/gallium/drivers/svga/svga_draw_elements.c
+++ b/src/gallium/drivers/svga/svga_draw_elements.c
@@ -30,7 +30,7 @@
 #include "svga_cmd.h"
 #include "svga_draw.h"
 #include "svga_draw_private.h"
-#include "svga_screen_buffer.h"
+#include "svga_resource_buffer.h"
 #include "svga_winsys.h"
 #include "svga_context.h"
 
@@ -39,32 +39,32 @@
 
 static enum pipe_error
 translate_indices( struct svga_hwtnl *hwtnl,
-                   struct pipe_buffer *src,
+                   struct pipe_resource *src,
                    unsigned offset,
                    unsigned nr,
                    unsigned index_size,
                    u_translate_func translate,
-                   struct pipe_buffer **out_buf )
+                   struct pipe_resource **out_buf )
 {
-   struct pipe_screen *screen = hwtnl->svga->pipe.screen;
+   struct pipe_context *pipe = &hwtnl->svga->pipe;
+   struct pipe_transfer *src_transfer = NULL;
+   struct pipe_transfer *dst_transfer = NULL;
    unsigned size = index_size * nr;
    const void *src_map = NULL;
-   struct pipe_buffer *dst = NULL;
+   struct pipe_resource *dst = NULL;
    void *dst_map = NULL;
 
-   dst = screen->buffer_create( screen, 32, 
-                                PIPE_BUFFER_USAGE_INDEX |
-                                PIPE_BUFFER_USAGE_CPU_WRITE |
-                                PIPE_BUFFER_USAGE_GPU_READ, 
-                                size );
+   dst = pipe_buffer_create( pipe->screen, 
+			     PIPE_BIND_INDEX_BUFFER, 
+			     size );
    if (dst == NULL)
       goto fail;
 
-   src_map = pipe_buffer_map( screen, src, PIPE_BUFFER_USAGE_CPU_READ );
+   src_map = pipe_buffer_map( pipe, src, PIPE_TRANSFER_READ, &src_transfer );
    if (src_map == NULL)
       goto fail;
 
-   dst_map = pipe_buffer_map( screen, dst, PIPE_BUFFER_USAGE_CPU_WRITE );
+   dst_map = pipe_buffer_map( pipe, dst, PIPE_TRANSFER_WRITE, &dst_transfer );
    if (dst_map == NULL)
       goto fail;
 
@@ -72,21 +72,21 @@ translate_indices( struct svga_hwtnl *hwtnl,
               nr,
               dst_map );
 
-   pipe_buffer_unmap( screen, src );
-   pipe_buffer_unmap( screen, dst );
+   pipe_buffer_unmap( pipe, src, src_transfer );
+   pipe_buffer_unmap( pipe, dst, dst_transfer );
 
    *out_buf = dst;
    return PIPE_OK;
 
 fail:
    if (src_map)
-      screen->buffer_unmap( screen, src );
+      pipe_buffer_unmap( pipe, src, src_transfer );
 
    if (dst_map)
-      screen->buffer_unmap( screen, dst );
+      pipe_buffer_unmap( pipe, dst, dst_transfer );
 
    if (dst)
-      screen->buffer_destroy( dst );
+      pipe->screen->resource_destroy( pipe->screen, dst );
 
    return PIPE_ERROR_OUT_OF_MEMORY;
 }
@@ -97,7 +97,7 @@ fail:
 
 enum pipe_error
 svga_hwtnl_simple_draw_range_elements( struct svga_hwtnl *hwtnl,
-                                       struct pipe_buffer *index_buffer,
+                                       struct pipe_resource *index_buffer,
                                        unsigned index_size,
                                        unsigned min_index,
                                        unsigned max_index,
@@ -106,7 +106,7 @@ svga_hwtnl_simple_draw_range_elements( struct svga_hwtnl *hwtnl,
                                        unsigned count,
                                        unsigned bias )
 {
-   struct pipe_buffer *upload_buffer = NULL;
+   struct pipe_resource *upload_buffer = NULL;
    SVGA3dPrimitiveRange range;
    unsigned hw_prim;
    unsigned hw_count;
@@ -120,7 +120,7 @@ svga_hwtnl_simple_draw_range_elements( struct svga_hwtnl *hwtnl,
    if (index_buffer && 
        svga_buffer_is_user_buffer(index_buffer)) 
    {
-      assert( index_buffer->size >= index_offset + count * index_size );
+      assert( index_buffer->width0 >= index_offset + count * index_size );
 
       ret = u_upload_buffer( hwtnl->upload_ib,
                              index_offset,
@@ -151,7 +151,7 @@ svga_hwtnl_simple_draw_range_elements( struct svga_hwtnl *hwtnl,
 
 done:
    if (upload_buffer)
-      pipe_buffer_reference( &upload_buffer, NULL );
+      pipe_resource_reference( &upload_buffer, NULL );
 
    return ret;
 }
@@ -161,7 +161,7 @@ done:
 
 enum pipe_error
 svga_hwtnl_draw_range_elements( struct svga_hwtnl *hwtnl,
-                                struct pipe_buffer *index_buffer,
+                                struct pipe_resource *index_buffer,
                                 unsigned index_size,
                                 unsigned min_index,
                                 unsigned max_index,
@@ -209,7 +209,7 @@ svga_hwtnl_draw_range_elements( struct svga_hwtnl *hwtnl,
                                                     gen_prim, start, count, bias );
    }
    else {
-      struct pipe_buffer *gen_buf = NULL;
+      struct pipe_resource *gen_buf = NULL;
 
       /* Need to allocate a new index buffer and run the translate
        * func to populate it.  Could potentially cache this translated
@@ -242,7 +242,7 @@ svga_hwtnl_draw_range_elements( struct svga_hwtnl *hwtnl,
 
    done:
       if (gen_buf)
-         pipe_buffer_reference( &gen_buf, NULL );
+         pipe_resource_reference( &gen_buf, NULL );
 
       return ret;
    }
diff --git a/src/gallium/drivers/svga/svga_draw_private.h b/src/gallium/drivers/svga/svga_draw_private.h
index 9aa40e16642..b6fcd6854c5 100644
--- a/src/gallium/drivers/svga/svga_draw_private.h
+++ b/src/gallium/drivers/svga/svga_draw_private.h
@@ -90,7 +90,7 @@ struct index_cache {
    /* If non-null, this buffer is filled by calling 
     *   generate(nr, map(buffer))
     */
-   struct pipe_buffer *buffer;
+   struct pipe_resource *buffer;
 };
 
 #define QSZ 32
@@ -99,11 +99,11 @@ struct draw_cmd {
    struct svga_winsys_context *swc;
 
    SVGA3dVertexDecl vdecl[SVGA3D_INPUTREG_MAX];
-   struct pipe_buffer *vdecl_vb[SVGA3D_INPUTREG_MAX];
+   struct pipe_resource *vdecl_vb[SVGA3D_INPUTREG_MAX];
    unsigned vdecl_count;
 
    SVGA3dPrimitiveRange prim[QSZ];
-   struct pipe_buffer *prim_ib[QSZ];
+   struct pipe_resource *prim_ib[QSZ];
    unsigned prim_count;
    unsigned min_index[QSZ];
    unsigned max_index[QSZ];
@@ -141,11 +141,11 @@ svga_hwtnl_prim( struct svga_hwtnl *hwtnl,
                  const SVGA3dPrimitiveRange *range,
                  unsigned min_index,
                  unsigned max_index,
-                 struct pipe_buffer *ib );
+                 struct pipe_resource *ib );
 
 enum pipe_error
 svga_hwtnl_simple_draw_range_elements( struct svga_hwtnl *hwtnl,
-                                       struct pipe_buffer *indexBuffer,
+                                       struct pipe_resource *indexBuffer,
                                        unsigned index_size,
                                        unsigned min_index,
                                        unsigned max_index,
diff --git a/src/gallium/drivers/svga/svga_pipe_blit.c b/src/gallium/drivers/svga/svga_pipe_blit.c
index 4f575b06e62..889da29e28b 100644
--- a/src/gallium/drivers/svga/svga_pipe_blit.c
+++ b/src/gallium/drivers/svga/svga_pipe_blit.c
@@ -23,10 +23,11 @@
  *
  **********************************************************/
 
-#include "svga_screen_texture.h"
+#include "svga_resource_texture.h"
 #include "svga_context.h"
 #include "svga_debug.h"
 #include "svga_cmd.h"
+#include "svga_surface.h"
 
 #define FILE_DEBUG_FLAG DEBUG_BLIT
 
diff --git a/src/gallium/drivers/svga/svga_pipe_clear.c b/src/gallium/drivers/svga/svga_pipe_clear.c
index bb1664fbed9..cbff95c9179 100644
--- a/src/gallium/drivers/svga/svga_pipe_clear.c
+++ b/src/gallium/drivers/svga/svga_pipe_clear.c
@@ -31,7 +31,7 @@
 
 #include "svga_context.h"
 #include "svga_state.h"
-#include "svga_screen_texture.h"
+#include "svga_surface.h"
 
 
 static enum pipe_error
diff --git a/src/gallium/drivers/svga/svga_pipe_constants.c b/src/gallium/drivers/svga/svga_pipe_constants.c
index 73a0cd6b3a8..2fa2142d07d 100644
--- a/src/gallium/drivers/svga/svga_pipe_constants.c
+++ b/src/gallium/drivers/svga/svga_pipe_constants.c
@@ -45,14 +45,14 @@ struct svga_constbuf
 
 static void svga_set_constant_buffer(struct pipe_context *pipe,
                                      uint shader, uint index,
-                                     struct pipe_buffer *buf)
+                                     struct pipe_resource *buf)
 {
    struct svga_context *svga = svga_context(pipe);
 
    assert(shader < PIPE_SHADER_TYPES);
    assert(index == 0);
 
-   pipe_buffer_reference( &svga->curr.cb[shader],
+   pipe_resource_reference( &svga->curr.cb[shader],
                           buf );
 
    if (shader == PIPE_SHADER_FRAGMENT)
diff --git a/src/gallium/drivers/svga/svga_pipe_draw.c b/src/gallium/drivers/svga/svga_pipe_draw.c
index f00cf23935e..a05272b2e40 100644
--- a/src/gallium/drivers/svga/svga_pipe_draw.c
+++ b/src/gallium/drivers/svga/svga_pipe_draw.c
@@ -42,7 +42,7 @@
 
 static enum pipe_error
 retry_draw_range_elements( struct svga_context *svga,
-                           struct pipe_buffer *index_buffer,
+                           struct pipe_resource *index_buffer,
                            unsigned index_size,
                            unsigned min_index,
                            unsigned max_index,
@@ -150,7 +150,7 @@ retry:
 
 static void
 svga_draw_range_elements( struct pipe_context *pipe,
-                          struct pipe_buffer *index_buffer,
+                          struct pipe_resource *index_buffer,
                           unsigned index_size,
                           unsigned min_index,
                           unsigned max_index,
@@ -224,7 +224,7 @@ svga_draw_range_elements( struct pipe_context *pipe,
 
 static void
 svga_draw_elements( struct pipe_context *pipe,
-                    struct pipe_buffer *index_buffer,
+                    struct pipe_resource *index_buffer,
                     unsigned index_size,
                     unsigned prim, unsigned start, unsigned count)
 {
diff --git a/src/gallium/drivers/svga/svga_pipe_flush.c b/src/gallium/drivers/svga/svga_pipe_flush.c
index 7fa2205ae5f..ab243aa6ec5 100644
--- a/src/gallium/drivers/svga/svga_pipe_flush.c
+++ b/src/gallium/drivers/svga/svga_pipe_flush.c
@@ -25,7 +25,7 @@
 
 #include "pipe/p_defines.h"
 #include "svga_screen.h"
-#include "svga_screen_texture.h"
+#include "svga_surface.h"
 #include "svga_context.h"
 #include "svga_debug.h"
 
diff --git a/src/gallium/drivers/svga/svga_pipe_misc.c b/src/gallium/drivers/svga/svga_pipe_misc.c
index 2c43f9a24f4..8c24fb302f7 100644
--- a/src/gallium/drivers/svga/svga_pipe_misc.c
+++ b/src/gallium/drivers/svga/svga_pipe_misc.c
@@ -28,7 +28,7 @@
 #include "util/u_inlines.h"
 
 #include "svga_context.h"
-#include "svga_screen_texture.h"
+#include "svga_surface.h"
 
 
 static void svga_set_scissor_state( struct pipe_context *pipe,
diff --git a/src/gallium/drivers/svga/svga_pipe_query.c b/src/gallium/drivers/svga/svga_pipe_query.c
index 08283e37317..9c6f5858ba4 100644
--- a/src/gallium/drivers/svga/svga_pipe_query.c
+++ b/src/gallium/drivers/svga/svga_pipe_query.c
@@ -30,7 +30,7 @@
 #include "svga_cmd.h"
 #include "svga_context.h"
 #include "svga_screen.h"
-#include "svga_screen_buffer.h"
+#include "svga_resource_buffer.h"
 #include "svga_winsys.h"
 #include "svga_debug.h"
 
@@ -89,7 +89,7 @@ static struct pipe_query *svga_create_query( struct pipe_context *pipe,
     
    sq->queryResult = (SVGA3dQueryResult *)sws->buffer_map(sws, 
                                                           sq->hwbuf, 
-                                                          PIPE_BUFFER_USAGE_CPU_WRITE);
+                                                          PIPE_TRANSFER_WRITE);
    if(!sq->queryResult)
       goto no_query_result;
 
diff --git a/src/gallium/drivers/svga/svga_pipe_sampler.c b/src/gallium/drivers/svga/svga_pipe_sampler.c
index 82d525ca33f..f44a0e1325a 100644
--- a/src/gallium/drivers/svga/svga_pipe_sampler.c
+++ b/src/gallium/drivers/svga/svga_pipe_sampler.c
@@ -30,7 +30,7 @@
 #include "tgsi/tgsi_parse.h"
 
 #include "svga_context.h"
-#include "svga_screen_texture.h"
+#include "svga_resource_texture.h"
 
 #include "svga_debug.h"
 
@@ -178,7 +178,7 @@ static void svga_delete_sampler_state(struct pipe_context *pipe,
 
 static struct pipe_sampler_view *
 svga_create_sampler_view(struct pipe_context *pipe,
-                         struct pipe_texture *texture,
+                         struct pipe_resource *texture,
                          const struct pipe_sampler_view *templ)
 {
    struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
@@ -187,7 +187,7 @@ svga_create_sampler_view(struct pipe_context *pipe,
       *view = *templ;
       view->reference.count = 1;
       view->texture = NULL;
-      pipe_texture_reference(&view->texture, texture);
+      pipe_resource_reference(&view->texture, texture);
       view->context = pipe;
    }
 
@@ -199,7 +199,7 @@ static void
 svga_sampler_view_destroy(struct pipe_context *pipe,
                           struct pipe_sampler_view *view)
 {
-   pipe_texture_reference(&view->texture, NULL);
+   pipe_resource_reference(&view->texture, NULL);
    FREE(view);
 }
 
diff --git a/src/gallium/drivers/svga/svga_pipe_vertex.c b/src/gallium/drivers/svga/svga_pipe_vertex.c
index 1715a47fc62..23808ad08e0 100644
--- a/src/gallium/drivers/svga/svga_pipe_vertex.c
+++ b/src/gallium/drivers/svga/svga_pipe_vertex.c
@@ -30,7 +30,7 @@
 #include "tgsi/tgsi_parse.h"
 
 #include "svga_screen.h"
-#include "svga_screen_buffer.h"
+#include "svga_resource_buffer.h"
 #include "svga_context.h"
 
 
@@ -49,13 +49,13 @@ static void svga_set_vertex_buffers(struct pipe_context *pipe,
 
    /* Adjust refcounts */
    for (i = 0; i < count; i++) {
-      pipe_buffer_reference(&svga->curr.vb[i].buffer, buffers[i].buffer);
+      pipe_resource_reference(&svga->curr.vb[i].buffer, buffers[i].buffer);
       if (svga_buffer_is_user_buffer(buffers[i].buffer))
          any_user_buffer = TRUE;
    }
 
    for ( ; i < svga->curr.num_vertex_buffers; i++)
-      pipe_buffer_reference(&svga->curr.vb[i].buffer, NULL);
+      pipe_resource_reference(&svga->curr.vb[i].buffer, NULL);
 
    /* Copy remaining data */
    memcpy(svga->curr.vb, buffers, count * sizeof buffers[0]);
@@ -102,7 +102,7 @@ void svga_cleanup_vertex_state( struct svga_context *svga )
    unsigned i;
    
    for (i = 0 ; i < svga->curr.num_vertex_buffers; i++)
-      pipe_buffer_reference(&svga->curr.vb[i].buffer, NULL);
+      pipe_resource_reference(&svga->curr.vb[i].buffer, NULL);
 }
 
 
diff --git a/src/gallium/drivers/svga/svga_resource.c b/src/gallium/drivers/svga/svga_resource.c
new file mode 100644
index 00000000000..15258c1966b
--- /dev/null
+++ b/src/gallium/drivers/svga/svga_resource.c
@@ -0,0 +1,55 @@
+#include "util/u_debug.h"
+
+#include "svga_resource.h"
+#include "svga_resource_buffer.h"
+#include "svga_resource_texture.h"
+#include "svga_context.h"
+#include "svga_screen.h"
+
+
+static struct pipe_resource *
+svga_resource_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template)
+{
+   if (template->target == PIPE_BUFFER)
+      return svga_buffer_create(screen, template);
+   else
+      return svga_resource_create(screen, template);
+
+}
+
+static struct pipe_resource *
+svga_resource_from_handle(struct pipe_screen * screen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle)
+{
+   if (template->target == PIPE_BUFFER)
+      return NULL;
+   else
+      return svga_resource_from_handle(screen, template, whandle);
+}
+
+
+void
+svga_init_resource_functions(struct svga_context *svga)
+{
+   svga->pipe.get_transfer = u_get_transfer_vtbl;
+   svga->pipe.transfer_map = u_transfer_map_vtbl;
+   svga->pipe.transfer_flush_region = u_transfer_flush_region_vtbl;
+   svga->pipe.transfer_unmap = u_transfer_unmap_vtbl;
+   svga->pipe.transfer_destroy = u_transfer_destroy_vtbl;
+   svga->pipe.transfer_inline_write = u_transfer_inline_write_vtbl;
+}
+
+void
+svga_init_screen_resource_functions(struct svga_screen *is)
+{
+   is->screen.resource_create = svga_resource_create;
+   is->screen.resource_from_handle = svga_resource_from_handle;
+   is->screen.resource_get_handle = u_resource_get_handle_vtbl;
+   is->screen.resource_destroy = u_resource_destroy_vtbl;
+   is->screen.user_buffer_create = svga_user_buffer_create;
+}
+
+
+
diff --git a/src/gallium/state_trackers/xorg/xvmc/attributes.c b/src/gallium/drivers/svga/svga_resource.h
index 79a67838e6e..851e3b50ce3 100644
--- a/src/gallium/state_trackers/xorg/xvmc/attributes.c
+++ b/src/gallium/drivers/svga/svga_resource.h
@@ -1,6 +1,6 @@
 /**************************************************************************
  * 
- * Copyright 2009 Younes Manton.
+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
  * All Rights Reserved.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -25,22 +25,19 @@
  * 
  **************************************************************************/
 
-#include <assert.h>
-#include <X11/Xlib.h>
-#include <X11/extensions/Xvlib.h>
-#include <X11/extensions/XvMClib.h>
-
-XvAttribute* XvMCQueryAttributes(Display *dpy, XvMCContext *context, int *number)
-{
-   return NULL;
-}
-
-Status XvMCSetAttribute(Display *dpy, XvMCContext *context, Atom attribute, int value)
-{
-   return BadImplementation;
-}
-
-Status XvMCGetAttribute(Display *dpy, XvMCContext *context, Atom attribute, int *value)
-{
-   return BadImplementation;
-}
+#ifndef SVGA_RESOURCE_H
+#define SVGA_RESOURCE_H
+
+struct svga_screen;
+
+#include "util/u_debug.h"
+
+struct svga_context;
+struct svga_screen;
+
+
+void svga_init_screen_resource_functions(struct svga_screen *is);
+void svga_init_resource_functions(struct svga_context *svga );
+
+
+#endif /* SVGA_RESOURCE_H */
diff --git a/src/gallium/drivers/svga/svga_resource_buffer.c b/src/gallium/drivers/svga/svga_resource_buffer.c
new file mode 100644
index 00000000000..cfa7d1015ee
--- /dev/null
+++ b/src/gallium/drivers/svga/svga_resource_buffer.c
@@ -0,0 +1,355 @@
+/**********************************************************
+ * Copyright 2008-2009 VMware, Inc.  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, sublicense, 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 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
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * 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.
+ *
+ **********************************************************/
+
+#include "svga_cmd.h"
+
+#include "pipe/p_state.h"
+#include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+#include "os/os_thread.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+
+#include "svga_context.h"
+#include "svga_screen.h"
+#include "svga_resource_buffer.h"
+#include "svga_resource_buffer_upload.h"
+#include "svga_winsys.h"
+#include "svga_debug.h"
+
+
+/**
+ * Vertex and index buffers need hardware backing.  Constant buffers
+ * do not.  No other types of buffers currently supported.
+ */
+static INLINE boolean
+svga_buffer_needs_hw_storage(unsigned usage)
+{
+   return usage & (PIPE_BIND_VERTEX_BUFFER | PIPE_BIND_INDEX_BUFFER);
+}
+
+
+static unsigned int
+svga_buffer_is_referenced( struct pipe_context *pipe,
+			     struct pipe_resource *buf,
+			     unsigned face, unsigned level)
+{
+   struct svga_screen *ss = svga_screen(pipe->screen);
+   struct svga_buffer *sbuf = svga_buffer(buf);
+
+   /**
+    * XXX: Check this.
+    * The screen may cache buffer writes, but when we map, we map out
+    * of those cached writes, so we don't need to set a
+    * PIPE_REFERENCED_FOR_WRITE flag for cached buffers.
+    */
+
+   if (!sbuf->handle || ss->sws->surface_is_flushed(ss->sws, sbuf->handle))
+     return PIPE_UNREFERENCED;
+
+   /**
+    * sws->surface_is_flushed() does not distinguish between read references
+    * and write references. So assume a reference is both,
+    * however, we make an exception for index- and vertex buffers, to avoid
+    * a flush in st_bufferobj_get_subdata, during display list replay.
+    */
+
+   if (sbuf->b.b.bind & (PIPE_BIND_VERTEX_BUFFER | PIPE_BIND_INDEX_BUFFER))
+      return PIPE_REFERENCED_FOR_READ;
+
+   return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+}
+
+
+
+
+
+
+static void *
+svga_buffer_map_range( struct pipe_screen *screen,
+                       struct pipe_resource *buf,
+                       unsigned offset,
+		       unsigned length,
+                       unsigned usage )
+{
+   struct svga_screen *ss = svga_screen(screen); 
+   struct svga_winsys_screen *sws = ss->sws;
+   struct svga_buffer *sbuf = svga_buffer( buf );
+   void *map;
+
+   if (!sbuf->swbuf && !sbuf->hwbuf) {
+      if (svga_buffer_create_hw_storage(ss, sbuf) != PIPE_OK) {
+         /*
+          * We can't create a hardware buffer big enough, so create a malloc
+          * buffer instead.
+          */
+         debug_printf("%s: failed to allocate %u KB of DMA, splitting DMA transfers\n",
+                      __FUNCTION__,
+                      (sbuf->b.b.width0 + 1023)/1024);
+
+         sbuf->swbuf = align_malloc(sbuf->b.b.width0, 16);
+      }
+   }
+
+   if (sbuf->swbuf) {
+      /* User/malloc buffer */
+      map = sbuf->swbuf;
+   }
+   else if (sbuf->hwbuf) {
+      map = sws->buffer_map(sws, sbuf->hwbuf, usage);
+   }
+   else {
+      map = NULL;
+   }
+
+   if(map) {
+      pipe_mutex_lock(ss->swc_mutex);
+
+      ++sbuf->map.count;
+
+      if (usage & PIPE_TRANSFER_WRITE) {
+         assert(sbuf->map.count <= 1);
+         sbuf->map.writing = TRUE;
+         if (usage & PIPE_TRANSFER_FLUSH_EXPLICIT)
+            sbuf->map.flush_explicit = TRUE;
+      }
+      
+      pipe_mutex_unlock(ss->swc_mutex);
+   }
+   
+   return map;
+}
+
+
+
+static void 
+svga_buffer_flush_mapped_range( struct pipe_screen *screen,
+                                struct pipe_resource *buf,
+                                unsigned offset, unsigned length)
+{
+   struct svga_buffer *sbuf = svga_buffer( buf );
+   struct svga_screen *ss = svga_screen(screen);
+   
+   pipe_mutex_lock(ss->swc_mutex);
+   assert(sbuf->map.writing);
+   if(sbuf->map.writing) {
+      assert(sbuf->map.flush_explicit);
+      svga_buffer_add_range(sbuf, offset, offset + length);
+   }
+   pipe_mutex_unlock(ss->swc_mutex);
+}
+
+static void 
+svga_buffer_unmap( struct pipe_screen *screen,
+                   struct pipe_resource *buf)
+{
+   struct svga_screen *ss = svga_screen(screen); 
+   struct svga_winsys_screen *sws = ss->sws;
+   struct svga_buffer *sbuf = svga_buffer( buf );
+   
+   pipe_mutex_lock(ss->swc_mutex);
+   
+   assert(sbuf->map.count);
+   if(sbuf->map.count)
+      --sbuf->map.count;
+
+   if(sbuf->hwbuf)
+      sws->buffer_unmap(sws, sbuf->hwbuf);
+
+   if(sbuf->map.writing) {
+      if(!sbuf->map.flush_explicit) {
+         /* No mapped range was flushed -- flush the whole buffer */
+         SVGA_DBG(DEBUG_DMA, "flushing the whole buffer\n");
+   
+         svga_buffer_add_range(sbuf, 0, sbuf->b.b.width0);
+      }
+      
+      sbuf->map.writing = FALSE;
+      sbuf->map.flush_explicit = FALSE;
+   }
+
+   pipe_mutex_unlock(ss->swc_mutex);
+}
+
+
+
+static void
+svga_buffer_destroy( struct pipe_screen *screen,
+		     struct pipe_resource *buf )
+{
+   struct svga_screen *ss = svga_screen(screen); 
+   struct svga_buffer *sbuf = svga_buffer( buf );
+
+   assert(!p_atomic_read(&buf->reference.count));
+   
+   assert(!sbuf->dma.pending);
+
+   if(sbuf->handle)
+      svga_buffer_destroy_host_surface(ss, sbuf);
+   
+   if(sbuf->uploaded.buffer)
+      pipe_resource_reference(&sbuf->uploaded.buffer, NULL);
+
+   if(sbuf->hwbuf)
+      svga_buffer_destroy_hw_storage(ss, sbuf);
+   
+   if(sbuf->swbuf && !sbuf->user)
+      align_free(sbuf->swbuf);
+   
+   FREE(sbuf);
+}
+
+
+/* Keep the original code more or less intact, implement transfers in
+ * terms of the old functions.
+ */
+static void *
+svga_buffer_transfer_map( struct pipe_context *pipe,
+			  struct pipe_transfer *transfer )
+{
+   uint8_t *map = svga_buffer_map_range( pipe->screen,
+					 transfer->resource,
+					 transfer->box.x,
+					 transfer->box.width,
+					 transfer->usage );
+   if (map == NULL)
+      return NULL;
+
+   /* map_buffer() returned a pointer to the beginning of the buffer,
+    * but transfers are expected to return a pointer to just the
+    * region specified in the box.
+    */
+   return map + transfer->box.x;
+}
+
+
+
+static void svga_buffer_transfer_flush_region( struct pipe_context *pipe,
+					       struct pipe_transfer *transfer,
+					       const struct pipe_box *box)
+{
+   assert(box->x + box->width <= transfer->box.width);
+
+   svga_buffer_flush_mapped_range(pipe->screen,
+				  transfer->resource,
+				  transfer->box.x + box->x,
+				  box->width);
+}
+
+static void svga_buffer_transfer_unmap( struct pipe_context *pipe,
+			    struct pipe_transfer *transfer )
+{
+   svga_buffer_unmap(pipe->screen,
+		     transfer->resource);
+}
+
+
+
+
+
+
+
+struct u_resource_vtbl svga_buffer_vtbl = 
+{
+   u_default_resource_get_handle,      /* get_handle */
+   svga_buffer_destroy,		     /* resource_destroy */
+   svga_buffer_is_referenced,	     /* is_resource_referenced */
+   u_default_get_transfer,	     /* get_transfer */
+   u_default_transfer_destroy,	     /* transfer_destroy */
+   svga_buffer_transfer_map,	     /* transfer_map */
+   svga_buffer_transfer_flush_region,  /* transfer_flush_region */
+   svga_buffer_transfer_unmap,	     /* transfer_unmap */
+   u_default_transfer_inline_write   /* transfer_inline_write */
+};
+
+
+
+struct pipe_resource *
+svga_buffer_create(struct pipe_screen *screen,
+		   const struct pipe_resource *template)
+{
+   struct svga_screen *ss = svga_screen(screen);
+   struct svga_buffer *sbuf;
+   
+   sbuf = CALLOC_STRUCT(svga_buffer);
+   if(!sbuf)
+      goto error1;
+   
+   sbuf->b.b = *template;
+   sbuf->b.vtbl = &svga_buffer_vtbl;
+   pipe_reference_init(&sbuf->b.b.reference, 1);
+   sbuf->b.b.screen = screen;
+
+   if(svga_buffer_needs_hw_storage(template->bind)) {
+      if(svga_buffer_create_host_surface(ss, sbuf) != PIPE_OK)
+         goto error2;
+   }
+   else {
+      sbuf->swbuf = align_malloc(template->width0, 64);
+      if(!sbuf->swbuf)
+         goto error2;
+   }
+      
+   return &sbuf->b.b; 
+
+error2:
+   FREE(sbuf);
+error1:
+   return NULL;
+}
+
+struct pipe_resource *
+svga_user_buffer_create(struct pipe_screen *screen,
+                        void *ptr,
+                        unsigned bytes,
+			unsigned bind)
+{
+   struct svga_buffer *sbuf;
+   
+   sbuf = CALLOC_STRUCT(svga_buffer);
+   if(!sbuf)
+      goto no_sbuf;
+      
+   pipe_reference_init(&sbuf->b.b.reference, 1);
+   sbuf->b.vtbl = &svga_buffer_vtbl;
+   sbuf->b.b.screen = screen;
+   sbuf->b.b.format = PIPE_FORMAT_R8_UNORM; /* ?? */
+   sbuf->b.b._usage = PIPE_USAGE_IMMUTABLE;
+   sbuf->b.b.bind = bind;
+   sbuf->b.b.width0 = bytes;
+   sbuf->b.b.height0 = 1;
+   sbuf->b.b.depth0 = 1;
+
+   sbuf->swbuf = ptr;
+   sbuf->user = TRUE;
+   
+   return &sbuf->b.b; 
+
+no_sbuf:
+   return NULL;
+}
+
+
+
diff --git a/src/gallium/drivers/svga/svga_screen_buffer.h b/src/gallium/drivers/svga/svga_resource_buffer.h
index 8c862fa62d6..55e7321184f 100644
--- a/src/gallium/drivers/svga/svga_screen_buffer.h
+++ b/src/gallium/drivers/svga/svga_resource_buffer.h
@@ -29,14 +29,13 @@
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_state.h"
+#include "util/u_transfer.h"
 
 #include "util/u_double_list.h"
 
 #include "svga_screen_cache.h"
 
 
-#define SVGA_BUFFER_MAGIC 0x344f9005
-
 /**
  * Maximum number of discontiguous ranges
  */
@@ -49,6 +48,8 @@ struct svga_winsys_buffer;
 struct svga_winsys_surface;
 
 
+extern struct u_resource_vtbl svga_buffer_vtbl;
+
 struct svga_buffer_range
 {
    unsigned start;
@@ -61,12 +62,7 @@ struct svga_buffer_range
  */
 struct svga_buffer 
 {
-   struct pipe_buffer base;
-
-   /** 
-    * Marker to detect bad casts in runtime.
-    */ 
-   uint32_t magic;
+   struct u_resource b;
 
    /**
     * Regular (non DMA'able) memory.
@@ -138,7 +134,7 @@ struct svga_buffer
     * Information about uploaded version of user buffers.
     */
    struct {
-      struct pipe_buffer *buffer;
+      struct pipe_resource *buffer;
 
       /**
        * We combine multiple user buffers into the same hardware buffer. This
@@ -190,10 +186,10 @@ struct svga_buffer
 
 
 static INLINE struct svga_buffer *
-svga_buffer(struct pipe_buffer *buffer)
+svga_buffer(struct pipe_resource *buffer)
 {
    if (buffer) {
-      assert(((struct svga_buffer *)buffer)->magic == SVGA_BUFFER_MAGIC);
+      assert(((struct svga_buffer *)buffer)->b.vtbl == &svga_buffer_vtbl);
       return (struct svga_buffer *)buffer;
    }
    return NULL;
@@ -205,14 +201,24 @@ svga_buffer(struct pipe_buffer *buffer)
  * decide to use an alternate upload path for these buffers.
  */
 static INLINE boolean 
-svga_buffer_is_user_buffer( struct pipe_buffer *buffer )
+svga_buffer_is_user_buffer( struct pipe_resource *buffer )
 {
    return svga_buffer(buffer)->user;
 }
 
 
-void
-svga_screen_init_buffer_functions(struct pipe_screen *screen);
+
+
+struct pipe_resource *
+svga_user_buffer_create(struct pipe_screen *screen,
+                        void *ptr,
+                        unsigned bytes,
+			unsigned usage);
+
+struct pipe_resource *
+svga_buffer_create(struct pipe_screen *screen,
+		   const struct pipe_resource *template);
+
 
 
 /**
@@ -226,7 +232,7 @@ svga_screen_init_buffer_functions(struct pipe_screen *screen);
  */
 struct svga_winsys_surface *
 svga_buffer_handle(struct svga_context *svga,
-                   struct pipe_buffer *buf);
+                   struct pipe_resource *buf);
 
 void
 svga_context_flush_buffers(struct svga_context *svga);
diff --git a/src/gallium/drivers/svga/svga_resource_buffer_host.c b/src/gallium/drivers/svga/svga_resource_buffer_host.c
new file mode 100644
index 00000000000..139597f9cb0
--- /dev/null
+++ b/src/gallium/drivers/svga/svga_resource_buffer_host.c
@@ -0,0 +1,2 @@
+
+
diff --git a/src/gallium/drivers/svga/svga_screen_buffer.c b/src/gallium/drivers/svga/svga_resource_buffer_upload.c
index 1ff6a3a5b31..acef60f4647 100644
--- a/src/gallium/drivers/svga/svga_screen_buffer.c
+++ b/src/gallium/drivers/svga/svga_resource_buffer_upload.c
@@ -34,88 +34,14 @@
 
 #include "svga_context.h"
 #include "svga_screen.h"
-#include "svga_screen_buffer.h"
+#include "svga_resource_buffer.h"
+#include "svga_resource_buffer_upload.h"
 #include "svga_winsys.h"
 #include "svga_debug.h"
 
 
-/**
- * Vertex and index buffers have to be treated slightly differently from 
- * regular guest memory regions because the SVGA device sees them as 
- * surfaces, and the state tracker can create/destroy without the pipe 
- * driver, therefore we must do the uploads from the vws.
+/* Allocate a winsys_buffer (ie. DMA, aka GMR memory).
  */
-static INLINE boolean
-svga_buffer_needs_hw_storage(unsigned usage)
-{
-   return usage & (PIPE_BUFFER_USAGE_VERTEX | PIPE_BUFFER_USAGE_INDEX);
-}
-
-
-static INLINE enum pipe_error
-svga_buffer_create_host_surface(struct svga_screen *ss,
-                                struct svga_buffer *sbuf)
-{
-   if(!sbuf->handle) {
-      sbuf->key.flags = 0;
-      
-      sbuf->key.format = SVGA3D_BUFFER;
-      if(sbuf->base.usage & PIPE_BUFFER_USAGE_VERTEX)
-         sbuf->key.flags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
-      if(sbuf->base.usage & PIPE_BUFFER_USAGE_INDEX)
-         sbuf->key.flags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
-      
-      sbuf->key.size.width = sbuf->base.size;
-      sbuf->key.size.height = 1;
-      sbuf->key.size.depth = 1;
-      
-      sbuf->key.numFaces = 1;
-      sbuf->key.numMipLevels = 1;
-      sbuf->key.cachable = 1;
-      
-      SVGA_DBG(DEBUG_DMA, "surface_create for buffer sz %d\n", sbuf->base.size);
-
-      sbuf->handle = svga_screen_surface_create(ss, &sbuf->key);
-      if(!sbuf->handle)
-         return PIPE_ERROR_OUT_OF_MEMORY;
-   
-      /* Always set the discard flag on the first time the buffer is written
-       * as svga_screen_surface_create might have passed a recycled host
-       * buffer.
-       */
-      sbuf->dma.flags.discard = TRUE;
-
-      SVGA_DBG(DEBUG_DMA, "   --> got sid %p sz %d (buffer)\n", sbuf->handle, sbuf->base.size);
-   }
-   
-   return PIPE_OK;
-}   
-
-
-static INLINE void
-svga_buffer_destroy_host_surface(struct svga_screen *ss,
-                                 struct svga_buffer *sbuf)
-{
-   if(sbuf->handle) {
-      SVGA_DBG(DEBUG_DMA, " ungrab sid %p sz %d\n", sbuf->handle, sbuf->base.size);
-      svga_screen_surface_destroy(ss, &sbuf->key, &sbuf->handle);
-   }
-}   
-
-
-static INLINE void
-svga_buffer_destroy_hw_storage(struct svga_screen *ss, struct svga_buffer *sbuf)
-{
-   struct svga_winsys_screen *sws = ss->sws;
-
-   assert(!sbuf->map.count);
-   assert(sbuf->hwbuf);
-   if(sbuf->hwbuf) {
-      sws->buffer_destroy(sws, sbuf->hwbuf);
-      sbuf->hwbuf = NULL;
-   }
-}
-
 struct svga_winsys_buffer *
 svga_winsys_buffer_create( struct svga_screen *ss,
                            unsigned alignment, 
@@ -142,21 +68,36 @@ svga_winsys_buffer_create( struct svga_screen *ss,
 }
 
 
+void
+svga_buffer_destroy_hw_storage(struct svga_screen *ss, struct svga_buffer *sbuf)
+{
+   struct svga_winsys_screen *sws = ss->sws;
+
+   assert(!sbuf->map.count);
+   assert(sbuf->hwbuf);
+   if(sbuf->hwbuf) {
+      sws->buffer_destroy(sws, sbuf->hwbuf);
+      sbuf->hwbuf = NULL;
+   }
+}
+
+
+
 /**
  * Allocate DMA'ble storage for the buffer. 
  * 
  * Called before mapping a buffer.
  */
-static INLINE enum pipe_error
+enum pipe_error
 svga_buffer_create_hw_storage(struct svga_screen *ss,
                               struct svga_buffer *sbuf)
 {
    assert(!sbuf->user);
 
    if(!sbuf->hwbuf) {
-      unsigned alignment = sbuf->base.alignment;
+      unsigned alignment = 16;
       unsigned usage = 0;
-      unsigned size = sbuf->base.size;
+      unsigned size = sbuf->b.b.width0;
       
       sbuf->hwbuf = svga_winsys_buffer_create(ss, alignment, usage, size);
       if(!sbuf->hwbuf)
@@ -169,6 +110,58 @@ svga_buffer_create_hw_storage(struct svga_screen *ss,
 }
 
 
+
+enum pipe_error
+svga_buffer_create_host_surface(struct svga_screen *ss,
+                                struct svga_buffer *sbuf)
+{
+   if(!sbuf->handle) {
+      sbuf->key.flags = 0;
+      
+      sbuf->key.format = SVGA3D_BUFFER;
+      if(sbuf->b.b.bind & PIPE_BIND_VERTEX_BUFFER)
+         sbuf->key.flags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
+      if(sbuf->b.b.bind & PIPE_BIND_INDEX_BUFFER)
+         sbuf->key.flags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
+      
+      sbuf->key.size.width = sbuf->b.b.width0;
+      sbuf->key.size.height = 1;
+      sbuf->key.size.depth = 1;
+      
+      sbuf->key.numFaces = 1;
+      sbuf->key.numMipLevels = 1;
+      sbuf->key.cachable = 1;
+      
+      SVGA_DBG(DEBUG_DMA, "surface_create for buffer sz %d\n", sbuf->b.b.width0);
+
+      sbuf->handle = svga_screen_surface_create(ss, &sbuf->key);
+      if(!sbuf->handle)
+         return PIPE_ERROR_OUT_OF_MEMORY;
+   
+      /* Always set the discard flag on the first time the buffer is written
+       * as svga_screen_surface_create might have passed a recycled host
+       * buffer.
+       */
+      sbuf->dma.flags.discard = TRUE;
+
+      SVGA_DBG(DEBUG_DMA, "   --> got sid %p sz %d (buffer)\n", sbuf->handle, sbuf->b.b.width0);
+   }
+   
+   return PIPE_OK;
+}   
+
+
+void
+svga_buffer_destroy_host_surface(struct svga_screen *ss,
+                                 struct svga_buffer *sbuf)
+{
+   if(sbuf->handle) {
+      SVGA_DBG(DEBUG_DMA, " ungrab sid %p sz %d\n", sbuf->handle, sbuf->b.b.width0);
+      svga_screen_surface_destroy(ss, &sbuf->key, &sbuf->handle);
+   }
+}   
+
+
 /**
  * Variant of SVGA3D_BufferDMA which leaves the copy box temporarily in blank.
  */
@@ -186,15 +179,15 @@ svga_buffer_upload_command(struct svga_context *svga,
    SVGA3dCmdSurfaceDMASuffix *pSuffix;
    unsigned region_flags;
    unsigned surface_flags;
-   struct pipe_buffer *dummy;
+   struct pipe_resource *dummy;
 
    if(transfer == SVGA3D_WRITE_HOST_VRAM) {
-      region_flags = PIPE_BUFFER_USAGE_GPU_READ;
-      surface_flags = PIPE_BUFFER_USAGE_GPU_WRITE;
+      region_flags = SVGA_RELOC_READ;
+      surface_flags = SVGA_RELOC_WRITE;
    }
    else if(transfer == SVGA3D_READ_HOST_VRAM) {
-      region_flags = PIPE_BUFFER_USAGE_GPU_WRITE;
-      surface_flags = PIPE_BUFFER_USAGE_GPU_READ;
+      region_flags = SVGA_RELOC_WRITE;
+      surface_flags = SVGA_RELOC_READ;
    }
    else {
       assert(0);
@@ -224,11 +217,11 @@ svga_buffer_upload_command(struct svga_context *svga,
 
    /* Increment reference count */
    dummy = NULL;
-   pipe_buffer_reference(&dummy, &sbuf->base);
+   pipe_resource_reference(&dummy, &sbuf->b.b);
 
    pSuffix = (SVGA3dCmdSurfaceDMASuffix *)((uint8_t*)cmd + sizeof *cmd + numBoxes * sizeof *boxes);
    pSuffix->suffixSize = sizeof *pSuffix;
-   pSuffix->maximumOffset = sbuf->base.size;
+   pSuffix->maximumOffset = sbuf->b.b.width0;
    pSuffix->flags = sbuf->dma.flags;
 
    SVGA_FIFOCommitAll(swc);
@@ -291,11 +284,12 @@ svga_buffer_upload_flush(struct svga_context *svga,
    sbuf->dma.boxes = NULL;
 
    /* Decrement reference count */
-   pipe_reference(&(sbuf->base.reference), NULL);
+   pipe_reference(&(sbuf->b.b.reference), NULL);
    sbuf = NULL;
 }
 
 
+
 /**
  * Note a dirty range.
  *
@@ -305,7 +299,7 @@ svga_buffer_upload_flush(struct svga_context *svga,
  * 
  * We try to lump as many contiguous DMA transfers together as possible.
  */
-static void
+void
 svga_buffer_add_range(struct svga_buffer *sbuf,
                       unsigned start,
                       unsigned end)
@@ -330,7 +324,7 @@ svga_buffer_add_range(struct svga_buffer *sbuf,
     * Note that it is not this function task to care about overlapping ranges,
     * as the GMR was already given so it is too late to do anything. Situations
     * where overlapping ranges may pose a problem should be detected via
-    * pipe_context::is_buffer_referenced and the context that refers to the
+    * pipe_context::is_resource_referenced and the context that refers to the
     * buffer should be flushed.
     */
 
@@ -400,222 +394,6 @@ svga_buffer_add_range(struct svga_buffer *sbuf,
 }
 
 
-static void *
-svga_buffer_map_range( struct pipe_screen *screen,
-                       struct pipe_buffer *buf,
-                       unsigned offset, unsigned length,
-                       unsigned usage )
-{
-   struct svga_screen *ss = svga_screen(screen); 
-   struct svga_winsys_screen *sws = ss->sws;
-   struct svga_buffer *sbuf = svga_buffer( buf );
-   void *map;
-
-   if (!sbuf->swbuf && !sbuf->hwbuf) {
-      if (svga_buffer_create_hw_storage(ss, sbuf) != PIPE_OK) {
-         /*
-          * We can't create a hardware buffer big enough, so create a malloc
-          * buffer instead.
-          */
-
-         debug_printf("%s: failed to allocate %u KB of DMA, splitting DMA transfers\n",
-                      __FUNCTION__,
-                      (sbuf->base.size + 1023)/1024);
-
-         sbuf->swbuf = align_malloc(sbuf->base.size, sbuf->base.alignment);
-      }
-   }
-
-   if (sbuf->swbuf) {
-      /* User/malloc buffer */
-      map = sbuf->swbuf;
-   }
-   else if (sbuf->hwbuf) {
-      map = sws->buffer_map(sws, sbuf->hwbuf, usage);
-   }
-   else {
-      map = NULL;
-   }
-
-   if(map) {
-      pipe_mutex_lock(ss->swc_mutex);
-
-      ++sbuf->map.count;
-
-      if (usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
-         assert(sbuf->map.count <= 1);
-         sbuf->map.writing = TRUE;
-         if (usage & PIPE_BUFFER_USAGE_FLUSH_EXPLICIT)
-            sbuf->map.flush_explicit = TRUE;
-      }
-      
-      pipe_mutex_unlock(ss->swc_mutex);
-   }
-   
-   return map;
-}
-
-static void 
-svga_buffer_flush_mapped_range( struct pipe_screen *screen,
-                                struct pipe_buffer *buf,
-                                unsigned offset, unsigned length)
-{
-   struct svga_buffer *sbuf = svga_buffer( buf );
-   struct svga_screen *ss = svga_screen(screen);
-   
-   pipe_mutex_lock(ss->swc_mutex);
-   assert(sbuf->map.writing);
-   if(sbuf->map.writing) {
-      assert(sbuf->map.flush_explicit);
-      svga_buffer_add_range(sbuf, offset, offset + length);
-   }
-   pipe_mutex_unlock(ss->swc_mutex);
-}
-
-static void 
-svga_buffer_unmap( struct pipe_screen *screen,
-                   struct pipe_buffer *buf)
-{
-   struct svga_screen *ss = svga_screen(screen); 
-   struct svga_winsys_screen *sws = ss->sws;
-   struct svga_buffer *sbuf = svga_buffer( buf );
-   
-   pipe_mutex_lock(ss->swc_mutex);
-   
-   assert(sbuf->map.count);
-   if(sbuf->map.count)
-      --sbuf->map.count;
-
-   if(sbuf->hwbuf)
-      sws->buffer_unmap(sws, sbuf->hwbuf);
-
-   if(sbuf->map.writing) {
-      if(!sbuf->map.flush_explicit) {
-         /* No mapped range was flushed -- flush the whole buffer */
-         SVGA_DBG(DEBUG_DMA, "flushing the whole buffer\n");
-   
-         svga_buffer_add_range(sbuf, 0, sbuf->base.size);
-      }
-      
-      sbuf->map.writing = FALSE;
-      sbuf->map.flush_explicit = FALSE;
-   }
-
-   pipe_mutex_unlock(ss->swc_mutex);
-}
-
-static void
-svga_buffer_destroy( struct pipe_buffer *buf )
-{
-   struct svga_screen *ss = svga_screen(buf->screen); 
-   struct svga_buffer *sbuf = svga_buffer( buf );
-
-   assert(!p_atomic_read(&buf->reference.count));
-   
-   assert(!sbuf->dma.pending);
-
-   if(sbuf->handle)
-      svga_buffer_destroy_host_surface(ss, sbuf);
-   
-   if(sbuf->uploaded.buffer)
-      pipe_buffer_reference(&sbuf->uploaded.buffer, NULL);
-
-   if(sbuf->hwbuf)
-      svga_buffer_destroy_hw_storage(ss, sbuf);
-   
-   if(sbuf->swbuf && !sbuf->user)
-      align_free(sbuf->swbuf);
-   
-   FREE(sbuf);
-}
-
-static struct pipe_buffer *
-svga_buffer_create(struct pipe_screen *screen,
-                   unsigned alignment,
-                   unsigned usage,
-                   unsigned size)
-{
-   struct svga_screen *ss = svga_screen(screen);
-   struct svga_buffer *sbuf;
-   
-   assert(size);
-   assert(alignment);
-
-   sbuf = CALLOC_STRUCT(svga_buffer);
-   if(!sbuf)
-      goto error1;
-      
-   sbuf->magic = SVGA_BUFFER_MAGIC;
-   
-   pipe_reference_init(&sbuf->base.reference, 1);
-   sbuf->base.screen = screen;
-   sbuf->base.alignment = alignment;
-   sbuf->base.usage = usage;
-   sbuf->base.size = size;
-
-   if(svga_buffer_needs_hw_storage(usage)) {
-      if(svga_buffer_create_host_surface(ss, sbuf) != PIPE_OK)
-         goto error2;
-   }
-   else {
-      if(alignment < sizeof(void*))
-         alignment = sizeof(void*);
-
-      usage |= PIPE_BUFFER_USAGE_CPU_READ_WRITE;
-      
-      sbuf->swbuf = align_malloc(size, alignment);
-      if(!sbuf->swbuf)
-         goto error2;
-   }
-      
-   return &sbuf->base; 
-
-error2:
-   FREE(sbuf);
-error1:
-   return NULL;
-}
-
-static struct pipe_buffer *
-svga_user_buffer_create(struct pipe_screen *screen,
-                        void *ptr,
-                        unsigned bytes)
-{
-   struct svga_buffer *sbuf;
-   
-   sbuf = CALLOC_STRUCT(svga_buffer);
-   if(!sbuf)
-      goto no_sbuf;
-      
-   sbuf->magic = SVGA_BUFFER_MAGIC;
-   
-   sbuf->swbuf = ptr;
-   sbuf->user = TRUE;
-   
-   pipe_reference_init(&sbuf->base.reference, 1);
-   sbuf->base.screen = screen;
-   sbuf->base.alignment = 1;
-   sbuf->base.usage = 0;
-   sbuf->base.size = bytes;
-   
-   return &sbuf->base; 
-
-no_sbuf:
-   return NULL;
-}
-
-   
-void
-svga_screen_init_buffer_functions(struct pipe_screen *screen)
-{
-   screen->buffer_create = svga_buffer_create;
-   screen->user_buffer_create = svga_user_buffer_create;
-   screen->buffer_map_range = svga_buffer_map_range;
-   screen->buffer_flush_mapped_range = svga_buffer_flush_mapped_range;
-   screen->buffer_unmap = svga_buffer_unmap;
-   screen->buffer_destroy = svga_buffer_destroy;
-}
-
 
 /**
  * Copy the contents of the malloc buffer to a hardware buffer.
@@ -637,7 +415,7 @@ svga_buffer_update_hw(struct svga_screen *ss, struct svga_buffer *sbuf)
          return ret;
 
       pipe_mutex_lock(ss->swc_mutex);
-      map = ss->sws->buffer_map(ss->sws, sbuf->hwbuf, PIPE_BUFFER_USAGE_CPU_WRITE);
+      map = ss->sws->buffer_map(ss->sws, sbuf->hwbuf, PIPE_TRANSFER_WRITE);
       assert(map);
       if(!map) {
 	 pipe_mutex_unlock(ss->swc_mutex);
@@ -645,7 +423,7 @@ svga_buffer_update_hw(struct svga_screen *ss, struct svga_buffer *sbuf)
          return PIPE_ERROR;
       }
 
-      memcpy(map, sbuf->swbuf, sbuf->base.size);
+      memcpy(map, sbuf->swbuf, sbuf->b.b.width0);
       ss->sws->buffer_unmap(ss->sws, sbuf->hwbuf);
 
       /* This user/malloc buffer is now indistinguishable from a gpu buffer */
@@ -710,8 +488,8 @@ svga_buffer_upload_piecewise(struct svga_screen *ss,
                   offset, offset + size);
 
          map = sws->buffer_map(sws, hwbuf,
-                               PIPE_BUFFER_USAGE_CPU_WRITE |
-                               PIPE_BUFFER_USAGE_DISCARD);
+                               PIPE_TRANSFER_WRITE |
+                               PIPE_TRANSFER_DISCARD);
          assert(map);
          if (map) {
             memcpy(map, sbuf->swbuf, size);
@@ -745,9 +523,14 @@ svga_buffer_upload_piecewise(struct svga_screen *ss,
 }
 
 
+
+
+/* Get (or create/upload) the winsys surface handle so that we can
+ * refer to this buffer in fifo commands.
+ */
 struct svga_winsys_surface *
 svga_buffer_handle(struct svga_context *svga,
-                   struct pipe_buffer *buf)
+                   struct pipe_resource *buf)
 {
    struct pipe_screen *screen = svga->pipe.screen;
    struct svga_screen *ss = svga_screen(screen);
@@ -828,45 +611,6 @@ svga_buffer_handle(struct svga_context *svga,
 }
 
 
-struct pipe_buffer *
-svga_screen_buffer_wrap_surface(struct pipe_screen *screen,
-				enum SVGA3dSurfaceFormat format,
-				struct svga_winsys_surface *srf)
-{
-   struct pipe_buffer *buf;
-   struct svga_buffer *sbuf;
-   struct svga_winsys_screen *sws = svga_winsys_screen(screen);
-
-   buf = svga_buffer_create(screen, 0, SVGA_BUFFER_USAGE_WRAPPED, 0);
-   if (!buf)
-      return NULL;
-
-   sbuf = svga_buffer(buf);
-
-   /*
-    * We are not the creator of this surface and therefore we must not
-    * cache it for reuse. Set the cacheable flag to zero in the key to
-    * prevent this.
-    */
-   sbuf->key.format = format;
-   sbuf->key.cachable = 0;
-   sws->surface_reference(sws, &sbuf->handle, srf);
-
-   return buf;
-}
-
-
-struct svga_winsys_surface *
-svga_screen_buffer_get_winsys_surface(struct pipe_buffer *buffer)
-{
-   struct svga_winsys_screen *sws = svga_winsys_screen(buffer->screen);
-   struct svga_winsys_surface *vsurf = NULL;
-
-   assert(svga_buffer(buffer)->key.cachable == 0);
-   svga_buffer(buffer)->key.cachable = 0;
-   sws->surface_reference(sws, &vsurf, svga_buffer(buffer)->handle);
-   return vsurf;
-}
 
 void
 svga_context_flush_buffers(struct svga_context *svga)
@@ -879,7 +623,7 @@ svga_context_flush_buffers(struct svga_context *svga)
    while(curr != &svga->dirty_buffers) {
       sbuf = LIST_ENTRY(struct svga_buffer, curr, head);
 
-      assert(p_atomic_read(&sbuf->base.reference.count) != 0);
+      assert(p_atomic_read(&sbuf->b.b.reference.count) != 0);
       assert(sbuf->dma.pending);
       
       svga_buffer_upload_flush(svga, sbuf);
diff --git a/src/gallium/drivers/svga/svga_resource_buffer_upload.h b/src/gallium/drivers/svga/svga_resource_buffer_upload.h
new file mode 100644
index 00000000000..11df3065263
--- /dev/null
+++ b/src/gallium/drivers/svga/svga_resource_buffer_upload.h
@@ -0,0 +1,54 @@
+/**********************************************************
+ * Copyright 2008-2009 VMware, Inc.  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, sublicense, 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 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
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * 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 SVGA_BUFFER_UPLOAD_H
+#define SVGA_BUFFER_UPLOAD_H
+
+
+void
+svga_buffer_add_range(struct svga_buffer *sbuf,
+                      unsigned start,
+                      unsigned end);
+
+enum pipe_error
+svga_buffer_create_hw_storage(struct svga_screen *ss,
+                              struct svga_buffer *sbuf);
+
+void
+svga_buffer_destroy_hw_storage(struct svga_screen *ss,
+			       struct svga_buffer *sbuf);
+
+enum pipe_error
+svga_buffer_create_host_surface(struct svga_screen *ss,
+                                struct svga_buffer *sbuf);
+
+void
+svga_buffer_destroy_host_surface(struct svga_screen *ss,
+                                 struct svga_buffer *sbuf);
+
+
+
+
+#endif /* SVGA_BUFFER_H */
diff --git a/src/gallium/drivers/svga/svga_resource_texture.c b/src/gallium/drivers/svga/svga_resource_texture.c
new file mode 100644
index 00000000000..f06b0323d8c
--- /dev/null
+++ b/src/gallium/drivers/svga/svga_resource_texture.c
@@ -0,0 +1,633 @@
+/**********************************************************
+ * Copyright 2008-2009 VMware, Inc.  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, sublicense, 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 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
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * 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.
+ *
+ **********************************************************/
+
+#include "svga_cmd.h"
+
+#include "pipe/p_state.h"
+#include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+#include "os/os_thread.h"
+#include "util/u_format.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+
+#include "svga_screen.h"
+#include "svga_context.h"
+#include "svga_resource_texture.h"
+#include "svga_resource_buffer.h"
+#include "svga_sampler_view.h"
+#include "svga_winsys.h"
+#include "svga_debug.h"
+
+
+/* XXX: This isn't a real hardware flag, but just a hack for kernel to
+ * know about primary surfaces. Find a better way to accomplish this.
+ */
+#define SVGA3D_SURFACE_HINT_SCANOUT (1 << 9)
+
+
+static unsigned int
+svga_texture_is_referenced( struct pipe_context *pipe,
+			    struct pipe_resource *texture,
+			    unsigned face, unsigned level)
+{
+   struct svga_texture *tex = svga_texture(texture);
+   struct svga_screen *ss = svga_screen(pipe->screen);
+
+   /**
+    * The screen does not cache texture writes.
+    */
+
+   if (!tex->handle || ss->sws->surface_is_flushed(ss->sws, tex->handle))
+      return PIPE_UNREFERENCED;
+
+   /**
+    * sws->surface_is_flushed() does not distinguish between read references
+    * and write references. So assume a reference is both.
+    */
+
+   return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+}
+
+
+
+/*
+ * Helper function and arrays
+ */
+
+SVGA3dSurfaceFormat
+svga_translate_format(enum pipe_format format)
+{
+   switch(format) {
+   
+   case PIPE_FORMAT_B8G8R8A8_UNORM:
+      return SVGA3D_A8R8G8B8;
+   case PIPE_FORMAT_B8G8R8X8_UNORM:
+      return SVGA3D_X8R8G8B8;
+
+      /* Required for GL2.1:
+       */
+   case PIPE_FORMAT_B8G8R8A8_SRGB:
+      return SVGA3D_A8R8G8B8;
+
+   case PIPE_FORMAT_B5G6R5_UNORM:
+      return SVGA3D_R5G6B5;
+   case PIPE_FORMAT_B5G5R5A1_UNORM:
+      return SVGA3D_A1R5G5B5;
+   case PIPE_FORMAT_B4G4R4A4_UNORM:
+      return SVGA3D_A4R4G4B4;
+
+      
+   /* XXX: Doesn't seem to work properly.
+   case PIPE_FORMAT_Z32_UNORM:
+      return SVGA3D_Z_D32;
+    */
+   case PIPE_FORMAT_Z16_UNORM:
+      return SVGA3D_Z_D16;
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+      return SVGA3D_Z_D24S8;
+   case PIPE_FORMAT_X8Z24_UNORM:
+      return SVGA3D_Z_D24X8;
+
+   case PIPE_FORMAT_A8_UNORM:
+      return SVGA3D_ALPHA8;
+   case PIPE_FORMAT_L8_UNORM:
+      return SVGA3D_LUMINANCE8;
+
+   case PIPE_FORMAT_DXT1_RGB:
+   case PIPE_FORMAT_DXT1_RGBA:
+      return SVGA3D_DXT1;
+   case PIPE_FORMAT_DXT3_RGBA:
+      return SVGA3D_DXT3;
+   case PIPE_FORMAT_DXT5_RGBA:
+      return SVGA3D_DXT5;
+
+   default:
+      return SVGA3D_FORMAT_INVALID;
+   }
+}
+
+
+SVGA3dSurfaceFormat
+svga_translate_format_render(enum pipe_format format)
+{
+   switch(format) { 
+   case PIPE_FORMAT_B8G8R8A8_UNORM:
+   case PIPE_FORMAT_B8G8R8X8_UNORM:
+   case PIPE_FORMAT_B5G5R5A1_UNORM:
+   case PIPE_FORMAT_B4G4R4A4_UNORM:
+   case PIPE_FORMAT_B5G6R5_UNORM:
+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
+   case PIPE_FORMAT_X8Z24_UNORM:
+   case PIPE_FORMAT_Z32_UNORM:
+   case PIPE_FORMAT_Z16_UNORM:
+   case PIPE_FORMAT_L8_UNORM:
+      return svga_translate_format(format);
+
+#if 1
+   /* For on host conversion */
+   case PIPE_FORMAT_DXT1_RGB:
+      return SVGA3D_X8R8G8B8;
+   case PIPE_FORMAT_DXT1_RGBA:
+   case PIPE_FORMAT_DXT3_RGBA:
+   case PIPE_FORMAT_DXT5_RGBA:
+      return SVGA3D_A8R8G8B8;
+#endif
+
+   default:
+      return SVGA3D_FORMAT_INVALID;
+   }
+}
+
+
+static INLINE void
+svga_transfer_dma_band(struct svga_transfer *st,
+                       SVGA3dTransferType transfer,
+                       unsigned y, unsigned h, unsigned srcy)
+{
+   struct svga_texture *texture = svga_texture(st->base.resource); 
+   struct svga_screen *screen = svga_screen(texture->b.b.screen);
+   SVGA3dCopyBox box;
+   enum pipe_error ret;
+   
+   SVGA_DBG(DEBUG_DMA, "dma %s sid %p, face %u, (%u, %u, %u) - (%u, %u, %u), %ubpp\n",
+                transfer == SVGA3D_WRITE_HOST_VRAM ? "to" : "from", 
+                texture->handle,
+                st->base.sr.face,
+                st->base.box.x,
+                y,
+                st->base.box.z,
+                st->base.box.x + st->base.box.width,
+                y + h,
+                st->base.box.z + 1,
+                util_format_get_blocksize(texture->b.b.format) * 8 /
+                (util_format_get_blockwidth(texture->b.b.format)*util_format_get_blockheight(texture->b.b.format)));
+   
+   box.x = st->base.box.x;
+   box.y = y;
+   box.z = st->base.box.z;
+   box.w = st->base.box.width;
+   box.h = h;
+   box.d = 1;
+   box.srcx = 0;
+   box.srcy = srcy;
+   box.srcz = 0;
+
+   pipe_mutex_lock(screen->swc_mutex);
+   ret = SVGA3D_SurfaceDMA(screen->swc, st, transfer, &box, 1);
+   if(ret != PIPE_OK) {
+      screen->swc->flush(screen->swc, NULL);
+      ret = SVGA3D_SurfaceDMA(screen->swc, st, transfer, &box, 1);
+      assert(ret == PIPE_OK);
+   }
+   pipe_mutex_unlock(screen->swc_mutex);
+}
+
+
+static INLINE void
+svga_transfer_dma(struct svga_transfer *st,
+                 SVGA3dTransferType transfer)
+{
+   struct svga_texture *texture = svga_texture(st->base.resource); 
+   struct svga_screen *screen = svga_screen(texture->b.b.screen);
+   struct svga_winsys_screen *sws = screen->sws;
+   struct pipe_fence_handle *fence = NULL;
+   
+   if (transfer == SVGA3D_READ_HOST_VRAM) {
+      SVGA_DBG(DEBUG_PERF, "%s: readback transfer\n", __FUNCTION__);
+   }
+
+
+   if(!st->swbuf) {
+      /* Do the DMA transfer in a single go */
+      
+      svga_transfer_dma_band(st, transfer, st->base.box.y, st->base.box.height, 0);
+
+      if(transfer == SVGA3D_READ_HOST_VRAM) {
+         svga_screen_flush(screen, &fence);
+         sws->fence_finish(sws, fence, 0);
+         sws->fence_reference(sws, &fence, NULL);
+      }
+   }
+   else {
+      unsigned y, h, srcy;
+      unsigned blockheight = util_format_get_blockheight(st->base.resource->format);
+      h = st->hw_nblocksy * blockheight;
+      srcy = 0;
+      for(y = 0; y < st->base.box.height; y += h) {
+         unsigned offset, length;
+         void *hw, *sw;
+
+         if (y + h > st->base.box.height)
+            h = st->base.box.height - y;
+
+         /* Transfer band must be aligned to pixel block boundaries */
+         assert(y % blockheight == 0);
+         assert(h % blockheight == 0);
+         
+         offset = y * st->base.stride / blockheight;
+         length = h * st->base.stride / blockheight;
+
+         sw = (uint8_t *)st->swbuf + offset;
+         
+         if(transfer == SVGA3D_WRITE_HOST_VRAM) {
+            /* Wait for the previous DMAs to complete */
+            /* TODO: keep one DMA (at half the size) in the background */
+            if(y) {
+               svga_screen_flush(screen, &fence);
+               sws->fence_finish(sws, fence, 0);
+               sws->fence_reference(sws, &fence, NULL);
+            }
+
+            hw = sws->buffer_map(sws, st->hwbuf, PIPE_TRANSFER_WRITE);
+            assert(hw);
+            if(hw) {
+               memcpy(hw, sw, length);
+               sws->buffer_unmap(sws, st->hwbuf);
+            }
+         }
+         
+         svga_transfer_dma_band(st, transfer, y, h, srcy);
+         
+         if(transfer == SVGA3D_READ_HOST_VRAM) {
+            svga_screen_flush(screen, &fence);
+            sws->fence_finish(sws, fence, 0);
+
+            hw = sws->buffer_map(sws, st->hwbuf, PIPE_TRANSFER_READ);
+            assert(hw);
+            if(hw) {
+               memcpy(sw, hw, length);
+               sws->buffer_unmap(sws, st->hwbuf);
+            }
+         }
+      }
+   }
+}
+
+
+
+
+
+static boolean 
+svga_texture_get_handle(struct pipe_screen *screen,
+                               struct pipe_resource *texture,
+                               struct winsys_handle *whandle)
+{
+   struct svga_winsys_screen *sws = svga_winsys_screen(texture->screen);
+   unsigned stride;
+
+   assert(svga_texture(texture)->key.cachable == 0);
+   svga_texture(texture)->key.cachable = 0;
+   stride = util_format_get_nblocksx(texture->format, texture->width0) *
+            util_format_get_blocksize(texture->format);
+   return sws->surface_get_handle(sws, svga_texture(texture)->handle, stride, whandle);
+}
+
+
+static void
+svga_texture_destroy(struct pipe_screen *screen,
+		     struct pipe_resource *pt)
+{
+   struct svga_screen *ss = svga_screen(screen);
+   struct svga_texture *tex = (struct svga_texture *)pt;
+
+   ss->texture_timestamp++;
+
+   svga_sampler_view_reference(&tex->cached_view, NULL);
+
+   /*
+     DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
+   */
+   SVGA_DBG(DEBUG_DMA, "unref sid %p (texture)\n", tex->handle);
+   svga_screen_surface_destroy(ss, &tex->key, &tex->handle);
+
+   FREE(tex);
+}
+
+
+
+
+
+
+
+/* XXX: Still implementing this as if it was a screen function, but
+ * can now modify it to queue transfers on the context.
+ */
+static struct pipe_transfer *
+svga_texture_get_transfer(struct pipe_context *pipe,
+			  struct pipe_resource *texture,
+			  struct pipe_subresource sr,
+			  unsigned usage,
+			  const struct pipe_box *box)
+{
+   struct svga_screen *ss = svga_screen(pipe->screen);
+   struct svga_winsys_screen *sws = ss->sws;
+   struct svga_transfer *st;
+   unsigned nblocksx = util_format_get_nblocksx(texture->format, box->width);
+   unsigned nblocksy = util_format_get_nblocksy(texture->format, box->height);
+
+   /* We can't map texture storage directly */
+   if (usage & PIPE_TRANSFER_MAP_DIRECTLY)
+      return NULL;
+
+   st = CALLOC_STRUCT(svga_transfer);
+   if (!st)
+      return NULL;
+   
+   pipe_resource_reference(&st->base.resource, texture);
+   st->base.sr = sr;
+   st->base.usage = usage;
+   st->base.box = *box;
+   st->base.stride = nblocksx*util_format_get_blocksize(texture->format);
+   st->base.slice_stride = 0;
+
+   st->hw_nblocksy = nblocksy;
+   
+   st->hwbuf = svga_winsys_buffer_create(ss, 
+                                         1, 
+                                         0,
+                                         st->hw_nblocksy*st->base.stride);
+   while(!st->hwbuf && (st->hw_nblocksy /= 2)) {
+      st->hwbuf = svga_winsys_buffer_create(ss, 
+                                            1, 
+                                            0,
+                                            st->hw_nblocksy*st->base.stride);
+   }
+
+   if(!st->hwbuf)
+      goto no_hwbuf;
+
+   if(st->hw_nblocksy < nblocksy) {
+      /* We couldn't allocate a hardware buffer big enough for the transfer, 
+       * so allocate regular malloc memory instead */
+      debug_printf("%s: failed to allocate %u KB of DMA, splitting into %u x %u KB DMA transfers\n",
+                   __FUNCTION__,
+                   (nblocksy*st->base.stride + 1023)/1024,
+                   (nblocksy + st->hw_nblocksy - 1)/st->hw_nblocksy,
+                   (st->hw_nblocksy*st->base.stride + 1023)/1024);
+      st->swbuf = MALLOC(nblocksy*st->base.stride);
+      if(!st->swbuf)
+         goto no_swbuf;
+   }
+   
+   if (usage & PIPE_TRANSFER_READ)
+      svga_transfer_dma(st, SVGA3D_READ_HOST_VRAM);
+
+   return &st->base;
+
+no_swbuf:
+   sws->buffer_destroy(sws, st->hwbuf);
+no_hwbuf:
+   FREE(st);
+   return NULL;
+}
+
+
+/* XXX: Still implementing this as if it was a screen function, but
+ * can now modify it to queue transfers on the context.
+ */
+static void *
+svga_texture_transfer_map( struct pipe_context *pipe,
+			   struct pipe_transfer *transfer )
+{
+   struct svga_screen *ss = svga_screen(pipe->screen);
+   struct svga_winsys_screen *sws = ss->sws;
+   struct svga_transfer *st = svga_transfer(transfer);
+
+   if(st->swbuf)
+      return st->swbuf;
+   else
+      /* The wait for read transfers already happened when svga_transfer_dma
+       * was called. */
+      return sws->buffer_map(sws, st->hwbuf, transfer->usage);
+}
+
+
+/* XXX: Still implementing this as if it was a screen function, but
+ * can now modify it to queue transfers on the context.
+ */
+static void
+svga_texture_transfer_unmap(struct pipe_context *pipe,
+			    struct pipe_transfer *transfer)
+{
+   struct svga_screen *ss = svga_screen(pipe->screen);
+   struct svga_winsys_screen *sws = ss->sws;
+   struct svga_transfer *st = svga_transfer(transfer);
+   
+   if(!st->swbuf)
+      sws->buffer_unmap(sws, st->hwbuf);
+}
+
+
+static void
+svga_texture_transfer_destroy(struct pipe_context *pipe,
+			      struct pipe_transfer *transfer)
+{
+   struct svga_texture *tex = svga_texture(transfer->resource);
+   struct svga_screen *ss = svga_screen(pipe->screen);
+   struct svga_winsys_screen *sws = ss->sws;
+   struct svga_transfer *st = svga_transfer(transfer);
+
+   if (st->base.usage & PIPE_TRANSFER_WRITE) {
+      svga_transfer_dma(st, SVGA3D_WRITE_HOST_VRAM);
+      ss->texture_timestamp++;
+      tex->view_age[transfer->sr.level] = ++(tex->age);
+      tex->defined[transfer->sr.face][transfer->sr.level] = TRUE;
+   }
+
+   pipe_resource_reference(&st->base.resource, NULL);
+   FREE(st->swbuf);
+   sws->buffer_destroy(sws, st->hwbuf);
+   FREE(st);
+}
+
+
+
+
+
+struct u_resource_vtbl svga_texture_vtbl = 
+{
+   svga_texture_get_handle,	      /* get_handle */
+   svga_texture_destroy,	      /* resource_destroy */
+   svga_texture_is_referenced,	      /* is_resource_referenced */
+   svga_texture_get_transfer,	      /* get_transfer */
+   svga_texture_transfer_destroy,     /* transfer_destroy */
+   svga_texture_transfer_map,	      /* transfer_map */
+   u_default_transfer_flush_region,   /* transfer_flush_region */
+   svga_texture_transfer_unmap,	      /* transfer_unmap */
+   u_default_transfer_inline_write    /* transfer_inline_write */
+};
+
+
+
+
+struct pipe_resource *
+svga_texture_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template)
+{
+   struct svga_screen *svgascreen = svga_screen(screen);
+   struct svga_texture *tex = CALLOC_STRUCT(svga_texture);
+   
+   if (!tex)
+      goto error1;
+
+   tex->b.b = *template;
+   tex->b.vtbl = &svga_texture_vtbl;
+   pipe_reference_init(&tex->b.b.reference, 1);
+   tex->b.b.screen = screen;
+
+   assert(template->last_level < SVGA_MAX_TEXTURE_LEVELS);
+   if(template->last_level >= SVGA_MAX_TEXTURE_LEVELS)
+      goto error2;
+   
+   tex->key.flags = 0;
+   tex->key.size.width = template->width0;
+   tex->key.size.height = template->height0;
+   tex->key.size.depth = template->depth0;
+   
+   if(template->target == PIPE_TEXTURE_CUBE) {
+      tex->key.flags |= SVGA3D_SURFACE_CUBEMAP;
+      tex->key.numFaces = 6;
+   }
+   else {
+      tex->key.numFaces = 1;
+   }
+
+   tex->key.cachable = 1;
+
+   if (template->bind & PIPE_BIND_SAMPLER_VIEW)
+      tex->key.flags |= SVGA3D_SURFACE_HINT_TEXTURE;
+
+   if (template->bind & PIPE_BIND_DISPLAY_TARGET) {
+      tex->key.cachable = 0;
+   }
+
+   if (template->bind & PIPE_BIND_SHARED) {
+      tex->key.cachable = 0;
+   }
+
+   if (template->bind & PIPE_BIND_SCANOUT) {
+      tex->key.flags |= SVGA3D_SURFACE_HINT_SCANOUT;
+      tex->key.cachable = 0;
+   }
+   
+   /* 
+    * XXX: Never pass the SVGA3D_SURFACE_HINT_RENDERTARGET hint. Mesa cannot
+    * know beforehand whether a texture will be used as a rendertarget or not
+    * and it always requests PIPE_BIND_RENDER_TARGET, therefore
+    * passing the SVGA3D_SURFACE_HINT_RENDERTARGET here defeats its purpose.
+    */
+#if 0
+   if((template->bind & PIPE_BIND_RENDER_TARGET) &&
+      !util_format_is_s3tc(template->format))
+      tex->key.flags |= SVGA3D_SURFACE_HINT_RENDERTARGET;
+#endif
+   
+   if(template->bind & PIPE_BIND_DEPTH_STENCIL)
+      tex->key.flags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
+   
+   tex->key.numMipLevels = template->last_level + 1;
+   
+   tex->key.format = svga_translate_format(template->format);
+   if(tex->key.format == SVGA3D_FORMAT_INVALID)
+      goto error2;
+
+   SVGA_DBG(DEBUG_DMA, "surface_create for texture\n", tex->handle);
+   tex->handle = svga_screen_surface_create(svgascreen, &tex->key);
+   if (tex->handle)
+      SVGA_DBG(DEBUG_DMA, "  --> got sid %p (texture)\n", tex->handle);
+
+   return &tex->b.b;
+
+error2:
+   FREE(tex);
+error1:
+   return NULL;
+}
+
+
+
+
+struct pipe_resource *
+svga_texture_from_handle(struct pipe_screen *screen,
+			 const struct pipe_resource *template,
+			 struct winsys_handle *whandle)
+{
+   struct svga_winsys_screen *sws = svga_winsys_screen(screen);
+   struct svga_winsys_surface *srf;
+   struct svga_texture *tex;
+   enum SVGA3dSurfaceFormat format = 0;
+   assert(screen);
+
+   /* Only supports one type */
+   if (template->target != PIPE_TEXTURE_2D ||
+       template->last_level != 0 ||
+       template->depth0 != 1) {
+      return NULL;
+   }
+
+   srf = sws->surface_from_handle(sws, whandle, &format);
+
+   if (!srf)
+      return NULL;
+
+   if (svga_translate_format(template->format) != format) {
+      unsigned f1 = svga_translate_format(template->format);
+      unsigned f2 = format;
+
+      /* It's okay for XRGB and ARGB or depth with/out stencil to get mixed up */
+      if ( !( (f1 == SVGA3D_X8R8G8B8 && f2 == SVGA3D_A8R8G8B8) ||
+              (f1 == SVGA3D_A8R8G8B8 && f2 == SVGA3D_X8R8G8B8) ||
+              (f1 == SVGA3D_Z_D24X8 && f2 == SVGA3D_Z_D24S8) ) ) {
+         debug_printf("%s wrong format %u != %u\n", __FUNCTION__, f1, f2);
+         return NULL;
+      }
+   }
+
+   tex = CALLOC_STRUCT(svga_texture);
+   if (!tex)
+      return NULL;
+
+   tex->b.b = *template;
+   tex->b.vtbl = &svga_texture_vtbl;
+   pipe_reference_init(&tex->b.b.reference, 1);
+   tex->b.b.screen = screen;
+
+   if (format == SVGA3D_X8R8G8B8)
+      tex->b.b.format = PIPE_FORMAT_B8G8R8X8_UNORM;
+   else if (format == SVGA3D_A8R8G8B8)
+      tex->b.b.format = PIPE_FORMAT_B8G8R8A8_UNORM;
+   else {
+      /* ?? */
+   }
+
+   SVGA_DBG(DEBUG_DMA, "wrap surface sid %p\n", srf);
+
+   tex->key.cachable = 0;
+   tex->handle = srf;
+
+   return &tex->b.b;
+}
+
diff --git a/src/gallium/drivers/svga/svga_screen_texture.h b/src/gallium/drivers/svga/svga_resource_texture.h
index 96d035b12d8..631937f2eb0 100644
--- a/src/gallium/drivers/svga/svga_screen_texture.h
+++ b/src/gallium/drivers/svga/svga_resource_texture.h
@@ -30,6 +30,7 @@
 #include "pipe/p_compiler.h"
 #include "pipe/p_state.h"
 #include "util/u_inlines.h"
+#include "util/u_transfer.h"
 #include "svga_screen_cache.h"
 
 struct pipe_context;
@@ -42,41 +43,12 @@ enum SVGA3dSurfaceFormat;
 #define SVGA_MAX_TEXTURE_LEVELS 16
 
 
-/**
- * A sampler's view into a texture
- *
- * We currently cache one sampler view on
- * the texture and in there by holding a reference
- * from the texture to the sampler view.
- *
- * Because of this we can not hold a refernce to the
- * texture from the sampler view. So the user
- * of the sampler views must make sure that the
- * texture has a reference take for as long as
- * the sampler view is refrenced.
- *
- * Just unreferencing the sampler_view before the
- * texture is enough.
- */
-struct svga_sampler_view
-{
-   struct pipe_reference reference;
-
-   struct pipe_texture *texture;
-
-   int min_lod;
-   int max_lod;
-
-   unsigned age;
-
-   struct svga_host_surface_cache_key key;
-   struct svga_winsys_surface *handle;
-};
+extern struct u_resource_vtbl svga_texture_vtbl;
 
 
 struct svga_texture 
 {
-   struct pipe_texture base;
+   struct u_resource b;
 
    boolean defined[6][SVGA_MAX_TEXTURE_LEVELS];
    
@@ -106,21 +78,9 @@ struct svga_texture
 };
 
 
-struct svga_surface
-{
-   struct pipe_surface base;
-
-   struct svga_host_surface_cache_key key;
-   struct svga_winsys_surface *handle;
-
-   unsigned real_face;
-   unsigned real_level;
-   unsigned real_zslice;
-
-   boolean dirty;
-};
-
 
+/* Note this is only used for texture (not buffer) transfers:
+ */
 struct svga_transfer
 {
    struct pipe_transfer base;
@@ -136,18 +96,13 @@ struct svga_transfer
 };
 
 
-static INLINE struct svga_texture *
-svga_texture(struct pipe_texture *texture)
+static INLINE struct svga_texture *svga_texture( struct pipe_resource *resource )
 {
-   return (struct svga_texture *)texture;
+   struct svga_texture *tex = (struct svga_texture *)resource;
+   assert(tex == NULL || tex->b.vtbl == &svga_texture_vtbl);
+   return tex;
 }
 
-static INLINE struct svga_surface *
-svga_surface(struct pipe_surface *surface)
-{
-   assert(surface);
-   return (struct svga_surface *)surface;
-}
 
 static INLINE struct svga_transfer *
 svga_transfer(struct pipe_transfer *transfer)
@@ -156,38 +111,18 @@ svga_transfer(struct pipe_transfer *transfer)
    return (struct svga_transfer *)transfer;
 }
 
-extern struct svga_sampler_view *
-svga_get_tex_sampler_view(struct pipe_context *pipe,
-                          struct pipe_texture *pt,
-                          unsigned min_lod, unsigned max_lod);
-
-void
-svga_validate_sampler_view(struct svga_context *svga, struct svga_sampler_view *v);
-
-void
-svga_destroy_sampler_view_priv(struct svga_sampler_view *v);
 
-static INLINE void
-svga_sampler_view_reference(struct svga_sampler_view **ptr, struct svga_sampler_view *v)
-{
-   struct svga_sampler_view *old = *ptr;
-
-   if (pipe_reference(&(*ptr)->reference, &v->reference))
-      svga_destroy_sampler_view_priv(old);
-   *ptr = v;
-}
 
-extern void
-svga_propagate_surface(struct pipe_context *pipe, struct pipe_surface *surf);
+struct pipe_resource *
+svga_texture_create(struct pipe_screen *screen,
+                    const struct pipe_resource *template);
 
-extern boolean
-svga_surface_needs_propagation(struct pipe_surface *surf);
+struct pipe_resource *
+svga_texture_from_handle(struct pipe_screen * screen,
+			const struct pipe_resource *template,
+			struct winsys_handle *whandle);
 
-extern void
-svga_screen_init_texture_functions(struct pipe_screen *screen);
 
-void
-svga_init_texture_functions(struct pipe_context *pipe);
 
 enum SVGA3dSurfaceFormat
 svga_translate_format(enum pipe_format format);
diff --git a/src/gallium/drivers/svga/svga_sampler_view.c b/src/gallium/drivers/svga/svga_sampler_view.c
new file mode 100644
index 00000000000..fbae552f78f
--- /dev/null
+++ b/src/gallium/drivers/svga/svga_sampler_view.c
@@ -0,0 +1,196 @@
+/**********************************************************
+ * Copyright 2008-2009 VMware, Inc.  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, sublicense, 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 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
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * 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.
+ *
+ **********************************************************/
+
+#include "svga_cmd.h"
+
+#include "pipe/p_state.h"
+#include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+#include "os/os_thread.h"
+#include "util/u_format.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+
+#include "svga_screen.h"
+#include "svga_context.h"
+#include "svga_resource_texture.h"
+#include "svga_sampler_view.h"
+#include "svga_debug.h"
+#include "svga_surface.h"
+
+
+struct svga_sampler_view *
+svga_get_tex_sampler_view(struct pipe_context *pipe,
+			  struct pipe_resource *pt,
+                          unsigned min_lod, unsigned max_lod)
+{
+   struct svga_screen *ss = svga_screen(pt->screen);
+   struct svga_texture *tex = svga_texture(pt); 
+   struct svga_sampler_view *sv = NULL;
+   SVGA3dSurfaceFormat format = svga_translate_format(pt->format);
+   boolean view = TRUE;
+
+   assert(pt);
+   assert(min_lod >= 0);
+   assert(min_lod <= max_lod);
+   assert(max_lod <= pt->last_level);
+
+
+   /* Is a view needed */
+   {
+      /*
+       * Can't control max lod. For first level views and when we only
+       * look at one level we disable mip filtering to achive the same
+       * results as a view.
+       */
+      if (min_lod == 0 && max_lod >= pt->last_level)
+         view = FALSE;
+
+      if (util_format_is_s3tc(pt->format) && view) {
+         format = svga_translate_format_render(pt->format);
+      }
+
+      if (ss->debug.no_sampler_view)
+         view = FALSE;
+
+      if (ss->debug.force_sampler_view)
+         view = TRUE;
+   }
+
+   /* First try the cache */
+   if (view) {
+      pipe_mutex_lock(ss->tex_mutex);
+      if (tex->cached_view &&
+          tex->cached_view->min_lod == min_lod &&
+          tex->cached_view->max_lod == max_lod) {
+         svga_sampler_view_reference(&sv, tex->cached_view);
+         pipe_mutex_unlock(ss->tex_mutex);
+         SVGA_DBG(DEBUG_VIEWS, "svga: Sampler view: reuse %p, %u %u, last %u\n",
+                              pt, min_lod, max_lod, pt->last_level);
+         svga_validate_sampler_view(svga_context(pipe), sv);
+         return sv;
+      }
+      pipe_mutex_unlock(ss->tex_mutex);
+   }
+
+   sv = CALLOC_STRUCT(svga_sampler_view);
+   pipe_reference_init(&sv->reference, 1);
+   pipe_resource_reference(&sv->texture, pt);
+   sv->min_lod = min_lod;
+   sv->max_lod = max_lod;
+
+   /* No view needed just use the whole texture */
+   if (!view) {
+      SVGA_DBG(DEBUG_VIEWS,
+               "svga: Sampler view: no %p, mips %u..%u, nr %u, size (%ux%ux%u), last %u\n",
+               pt, min_lod, max_lod,
+               max_lod - min_lod + 1,
+               pt->width0,
+               pt->height0,
+               pt->depth0,
+               pt->last_level);
+      sv->key.cachable = 0;
+      sv->handle = tex->handle;
+      return sv;
+   }
+
+   SVGA_DBG(DEBUG_VIEWS,
+            "svga: Sampler view: yes %p, mips %u..%u, nr %u, size (%ux%ux%u), last %u\n",
+            pt, min_lod, max_lod,
+            max_lod - min_lod + 1,
+            pt->width0,
+            pt->height0,
+            pt->depth0,
+            pt->last_level);
+
+   sv->age = tex->age;
+   sv->handle = svga_texture_view_surface(pipe, tex, format,
+                                          min_lod,
+                                          max_lod - min_lod + 1,
+                                          -1, -1,
+                                          &sv->key);
+
+   if (!sv->handle) {
+      assert(0);
+      sv->key.cachable = 0;
+      sv->handle = tex->handle;
+      return sv;
+   }
+
+   pipe_mutex_lock(ss->tex_mutex);
+   svga_sampler_view_reference(&tex->cached_view, sv);
+   pipe_mutex_unlock(ss->tex_mutex);
+
+   return sv;
+}
+
+void
+svga_validate_sampler_view(struct svga_context *svga, struct svga_sampler_view *v)
+{
+   struct svga_texture *tex = svga_texture(v->texture);
+   unsigned numFaces;
+   unsigned age = 0;
+   int i, k;
+
+   assert(svga);
+
+   if (v->handle == tex->handle)
+      return;
+
+   age = tex->age;
+
+   if(tex->b.b.target == PIPE_TEXTURE_CUBE)
+      numFaces = 6;
+   else
+      numFaces = 1;
+
+   for (i = v->min_lod; i <= v->max_lod; i++) {
+      for (k = 0; k < numFaces; k++) {
+         if (v->age < tex->view_age[i])
+            svga_texture_copy_handle(svga, NULL,
+                                     tex->handle, 0, 0, 0, i, k,
+                                     v->handle, 0, 0, 0, i - v->min_lod, k,
+                                     u_minify(tex->b.b.width0, i),
+                                     u_minify(tex->b.b.height0, i),
+                                     u_minify(tex->b.b.depth0, i));
+      }
+   }
+
+   v->age = age;
+}
+
+void
+svga_destroy_sampler_view_priv(struct svga_sampler_view *v)
+{
+   struct svga_texture *tex = svga_texture(v->texture);
+
+   if(v->handle != tex->handle) {
+      struct svga_screen *ss = svga_screen(v->texture->screen);
+      SVGA_DBG(DEBUG_DMA, "unref sid %p (sampler view)\n", v->handle);
+      svga_screen_surface_destroy(ss, &v->key, &v->handle);
+   }
+   pipe_resource_reference(&v->texture, NULL);
+   FREE(v);
+}
diff --git a/src/gallium/drivers/svga/svga_sampler_view.h b/src/gallium/drivers/svga/svga_sampler_view.h
new file mode 100644
index 00000000000..e64665f2e58
--- /dev/null
+++ b/src/gallium/drivers/svga/svga_sampler_view.h
@@ -0,0 +1,97 @@
+/**********************************************************
+ * Copyright 2008-2009 VMware, Inc.  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, sublicense, 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 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
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * 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 SVGA_SAMPLER_VIEW_H
+#define SVGA_SAMPLER_VIEW_H
+
+
+#include "pipe/p_compiler.h"
+#include "pipe/p_state.h"
+#include "util/u_inlines.h"
+#include "svga_screen_cache.h"
+
+struct pipe_context;
+struct pipe_screen;
+struct svga_context;
+struct svga_winsys_surface;
+enum SVGA3dSurfaceFormat;
+
+
+/**
+ * A sampler's view into a texture
+ *
+ * We currently cache one sampler view on
+ * the texture and in there by holding a reference
+ * from the texture to the sampler view.
+ *
+ * Because of this we can not hold a refernce to the
+ * texture from the sampler view. So the user
+ * of the sampler views must make sure that the
+ * texture has a reference take for as long as
+ * the sampler view is refrenced.
+ *
+ * Just unreferencing the sampler_view before the
+ * texture is enough.
+ */
+struct svga_sampler_view
+{
+   struct pipe_reference reference;
+
+   struct pipe_resource *texture;
+
+   int min_lod;
+   int max_lod;
+
+   unsigned age;
+
+   struct svga_host_surface_cache_key key;
+   struct svga_winsys_surface *handle;
+};
+
+
+
+extern struct svga_sampler_view *
+svga_get_tex_sampler_view(struct pipe_context *pipe,
+                          struct pipe_resource *pt,
+                          unsigned min_lod, unsigned max_lod);
+
+void
+svga_validate_sampler_view(struct svga_context *svga, struct svga_sampler_view *v);
+
+void
+svga_destroy_sampler_view_priv(struct svga_sampler_view *v);
+
+static INLINE void
+svga_sampler_view_reference(struct svga_sampler_view **ptr, struct svga_sampler_view *v)
+{
+   struct svga_sampler_view *old = *ptr;
+
+   if (pipe_reference(&(*ptr)->reference, &v->reference))
+      svga_destroy_sampler_view_priv(old);
+   *ptr = v;
+}
+
+
+#endif
diff --git a/src/gallium/drivers/svga/svga_screen.c b/src/gallium/drivers/svga/svga_screen.c
index 9a2e7c6f5b0..aeda3dcad51 100644
--- a/src/gallium/drivers/svga/svga_screen.c
+++ b/src/gallium/drivers/svga/svga_screen.c
@@ -31,8 +31,8 @@
 #include "svga_winsys.h"
 #include "svga_context.h"
 #include "svga_screen.h"
-#include "svga_screen_texture.h"
-#include "svga_screen_buffer.h"
+#include "svga_resource_texture.h"
+#include "svga_resource.h"
 #include "svga_debug.h"
 
 #include "svga3d_shaderdefs.h"
@@ -248,7 +248,7 @@ svga_is_format_supported( struct pipe_screen *screen,
    assert(tex_usage);
 
    /* Override host capabilities */
-   if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET) {
+   if (tex_usage & PIPE_BIND_RENDER_TARGET) {
       switch(format) { 
 
       /* Often unsupported/problematic. This means we end up with the same
@@ -278,11 +278,11 @@ svga_is_format_supported( struct pipe_screen *screen,
       SVGA3dSurfaceFormatCaps mask;
       
       mask.value = 0;
-      if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
+      if (tex_usage & PIPE_BIND_RENDER_TARGET)
          mask.offscreenRenderTarget = 1;
-      if (tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL)
+      if (tex_usage & PIPE_BIND_DEPTH_STENCIL)
          mask.zStencil = 1;
-      if (tex_usage & PIPE_TEXTURE_USAGE_SAMPLER)
+      if (tex_usage & PIPE_BIND_SAMPLER_VIEW)
          mask.texture = 1;
 
       if ((result.u & mask.value) == mask.value)
@@ -295,7 +295,7 @@ svga_is_format_supported( struct pipe_screen *screen,
     * duplicated list of supported formats which is prone to getting
     * out of sync:
     */
-   if(tex_usage & (PIPE_TEXTURE_USAGE_RENDER_TARGET | PIPE_TEXTURE_USAGE_DEPTH_STENCIL))
+   if(tex_usage & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_DEPTH_STENCIL))
       return svga_translate_format_render(format) != SVGA3D_FORMAT_INVALID;
    else
       return svga_translate_format(format) != SVGA3D_FORMAT_INVALID;
@@ -397,8 +397,7 @@ svga_screen_create(struct svga_winsys_screen *sws)
    screen->fence_finish = svga_fence_finish;
    svgascreen->sws = sws;
 
-   svga_screen_init_texture_functions(screen);
-   svga_screen_init_buffer_functions(screen);
+   svga_init_screen_resource_functions(svgascreen);
 
    svgascreen->use_ps30 =
       sws->get_cap(sws, SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION, &result) &&
diff --git a/src/gallium/drivers/svga/svga_screen_texture.c b/src/gallium/drivers/svga/svga_screen_texture.c
deleted file mode 100644
index 811c7466956..00000000000
--- a/src/gallium/drivers/svga/svga_screen_texture.c
+++ /dev/null
@@ -1,1097 +0,0 @@
-/**********************************************************
- * Copyright 2008-2009 VMware, Inc.  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, sublicense, 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 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
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * 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.
- *
- **********************************************************/
-
-#include "svga_cmd.h"
-
-#include "pipe/p_state.h"
-#include "pipe/p_defines.h"
-#include "util/u_inlines.h"
-#include "os/os_thread.h"
-#include "util/u_format.h"
-#include "util/u_math.h"
-#include "util/u_memory.h"
-
-#include "svga_screen.h"
-#include "svga_context.h"
-#include "svga_screen_texture.h"
-#include "svga_screen_buffer.h"
-#include "svga_winsys.h"
-#include "svga_debug.h"
-#include "svga_screen_buffer.h"
-
-
-/* XXX: This isn't a real hardware flag, but just a hack for kernel to
- * know about primary surfaces. Find a better way to accomplish this.
- */
-#define SVGA3D_SURFACE_HINT_SCANOUT (1 << 9)
-
-
-/*
- * Helper function and arrays
- */
-
-SVGA3dSurfaceFormat
-svga_translate_format(enum pipe_format format)
-{
-   switch(format) {
-   
-   case PIPE_FORMAT_B8G8R8A8_UNORM:
-      return SVGA3D_A8R8G8B8;
-   case PIPE_FORMAT_B8G8R8X8_UNORM:
-      return SVGA3D_X8R8G8B8;
-
-      /* Required for GL2.1:
-       */
-   case PIPE_FORMAT_B8G8R8A8_SRGB:
-      return SVGA3D_A8R8G8B8;
-
-   case PIPE_FORMAT_B5G6R5_UNORM:
-      return SVGA3D_R5G6B5;
-   case PIPE_FORMAT_B5G5R5A1_UNORM:
-      return SVGA3D_A1R5G5B5;
-   case PIPE_FORMAT_B4G4R4A4_UNORM:
-      return SVGA3D_A4R4G4B4;
-
-      
-   /* XXX: Doesn't seem to work properly.
-   case PIPE_FORMAT_Z32_UNORM:
-      return SVGA3D_Z_D32;
-    */
-   case PIPE_FORMAT_Z16_UNORM:
-      return SVGA3D_Z_D16;
-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-      return SVGA3D_Z_D24S8;
-   case PIPE_FORMAT_X8Z24_UNORM:
-      return SVGA3D_Z_D24X8;
-
-   case PIPE_FORMAT_A8_UNORM:
-      return SVGA3D_ALPHA8;
-   case PIPE_FORMAT_L8_UNORM:
-      return SVGA3D_LUMINANCE8;
-
-   case PIPE_FORMAT_DXT1_RGB:
-   case PIPE_FORMAT_DXT1_RGBA:
-      return SVGA3D_DXT1;
-   case PIPE_FORMAT_DXT3_RGBA:
-      return SVGA3D_DXT3;
-   case PIPE_FORMAT_DXT5_RGBA:
-      return SVGA3D_DXT5;
-
-   default:
-      return SVGA3D_FORMAT_INVALID;
-   }
-}
-
-
-SVGA3dSurfaceFormat
-svga_translate_format_render(enum pipe_format format)
-{
-   switch(format) { 
-   case PIPE_FORMAT_B8G8R8A8_UNORM:
-   case PIPE_FORMAT_B8G8R8X8_UNORM:
-   case PIPE_FORMAT_B5G5R5A1_UNORM:
-   case PIPE_FORMAT_B4G4R4A4_UNORM:
-   case PIPE_FORMAT_B5G6R5_UNORM:
-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-   case PIPE_FORMAT_X8Z24_UNORM:
-   case PIPE_FORMAT_Z32_UNORM:
-   case PIPE_FORMAT_Z16_UNORM:
-   case PIPE_FORMAT_L8_UNORM:
-      return svga_translate_format(format);
-
-#if 1
-   /* For on host conversion */
-   case PIPE_FORMAT_DXT1_RGB:
-      return SVGA3D_X8R8G8B8;
-   case PIPE_FORMAT_DXT1_RGBA:
-   case PIPE_FORMAT_DXT3_RGBA:
-   case PIPE_FORMAT_DXT5_RGBA:
-      return SVGA3D_A8R8G8B8;
-#endif
-
-   default:
-      return SVGA3D_FORMAT_INVALID;
-   }
-}
-
-
-static INLINE void
-svga_transfer_dma_band(struct svga_transfer *st,
-                       SVGA3dTransferType transfer,
-                       unsigned y, unsigned h, unsigned srcy)
-{
-   struct svga_texture *texture = svga_texture(st->base.texture); 
-   struct svga_screen *screen = svga_screen(texture->base.screen);
-   SVGA3dCopyBox box;
-   enum pipe_error ret;
-   
-   SVGA_DBG(DEBUG_DMA, "dma %s sid %p, face %u, (%u, %u, %u) - (%u, %u, %u), %ubpp\n",
-                transfer == SVGA3D_WRITE_HOST_VRAM ? "to" : "from", 
-                texture->handle,
-                st->base.face,
-                st->base.x,
-                y,
-                st->base.zslice,
-                st->base.x + st->base.width,
-                y + h,
-                st->base.zslice + 1,
-                util_format_get_blocksize(texture->base.format)*8/
-                (util_format_get_blockwidth(texture->base.format)*util_format_get_blockheight(texture->base.format)));
-   
-   box.x = st->base.x;
-   box.y = y;
-   box.z = st->base.zslice;
-   box.w = st->base.width;
-   box.h = h;
-   box.d = 1;
-   box.srcx = 0;
-   box.srcy = srcy;
-   box.srcz = 0;
-
-   pipe_mutex_lock(screen->swc_mutex);
-   ret = SVGA3D_SurfaceDMA(screen->swc, st, transfer, &box, 1);
-   if(ret != PIPE_OK) {
-      screen->swc->flush(screen->swc, NULL);
-      ret = SVGA3D_SurfaceDMA(screen->swc, st, transfer, &box, 1);
-      assert(ret == PIPE_OK);
-   }
-   pipe_mutex_unlock(screen->swc_mutex);
-}
-
-
-static INLINE void
-svga_transfer_dma(struct svga_transfer *st,
-                 SVGA3dTransferType transfer)
-{
-   struct svga_texture *texture = svga_texture(st->base.texture); 
-   struct svga_screen *screen = svga_screen(texture->base.screen);
-   struct svga_winsys_screen *sws = screen->sws;
-   struct pipe_fence_handle *fence = NULL;
-   
-   if (transfer == SVGA3D_READ_HOST_VRAM) {
-      SVGA_DBG(DEBUG_PERF, "%s: readback transfer\n", __FUNCTION__);
-   }
-
-
-   if(!st->swbuf) {
-      /* Do the DMA transfer in a single go */
-      
-      svga_transfer_dma_band(st, transfer, st->base.y, st->base.height, 0);
-
-      if(transfer == SVGA3D_READ_HOST_VRAM) {
-         svga_screen_flush(screen, &fence);
-         sws->fence_finish(sws, fence, 0);
-         sws->fence_reference(sws, &fence, NULL);
-      }
-   }
-   else {
-      unsigned y, h, srcy;
-      unsigned blockheight = util_format_get_blockheight(st->base.texture->format);
-      h = st->hw_nblocksy * blockheight;
-      srcy = 0;
-      for(y = 0; y < st->base.height; y += h) {
-         unsigned offset, length;
-         void *hw, *sw;
-
-         if (y + h > st->base.height)
-            h = st->base.height - y;
-
-         /* Transfer band must be aligned to pixel block boundaries */
-         assert(y % blockheight == 0);
-         assert(h % blockheight == 0);
-         
-         offset = y * st->base.stride / blockheight;
-         length = h * st->base.stride / blockheight;
-
-         sw = (uint8_t *)st->swbuf + offset;
-         
-         if(transfer == SVGA3D_WRITE_HOST_VRAM) {
-            /* Wait for the previous DMAs to complete */
-            /* TODO: keep one DMA (at half the size) in the background */
-            if(y) {
-               svga_screen_flush(screen, &fence);
-               sws->fence_finish(sws, fence, 0);
-               sws->fence_reference(sws, &fence, NULL);
-            }
-
-            hw = sws->buffer_map(sws, st->hwbuf, PIPE_BUFFER_USAGE_CPU_WRITE);
-            assert(hw);
-            if(hw) {
-               memcpy(hw, sw, length);
-               sws->buffer_unmap(sws, st->hwbuf);
-            }
-         }
-         
-         svga_transfer_dma_band(st, transfer, y, h, srcy);
-         
-         if(transfer == SVGA3D_READ_HOST_VRAM) {
-            svga_screen_flush(screen, &fence);
-            sws->fence_finish(sws, fence, 0);
-
-            hw = sws->buffer_map(sws, st->hwbuf, PIPE_BUFFER_USAGE_CPU_READ);
-            assert(hw);
-            if(hw) {
-               memcpy(sw, hw, length);
-               sws->buffer_unmap(sws, st->hwbuf);
-            }
-         }
-      }
-   }
-}
-
-
-static struct pipe_texture *
-svga_texture_create(struct pipe_screen *screen,
-                    const struct pipe_texture *templat)
-{
-   struct svga_screen *svgascreen = svga_screen(screen);
-   struct svga_texture *tex = CALLOC_STRUCT(svga_texture);
-   unsigned width, height, depth;
-   unsigned level;
-   
-   if (!tex)
-      goto error1;
-
-   tex->base = *templat;
-   pipe_reference_init(&tex->base.reference, 1);
-   tex->base.screen = screen;
-
-   assert(templat->last_level < SVGA_MAX_TEXTURE_LEVELS);
-   if(templat->last_level >= SVGA_MAX_TEXTURE_LEVELS)
-      goto error2;
-   
-   width = templat->width0;
-   height = templat->height0;
-   depth = templat->depth0;
-   for(level = 0; level <= templat->last_level; ++level) {
-      width = u_minify(width, 1);
-      height = u_minify(height, 1);
-      depth = u_minify(depth, 1);
-   }
-   
-   tex->key.flags = 0;
-   tex->key.size.width = templat->width0;
-   tex->key.size.height = templat->height0;
-   tex->key.size.depth = templat->depth0;
-   
-   if(templat->target == PIPE_TEXTURE_CUBE) {
-      tex->key.flags |= SVGA3D_SURFACE_CUBEMAP;
-      tex->key.numFaces = 6;
-   }
-   else {
-      tex->key.numFaces = 1;
-   }
-
-   tex->key.cachable = 1;
-
-   if(templat->tex_usage & PIPE_TEXTURE_USAGE_SAMPLER)
-      tex->key.flags |= SVGA3D_SURFACE_HINT_TEXTURE;
-
-   if(templat->tex_usage & PIPE_TEXTURE_USAGE_DISPLAY_TARGET) {
-      tex->key.cachable = 0;
-   }
-
-   if(templat->tex_usage & PIPE_TEXTURE_USAGE_SHARED) {
-      tex->key.cachable = 0;
-   }
-
-   if(templat->tex_usage & PIPE_TEXTURE_USAGE_SCANOUT) {
-      tex->key.flags |= SVGA3D_SURFACE_HINT_SCANOUT;
-      tex->key.cachable = 0;
-   }
-   
-   /* 
-    * XXX: Never pass the SVGA3D_SURFACE_HINT_RENDERTARGET hint. Mesa cannot
-    * know beforehand whether a texture will be used as a rendertarget or not
-    * and it always requests PIPE_TEXTURE_USAGE_RENDER_TARGET, therefore
-    * passing the SVGA3D_SURFACE_HINT_RENDERTARGET here defeats its purpose.
-    */
-#if 0
-   if((templat->tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET) &&
-      !util_format_is_s3tc(templat->format))
-      tex->key.flags |= SVGA3D_SURFACE_HINT_RENDERTARGET;
-#endif
-   
-   if(templat->tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL)
-      tex->key.flags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
-   
-   tex->key.numMipLevels = templat->last_level + 1;
-   
-   tex->key.format = svga_translate_format(templat->format);
-   if(tex->key.format == SVGA3D_FORMAT_INVALID)
-      goto error2;
-
-   SVGA_DBG(DEBUG_DMA, "surface_create for texture\n", tex->handle);
-   tex->handle = svga_screen_surface_create(svgascreen, &tex->key);
-   if (tex->handle)
-      SVGA_DBG(DEBUG_DMA, "  --> got sid %p (texture)\n", tex->handle);
-
-   return &tex->base;
-
-error2:
-   FREE(tex);
-error1:
-   return NULL;
-}
-
-
-
-
-
-static struct pipe_texture *
-svga_screen_texture_from_handle(struct pipe_screen *screen,
-                                const struct pipe_texture *base,
-                                struct winsys_handle *whandle)
-{
-   struct svga_winsys_screen *sws = svga_winsys_screen(screen);
-   struct svga_winsys_surface *srf;
-   struct svga_texture *tex;
-   enum SVGA3dSurfaceFormat format = 0;
-   assert(screen);
-
-   /* Only supports one type */
-   if (base->target != PIPE_TEXTURE_2D ||
-       base->last_level != 0 ||
-       base->depth0 != 1) {
-      return NULL;
-   }
-
-   srf = sws->surface_from_handle(sws, whandle, &format);
-
-   if (!srf)
-      return NULL;
-
-   if (svga_translate_format(base->format) != format) {
-      unsigned f1 = svga_translate_format(base->format);
-      unsigned f2 = format;
-
-      /* It's okay for XRGB and ARGB or depth with/out stencil to get mixed up */
-      if ( !( (f1 == SVGA3D_X8R8G8B8 && f2 == SVGA3D_A8R8G8B8) ||
-              (f1 == SVGA3D_A8R8G8B8 && f2 == SVGA3D_X8R8G8B8) ||
-              (f1 == SVGA3D_Z_D24X8 && f2 == SVGA3D_Z_D24S8) ) ) {
-         debug_printf("%s wrong format %u != %u\n", __FUNCTION__, f1, f2);
-         return NULL;
-      }
-   }
-
-   tex = CALLOC_STRUCT(svga_texture);
-   if (!tex)
-      return NULL;
-
-   tex->base = *base;
-   
-
-   if (format == 1)
-      tex->base.format = PIPE_FORMAT_B8G8R8X8_UNORM;
-   else if (format == 2)
-      tex->base.format = PIPE_FORMAT_B8G8R8A8_UNORM;
-
-   pipe_reference_init(&tex->base.reference, 1);
-   tex->base.screen = screen;
-
-   SVGA_DBG(DEBUG_DMA, "wrap surface sid %p\n", srf);
-
-   tex->key.cachable = 0;
-   tex->handle = srf;
-
-   return &tex->base;
-}
-
-
-static boolean 
-svga_screen_texture_get_handle(struct pipe_screen *screen,
-                               struct pipe_texture *texture,
-                               struct winsys_handle *whandle)
-{
-   struct svga_winsys_screen *sws = svga_winsys_screen(texture->screen);
-   unsigned stride;
-
-   assert(svga_texture(texture)->key.cachable == 0);
-   svga_texture(texture)->key.cachable = 0;
-   stride = util_format_get_nblocksx(texture->format, texture->width0) *
-            util_format_get_blocksize(texture->format);
-   return sws->surface_get_handle(sws, svga_texture(texture)->handle, stride, whandle);
-}
-
-
-static void
-svga_texture_destroy(struct pipe_texture *pt)
-{
-   struct svga_screen *ss = svga_screen(pt->screen);
-   struct svga_texture *tex = (struct svga_texture *)pt;
-
-   ss->texture_timestamp++;
-
-   svga_sampler_view_reference(&tex->cached_view, NULL);
-
-   /*
-     DBG("%s deleting %p\n", __FUNCTION__, (void *) tex);
-   */
-   SVGA_DBG(DEBUG_DMA, "unref sid %p (texture)\n", tex->handle);
-   svga_screen_surface_destroy(ss, &tex->key, &tex->handle);
-
-   FREE(tex);
-}
-
-
-static void
-svga_texture_copy_handle(struct svga_context *svga,
-                         struct svga_screen *ss,
-                         struct svga_winsys_surface *src_handle,
-                         unsigned src_x, unsigned src_y, unsigned src_z,
-                         unsigned src_level, unsigned src_face,
-                         struct svga_winsys_surface *dst_handle,
-                         unsigned dst_x, unsigned dst_y, unsigned dst_z,
-                         unsigned dst_level, unsigned dst_face,
-                         unsigned width, unsigned height, unsigned depth)
-{
-   struct svga_surface dst, src;
-   enum pipe_error ret;
-   SVGA3dCopyBox box, *boxes;
-
-   assert(svga || ss);
-
-   src.handle = src_handle;
-   src.real_level = src_level;
-   src.real_face = src_face;
-   src.real_zslice = 0;
-
-   dst.handle = dst_handle;
-   dst.real_level = dst_level;
-   dst.real_face = dst_face;
-   dst.real_zslice = 0;
-
-   box.x = dst_x;
-   box.y = dst_y;
-   box.z = dst_z;
-   box.w = width;
-   box.h = height;
-   box.d = depth;
-   box.srcx = src_x;
-   box.srcy = src_y;
-   box.srcz = src_z;
-
-/*
-   SVGA_DBG(DEBUG_VIEWS, "mipcopy src: %p %u (%ux%ux%u), dst: %p %u (%ux%ux%u)\n",
-            src_handle, src_level, src_x, src_y, src_z,
-            dst_handle, dst_level, dst_x, dst_y, dst_z);
-*/
-
-   if (svga) {
-      ret = SVGA3D_BeginSurfaceCopy(svga->swc,
-                                    &src.base,
-                                    &dst.base,
-                                    &boxes, 1);
-      if(ret != PIPE_OK) {
-         svga_context_flush(svga, NULL);
-         ret = SVGA3D_BeginSurfaceCopy(svga->swc,
-                                       &src.base,
-                                       &dst.base,
-                                       &boxes, 1);
-         assert(ret == PIPE_OK);
-      }
-      *boxes = box;
-      SVGA_FIFOCommitAll(svga->swc);
-   } else {
-      pipe_mutex_lock(ss->swc_mutex);
-      ret = SVGA3D_BeginSurfaceCopy(ss->swc,
-                                    &src.base,
-                                    &dst.base,
-                                    &boxes, 1);
-      if(ret != PIPE_OK) {
-         ss->swc->flush(ss->swc, NULL);
-         ret = SVGA3D_BeginSurfaceCopy(ss->swc,
-                                       &src.base,
-                                       &dst.base,
-                                       &boxes, 1);
-         assert(ret == PIPE_OK);
-      }
-      *boxes = box;
-      SVGA_FIFOCommitAll(ss->swc);
-      pipe_mutex_unlock(ss->swc_mutex);
-   }
-}
-
-static struct svga_winsys_surface *
-svga_texture_view_surface(struct pipe_context *pipe,
-                          struct svga_texture *tex,
-                          SVGA3dSurfaceFormat format,
-                          unsigned start_mip,
-                          unsigned num_mip,
-                          int face_pick,
-                          int zslice_pick,
-                          struct svga_host_surface_cache_key *key) /* OUT */
-{
-   struct svga_screen *ss = svga_screen(tex->base.screen);
-   struct svga_winsys_surface *handle;
-   uint32_t i, j;
-   unsigned z_offset = 0;
-
-   SVGA_DBG(DEBUG_PERF, 
-            "svga: Create surface view: face %d zslice %d mips %d..%d\n",
-            face_pick, zslice_pick, start_mip, start_mip+num_mip-1);
-
-   key->flags = 0;
-   key->format = format;
-   key->numMipLevels = num_mip;
-   key->size.width = u_minify(tex->base.width0, start_mip);
-   key->size.height = u_minify(tex->base.height0, start_mip);
-   key->size.depth = zslice_pick < 0 ? u_minify(tex->base.depth0, start_mip) : 1;
-   key->cachable = 1;
-   assert(key->size.depth == 1);
-   
-   if(tex->base.target == PIPE_TEXTURE_CUBE && face_pick < 0) {
-      key->flags |= SVGA3D_SURFACE_CUBEMAP;
-      key->numFaces = 6;
-   } else {
-      key->numFaces = 1;
-   }
-
-   if(key->format == SVGA3D_FORMAT_INVALID) {
-      key->cachable = 0;
-      return NULL;
-   }
-
-   SVGA_DBG(DEBUG_DMA, "surface_create for texture view\n");
-   handle = svga_screen_surface_create(ss, key);
-   if (!handle) {
-      key->cachable = 0;
-      return NULL;
-   }
-
-   SVGA_DBG(DEBUG_DMA, " --> got sid %p (texture view)\n", handle);
-
-   if (face_pick < 0)
-      face_pick = 0;
-
-   if (zslice_pick >= 0)
-       z_offset = zslice_pick;
-
-   for (i = 0; i < key->numMipLevels; i++) {
-      for (j = 0; j < key->numFaces; j++) {
-         if(tex->defined[j + face_pick][i + start_mip]) {
-            unsigned depth = (zslice_pick < 0 ?
-                              u_minify(tex->base.depth0, i + start_mip) :
-                              1);
-
-            svga_texture_copy_handle(svga_context(pipe),
-                                     ss,
-                                     tex->handle, 
-                                     0, 0, z_offset, 
-                                     i + start_mip, 
-                                     j + face_pick,
-                                     handle, 0, 0, 0, i, j,
-                                     u_minify(tex->base.width0, i + start_mip),
-                                     u_minify(tex->base.height0, i + start_mip),
-                                     depth);
-         }
-      }
-   }
-
-   return handle;
-}
-
-
-static struct pipe_surface *
-svga_get_tex_surface(struct pipe_screen *screen,
-                     struct pipe_texture *pt,
-                     unsigned face, unsigned level, unsigned zslice,
-                     unsigned flags)
-{
-   struct svga_texture *tex = svga_texture(pt);
-   struct svga_surface *s;
-   boolean render = flags & PIPE_BUFFER_USAGE_GPU_WRITE ? TRUE : FALSE;
-   boolean view = FALSE;
-   SVGA3dSurfaceFormat format;
-
-   s = CALLOC_STRUCT(svga_surface);
-   if (!s)
-      return NULL;
-
-   pipe_reference_init(&s->base.reference, 1);
-   pipe_texture_reference(&s->base.texture, pt);
-   s->base.format = pt->format;
-   s->base.width = u_minify(pt->width0, level);
-   s->base.height = u_minify(pt->height0, level);
-   s->base.usage = flags;
-   s->base.level = level;
-   s->base.face = face;
-   s->base.zslice = zslice;
-
-   if (!render)
-      format = svga_translate_format(pt->format);
-   else
-      format = svga_translate_format_render(pt->format);
-
-   assert(format != SVGA3D_FORMAT_INVALID);
-   assert(!(flags & PIPE_BUFFER_USAGE_CPU_READ_WRITE));
-
-
-   if (svga_screen(screen)->debug.force_surface_view)
-      view = TRUE;
-
-   /* Currently only used for compressed textures */
-   if (render && 
-       format != svga_translate_format(pt->format)) {
-      view = TRUE;
-   }
-
-   if (level != 0 && 
-       svga_screen(screen)->debug.force_level_surface_view)
-      view = TRUE;
-
-   if (pt->target == PIPE_TEXTURE_3D)
-      view = TRUE;
-
-   if (svga_screen(screen)->debug.no_surface_view)
-      view = FALSE;
-
-   if (view) {
-      SVGA_DBG(DEBUG_VIEWS, "svga: Surface view: yes %p, level %u face %u z %u, %p\n",
-               pt, level, face, zslice, s);
-
-      s->handle = svga_texture_view_surface(NULL, tex, format, level, 1, face, zslice,
-                                            &s->key);
-      s->real_face = 0;
-      s->real_level = 0;
-      s->real_zslice = 0;
-   } else {
-      SVGA_DBG(DEBUG_VIEWS, "svga: Surface view: no %p, level %u, face %u, z %u, %p\n",
-               pt, level, face, zslice, s);
-
-      memset(&s->key, 0, sizeof s->key);
-      s->handle = tex->handle;
-      s->real_face = face;
-      s->real_level = level;
-      s->real_zslice = zslice;
-   }
-
-   return &s->base;
-}
-
-
-static void
-svga_tex_surface_destroy(struct pipe_surface *surf)
-{
-   struct svga_surface *s = svga_surface(surf);
-   struct svga_texture *t = svga_texture(surf->texture);
-   struct svga_screen *ss = svga_screen(surf->texture->screen);
-
-   if(s->handle != t->handle) {
-      SVGA_DBG(DEBUG_DMA, "unref sid %p (tex surface)\n", s->handle);
-      svga_screen_surface_destroy(ss, &s->key, &s->handle);
-   }
-
-   pipe_texture_reference(&surf->texture, NULL);
-   FREE(surf);
-}
-
-
-static INLINE void 
-svga_mark_surface_dirty(struct pipe_surface *surf)
-{
-   struct svga_surface *s = svga_surface(surf);
-
-   if(!s->dirty) {
-      struct svga_texture *tex = svga_texture(surf->texture);
-
-      s->dirty = TRUE;
-
-      if (s->handle == tex->handle)
-         tex->defined[surf->face][surf->level] = TRUE;
-      else {
-         /* this will happen later in svga_propagate_surface */
-      }
-   }
-}
-
-
-void svga_mark_surfaces_dirty(struct svga_context *svga)
-{
-   unsigned i;
-
-   for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
-      if (svga->curr.framebuffer.cbufs[i])
-         svga_mark_surface_dirty(svga->curr.framebuffer.cbufs[i]);
-   }
-   if (svga->curr.framebuffer.zsbuf)
-      svga_mark_surface_dirty(svga->curr.framebuffer.zsbuf);
-}
-
-/**
- * Progagate any changes from surfaces to texture.
- * pipe is optional context to inline the blit command in.
- */
-void
-svga_propagate_surface(struct pipe_context *pipe, struct pipe_surface *surf)
-{
-   struct svga_surface *s = svga_surface(surf);
-   struct svga_texture *tex = svga_texture(surf->texture);
-   struct svga_screen *ss = svga_screen(surf->texture->screen);
-
-   if (!s->dirty)
-      return;
-
-   s->dirty = FALSE;
-   ss->texture_timestamp++;
-   tex->view_age[surf->level] = ++(tex->age);
-
-   if (s->handle != tex->handle) {
-      SVGA_DBG(DEBUG_VIEWS, "svga: Surface propagate: tex %p, level %u, from %p\n", tex, surf->level, surf);
-      svga_texture_copy_handle(svga_context(pipe), ss,
-                               s->handle, 0, 0, 0, s->real_level, s->real_face,
-                               tex->handle, 0, 0, surf->zslice, surf->level, surf->face,
-                               u_minify(tex->base.width0, surf->level),
-                               u_minify(tex->base.height0, surf->level), 1);
-      tex->defined[surf->face][surf->level] = TRUE;
-   }
-}
-
-/**
- * Check if we should call svga_propagate_surface on the surface.
- */
-extern boolean
-svga_surface_needs_propagation(struct pipe_surface *surf)
-{
-   struct svga_surface *s = svga_surface(surf);
-   struct svga_texture *tex = svga_texture(surf->texture);
-
-   return s->dirty && s->handle != tex->handle;
-}
-
-/* XXX: Still implementing this as if it was a screen function, but
- * can now modify it to queue transfers on the context.
- */
-static struct pipe_transfer *
-svga_get_tex_transfer(struct pipe_context *pipe,
-		      struct pipe_texture *texture,
-		      unsigned face, unsigned level, unsigned zslice,
-		      enum pipe_transfer_usage usage, unsigned x, unsigned y,
-		      unsigned w, unsigned h)
-{
-   struct svga_screen *ss = svga_screen(pipe->screen);
-   struct svga_winsys_screen *sws = ss->sws;
-   struct svga_transfer *st;
-   unsigned nblocksx = util_format_get_nblocksx(texture->format, w);
-   unsigned nblocksy = util_format_get_nblocksy(texture->format, h);
-
-   /* We can't map texture storage directly */
-   if (usage & PIPE_TRANSFER_MAP_DIRECTLY)
-      return NULL;
-
-   st = CALLOC_STRUCT(svga_transfer);
-   if (!st)
-      return NULL;
-   
-   st->base.x = x;
-   st->base.y = y;
-   st->base.width = w;
-   st->base.height = h;
-   st->base.stride = nblocksx*util_format_get_blocksize(texture->format);
-   st->base.usage = usage;
-   st->base.face = face;
-   st->base.level = level;
-   st->base.zslice = zslice;
-
-   st->hw_nblocksy = nblocksy;
-   
-   st->hwbuf = svga_winsys_buffer_create(ss, 
-                                         1, 
-                                         0,
-                                         st->hw_nblocksy*st->base.stride);
-   while(!st->hwbuf && (st->hw_nblocksy /= 2)) {
-      st->hwbuf = svga_winsys_buffer_create(ss, 
-                                            1, 
-                                            0,
-                                            st->hw_nblocksy*st->base.stride);
-   }
-
-   if(!st->hwbuf)
-      goto no_hwbuf;
-
-   if(st->hw_nblocksy < nblocksy) {
-      /* We couldn't allocate a hardware buffer big enough for the transfer, 
-       * so allocate regular malloc memory instead */
-      debug_printf("%s: failed to allocate %u KB of DMA, splitting into %u x %u KB DMA transfers\n",
-                   __FUNCTION__,
-                   (nblocksy*st->base.stride + 1023)/1024,
-                   (nblocksy + st->hw_nblocksy - 1)/st->hw_nblocksy,
-                   (st->hw_nblocksy*st->base.stride + 1023)/1024);
-      st->swbuf = MALLOC(nblocksy*st->base.stride);
-      if(!st->swbuf)
-         goto no_swbuf;
-   }
-   
-   pipe_texture_reference(&st->base.texture, texture);
-
-   if (usage & PIPE_TRANSFER_READ)
-      svga_transfer_dma(st, SVGA3D_READ_HOST_VRAM);
-
-   return &st->base;
-
-no_swbuf:
-   sws->buffer_destroy(sws, st->hwbuf);
-no_hwbuf:
-   FREE(st);
-   return NULL;
-}
-
-
-/* XXX: Still implementing this as if it was a screen function, but
- * can now modify it to queue transfers on the context.
- */
-static void *
-svga_transfer_map( struct pipe_context *pipe,
-                   struct pipe_transfer *transfer )
-{
-   struct svga_screen *ss = svga_screen(pipe->screen);
-   struct svga_winsys_screen *sws = ss->sws;
-   struct svga_transfer *st = svga_transfer(transfer);
-
-   if(st->swbuf)
-      return st->swbuf;
-   else
-      /* The wait for read transfers already happened when svga_transfer_dma
-       * was called. */
-      return sws->buffer_map(sws, st->hwbuf,
-                             pipe_transfer_buffer_flags(transfer));
-}
-
-
-/* XXX: Still implementing this as if it was a screen function, but
- * can now modify it to queue transfers on the context.
- */
-static void
-svga_transfer_unmap(struct pipe_context *pipe,
-                    struct pipe_transfer *transfer)
-{
-   struct svga_screen *ss = svga_screen(pipe->screen);
-   struct svga_winsys_screen *sws = ss->sws;
-   struct svga_transfer *st = svga_transfer(transfer);
-   
-   if(!st->swbuf)
-      sws->buffer_unmap(sws, st->hwbuf);
-}
-
-
-static void
-svga_tex_transfer_destroy(struct pipe_context *pipe,
-                          struct pipe_transfer *transfer)
-{
-   struct svga_texture *tex = svga_texture(transfer->texture);
-   struct svga_screen *ss = svga_screen(pipe->screen);
-   struct svga_winsys_screen *sws = ss->sws;
-   struct svga_transfer *st = svga_transfer(transfer);
-
-   if (st->base.usage & PIPE_TRANSFER_WRITE) {
-      svga_transfer_dma(st, SVGA3D_WRITE_HOST_VRAM);
-      ss->texture_timestamp++;
-      tex->view_age[transfer->level] = ++(tex->age);
-      tex->defined[transfer->face][transfer->level] = TRUE;
-   }
-
-   pipe_texture_reference(&st->base.texture, NULL);
-   FREE(st->swbuf);
-   sws->buffer_destroy(sws, st->hwbuf);
-   FREE(st);
-}
-
-
-void
-svga_init_texture_functions(struct pipe_context *pipe)
-{
-   pipe->get_tex_transfer = svga_get_tex_transfer;
-   pipe->transfer_map = svga_transfer_map;
-   pipe->transfer_unmap = svga_transfer_unmap;
-   pipe->tex_transfer_destroy = svga_tex_transfer_destroy;
-}
-
-
-void
-svga_screen_init_texture_functions(struct pipe_screen *screen)
-{
-   screen->texture_create = svga_texture_create;
-   screen->texture_from_handle = svga_screen_texture_from_handle;
-   screen->texture_get_handle = svga_screen_texture_get_handle;
-   screen->texture_destroy = svga_texture_destroy;
-   screen->get_tex_surface = svga_get_tex_surface;
-   screen->tex_surface_destroy = svga_tex_surface_destroy;
-}
-
-/*********************************************************************** 
- */
-
-struct svga_sampler_view *
-svga_get_tex_sampler_view(struct pipe_context *pipe, struct pipe_texture *pt,
-                          unsigned min_lod, unsigned max_lod)
-{
-   struct svga_screen *ss = svga_screen(pt->screen);
-   struct svga_texture *tex = svga_texture(pt); 
-   struct svga_sampler_view *sv = NULL;
-   SVGA3dSurfaceFormat format = svga_translate_format(pt->format);
-   boolean view = TRUE;
-
-   assert(pt);
-   assert(min_lod >= 0);
-   assert(min_lod <= max_lod);
-   assert(max_lod <= pt->last_level);
-
-
-   /* Is a view needed */
-   {
-      /*
-       * Can't control max lod. For first level views and when we only
-       * look at one level we disable mip filtering to achive the same
-       * results as a view.
-       */
-      if (min_lod == 0 && max_lod >= pt->last_level)
-         view = FALSE;
-
-      if (util_format_is_s3tc(pt->format) && view) {
-         format = svga_translate_format_render(pt->format);
-      }
-
-      if (ss->debug.no_sampler_view)
-         view = FALSE;
-
-      if (ss->debug.force_sampler_view)
-         view = TRUE;
-   }
-
-   /* First try the cache */
-   if (view) {
-      pipe_mutex_lock(ss->tex_mutex);
-      if (tex->cached_view &&
-          tex->cached_view->min_lod == min_lod &&
-          tex->cached_view->max_lod == max_lod) {
-         svga_sampler_view_reference(&sv, tex->cached_view);
-         pipe_mutex_unlock(ss->tex_mutex);
-         SVGA_DBG(DEBUG_VIEWS, "svga: Sampler view: reuse %p, %u %u, last %u\n",
-                              pt, min_lod, max_lod, pt->last_level);
-         svga_validate_sampler_view(svga_context(pipe), sv);
-         return sv;
-      }
-      pipe_mutex_unlock(ss->tex_mutex);
-   }
-
-   sv = CALLOC_STRUCT(svga_sampler_view);
-   pipe_reference_init(&sv->reference, 1);
-   pipe_texture_reference(&sv->texture, pt);
-   sv->min_lod = min_lod;
-   sv->max_lod = max_lod;
-
-   /* No view needed just use the whole texture */
-   if (!view) {
-      SVGA_DBG(DEBUG_VIEWS,
-               "svga: Sampler view: no %p, mips %u..%u, nr %u, size (%ux%ux%u), last %u\n",
-               pt, min_lod, max_lod,
-               max_lod - min_lod + 1,
-               pt->width0,
-               pt->height0,
-               pt->depth0,
-               pt->last_level);
-      sv->key.cachable = 0;
-      sv->handle = tex->handle;
-      return sv;
-   }
-
-   SVGA_DBG(DEBUG_VIEWS,
-            "svga: Sampler view: yes %p, mips %u..%u, nr %u, size (%ux%ux%u), last %u\n",
-            pt, min_lod, max_lod,
-            max_lod - min_lod + 1,
-            pt->width0,
-            pt->height0,
-            pt->depth0,
-            pt->last_level);
-
-   sv->age = tex->age;
-   sv->handle = svga_texture_view_surface(pipe, tex, format,
-                                          min_lod,
-                                          max_lod - min_lod + 1,
-                                          -1, -1,
-                                          &sv->key);
-
-   if (!sv->handle) {
-      assert(0);
-      sv->key.cachable = 0;
-      sv->handle = tex->handle;
-      return sv;
-   }
-
-   pipe_mutex_lock(ss->tex_mutex);
-   svga_sampler_view_reference(&tex->cached_view, sv);
-   pipe_mutex_unlock(ss->tex_mutex);
-
-   return sv;
-}
-
-void
-svga_validate_sampler_view(struct svga_context *svga, struct svga_sampler_view *v)
-{
-   struct svga_texture *tex = svga_texture(v->texture);
-   unsigned numFaces;
-   unsigned age = 0;
-   int i, k;
-
-   assert(svga);
-
-   if (v->handle == tex->handle)
-      return;
-
-   age = tex->age;
-
-   if(tex->base.target == PIPE_TEXTURE_CUBE)
-      numFaces = 6;
-   else
-      numFaces = 1;
-
-   for (i = v->min_lod; i <= v->max_lod; i++) {
-      for (k = 0; k < numFaces; k++) {
-         if (v->age < tex->view_age[i])
-            svga_texture_copy_handle(svga, NULL,
-                                     tex->handle, 0, 0, 0, i, k,
-                                     v->handle, 0, 0, 0, i - v->min_lod, k,
-                                     u_minify(tex->base.width0, i),
-                                     u_minify(tex->base.height0, i),
-                                     u_minify(tex->base.depth0, i));
-      }
-   }
-
-   v->age = age;
-}
-
-void
-svga_destroy_sampler_view_priv(struct svga_sampler_view *v)
-{
-   struct svga_texture *tex = svga_texture(v->texture);
-
-   if(v->handle != tex->handle) {
-      struct svga_screen *ss = svga_screen(v->texture->screen);
-      SVGA_DBG(DEBUG_DMA, "unref sid %p (sampler view)\n", v->handle);
-      svga_screen_surface_destroy(ss, &v->key, &v->handle);
-   }
-   pipe_texture_reference(&v->texture, NULL);
-   FREE(v);
-}
diff --git a/src/gallium/drivers/svga/svga_state_constants.c b/src/gallium/drivers/svga/svga_state_constants.c
index 493f78a9908..97c818cd379 100644
--- a/src/gallium/drivers/svga/svga_state_constants.c
+++ b/src/gallium/drivers/svga/svga_state_constants.c
@@ -82,7 +82,7 @@ static int emit_consts( struct svga_context *svga,
                         int offset,
                         int unit )
 {
-   struct pipe_screen *screen = svga->pipe.screen;
+   struct pipe_transfer *transfer = NULL;
    unsigned count;
    const float (*data)[4] = NULL;
    unsigned i;
@@ -91,11 +91,12 @@ static int emit_consts( struct svga_context *svga,
    if (svga->curr.cb[unit] == NULL)
       goto done;
 
-   count = svga->curr.cb[unit]->size / (4 * sizeof(float));
+   count = svga->curr.cb[unit]->width0 / (4 * sizeof(float));
 
-   data = (const float (*)[4])pipe_buffer_map(screen,
+   data = (const float (*)[4])pipe_buffer_map(&svga->pipe,
                                               svga->curr.cb[unit],
-                                              PIPE_BUFFER_USAGE_CPU_READ);
+                                              PIPE_TRANSFER_READ,
+					      &transfer);
    if (data == NULL) {
       ret = PIPE_ERROR_OUT_OF_MEMORY;
       goto done;
@@ -109,7 +110,7 @@ static int emit_consts( struct svga_context *svga,
 
 done:
    if (data)
-      pipe_buffer_unmap(screen, svga->curr.cb[unit]);
+      pipe_buffer_unmap(&svga->pipe, svga->curr.cb[unit], transfer);
 
    return ret;
 }
@@ -137,7 +138,7 @@ static int emit_fs_consts( struct svga_context *svga,
 
       for (i = 0; i < key->num_textures; i++) {
          if (key->tex[i].unnormalized) {
-            struct pipe_texture *tex = svga->curr.sampler_views[i]->texture;
+            struct pipe_resource *tex = svga->curr.sampler_views[i]->texture;
             float data[4];
 
             data[0] = 1.0 / (float)tex->width0;
diff --git a/src/gallium/drivers/svga/svga_state_tss.c b/src/gallium/drivers/svga/svga_state_tss.c
index c08ec7c2e8c..76a2dae1435 100644
--- a/src/gallium/drivers/svga/svga_state_tss.c
+++ b/src/gallium/drivers/svga/svga_state_tss.c
@@ -27,7 +27,7 @@
 #include "pipe/p_defines.h"
 #include "util/u_math.h"
 
-#include "svga_screen_texture.h"
+#include "svga_sampler_view.h"
 #include "svga_winsys.h"
 #include "svga_context.h"
 #include "svga_state.h"
@@ -45,7 +45,7 @@ void svga_cleanup_tss_binding(struct svga_context *svga)
 
       svga_sampler_view_reference(&view->v, NULL);
       pipe_sampler_view_reference( &svga->curr.sampler_views[i], NULL );
-      pipe_texture_reference( &view->texture, NULL );
+      pipe_resource_reference( &view->texture, NULL );
 
       view->dirty = 1;
    }
@@ -77,7 +77,7 @@ update_tss_binding(struct svga_context *svga,
    for (i = 0; i < count; i++) {
       const struct svga_sampler_state *s = svga->curr.sampler[i];
       struct svga_hw_view_state *view = &svga->state.hw_draw.views[i];
-      struct pipe_texture *texture = NULL;
+      struct pipe_resource *texture = NULL;
 
       /* get min max lod */
       if (svga->curr.sampler_views[i]) {
@@ -94,7 +94,7 @@ update_tss_binding(struct svga_context *svga,
           view->max_lod != max_lod) {
 
          svga_sampler_view_reference(&view->v, NULL);
-         pipe_texture_reference( &view->texture, texture );
+         pipe_resource_reference( &view->texture, texture );
 
          view->dirty = TRUE;
          view->min_lod = min_lod;
@@ -135,7 +135,7 @@ update_tss_binding(struct svga_context *svga,
             svga->swc->surface_relocation(svga->swc,
                                           &ts[i].value,
                                           queue.bind[i].view->v->handle,
-                                          PIPE_BUFFER_USAGE_GPU_READ);
+                                          SVGA_RELOC_READ);
          }
          else {
             ts[i].value = SVGA3D_INVALID_ID;
diff --git a/src/gallium/drivers/svga/svga_state_vdecl.c b/src/gallium/drivers/svga/svga_state_vdecl.c
index f531e223048..3af7bf2b358 100644
--- a/src/gallium/drivers/svga/svga_state_vdecl.c
+++ b/src/gallium/drivers/svga/svga_state_vdecl.c
@@ -33,7 +33,7 @@
 #include "svga_draw.h"
 #include "svga_tgsi.h"
 #include "svga_screen.h"
-#include "svga_screen_buffer.h"
+#include "svga_resource_buffer.h"
 
 #include "svga_hw_reg.h"
 
@@ -59,8 +59,8 @@ upload_user_buffers( struct svga_context *svga )
          if (!buffer->uploaded.buffer) {
             ret = u_upload_buffer( svga->upload_vb,
                                    0,
-                                   buffer->base.size,
-                                   &buffer->base,
+                                   buffer->b.b.width0,
+                                   &buffer->b.b,
                                    &buffer->uploaded.offset,
                                    &buffer->uploaded.buffer );
             if (ret)
@@ -73,10 +73,10 @@ upload_user_buffers( struct svga_context *svga )
                             buffer,
                             buffer->uploaded.buffer,
                             buffer->uploaded.offset,
-                            buffer->base.size);
+                            buffer->b.b.width0);
          }
 
-         pipe_buffer_reference( &svga->curr.vb[i].buffer, buffer->uploaded.buffer );
+         pipe_resource_reference( &svga->curr.vb[i].buffer, buffer->uploaded.buffer );
          svga->curr.vb[i].buffer_offset = buffer->uploaded.offset;
       }
    }
diff --git a/src/gallium/drivers/svga/svga_state_vs.c b/src/gallium/drivers/svga/svga_state_vs.c
index 781f7bf5339..a6215c68cbe 100644
--- a/src/gallium/drivers/svga/svga_state_vs.c
+++ b/src/gallium/drivers/svga/svga_state_vs.c
@@ -190,9 +190,11 @@ static int update_zero_stride( struct svga_context *svga,
       const struct pipe_vertex_element *vel = &svga->curr.velems->velem[i];
       const struct pipe_vertex_buffer *vbuffer = &svga->curr.vb[
          vel->vertex_buffer_index];
+
       if (vbuffer->stride == 0) {
          unsigned const_idx =
             svga->curr.num_zero_stride_vertex_elements;
+	 struct pipe_transfer *transfer;
          struct translate *translate;
          struct translate_key key;
          void *mapped_buffer;
@@ -218,19 +220,23 @@ static int update_zero_stride( struct svga_context *svga,
 
          assert(vel->src_offset == 0);
          
-         mapped_buffer = pipe_buffer_map_range(svga->pipe.screen, 
+         mapped_buffer = pipe_buffer_map_range(&svga->pipe, 
                                                vbuffer->buffer,
                                                vel->src_offset,
                                                util_format_get_blocksize(vel->src_format),
-                                               PIPE_BUFFER_USAGE_CPU_READ);
+                                               PIPE_TRANSFER_READ,
+					       &transfer);
+
          translate->set_buffer(translate, vel->vertex_buffer_index,
                                mapped_buffer,
                                vbuffer->stride);
          translate->run(translate, 0, 1, 0,
                         svga->curr.zero_stride_constants);
 
-         pipe_buffer_unmap(svga->pipe.screen,
-                           vbuffer->buffer);
+         pipe_buffer_unmap(&svga->pipe,
+                           vbuffer->buffer,
+			   transfer);
+
          translate->release(translate);
       }
    }
diff --git a/src/gallium/drivers/svga/svga_surface.c b/src/gallium/drivers/svga/svga_surface.c
new file mode 100644
index 00000000000..dc1d9a850df
--- /dev/null
+++ b/src/gallium/drivers/svga/svga_surface.c
@@ -0,0 +1,381 @@
+/**********************************************************
+ * Copyright 2008-2009 VMware, Inc.  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, sublicense, 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 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
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * 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.
+ *
+ **********************************************************/
+
+#include "svga_cmd.h"
+
+#include "pipe/p_state.h"
+#include "pipe/p_defines.h"
+#include "util/u_inlines.h"
+#include "os/os_thread.h"
+#include "util/u_format.h"
+#include "util/u_math.h"
+#include "util/u_memory.h"
+
+#include "svga_screen.h"
+#include "svga_context.h"
+#include "svga_resource_texture.h"
+#include "svga_surface.h"
+#include "svga_winsys.h"
+#include "svga_debug.h"
+
+
+void
+svga_texture_copy_handle(struct svga_context *svga,
+                         struct svga_screen *ss,
+                         struct svga_winsys_surface *src_handle,
+                         unsigned src_x, unsigned src_y, unsigned src_z,
+                         unsigned src_level, unsigned src_face,
+                         struct svga_winsys_surface *dst_handle,
+                         unsigned dst_x, unsigned dst_y, unsigned dst_z,
+                         unsigned dst_level, unsigned dst_face,
+                         unsigned width, unsigned height, unsigned depth)
+{
+   struct svga_surface dst, src;
+   enum pipe_error ret;
+   SVGA3dCopyBox box, *boxes;
+
+   assert(svga || ss);
+
+   src.handle = src_handle;
+   src.real_level = src_level;
+   src.real_face = src_face;
+   src.real_zslice = 0;
+
+   dst.handle = dst_handle;
+   dst.real_level = dst_level;
+   dst.real_face = dst_face;
+   dst.real_zslice = 0;
+
+   box.x = dst_x;
+   box.y = dst_y;
+   box.z = dst_z;
+   box.w = width;
+   box.h = height;
+   box.d = depth;
+   box.srcx = src_x;
+   box.srcy = src_y;
+   box.srcz = src_z;
+
+/*
+   SVGA_DBG(DEBUG_VIEWS, "mipcopy src: %p %u (%ux%ux%u), dst: %p %u (%ux%ux%u)\n",
+            src_handle, src_level, src_x, src_y, src_z,
+            dst_handle, dst_level, dst_x, dst_y, dst_z);
+*/
+
+   if (svga) {
+      ret = SVGA3D_BeginSurfaceCopy(svga->swc,
+                                    &src.base,
+                                    &dst.base,
+                                    &boxes, 1);
+      if(ret != PIPE_OK) {
+         svga_context_flush(svga, NULL);
+         ret = SVGA3D_BeginSurfaceCopy(svga->swc,
+                                       &src.base,
+                                       &dst.base,
+                                       &boxes, 1);
+         assert(ret == PIPE_OK);
+      }
+      *boxes = box;
+      SVGA_FIFOCommitAll(svga->swc);
+   } else {
+      pipe_mutex_lock(ss->swc_mutex);
+      ret = SVGA3D_BeginSurfaceCopy(ss->swc,
+                                    &src.base,
+                                    &dst.base,
+                                    &boxes, 1);
+      if(ret != PIPE_OK) {
+         ss->swc->flush(ss->swc, NULL);
+         ret = SVGA3D_BeginSurfaceCopy(ss->swc,
+                                       &src.base,
+                                       &dst.base,
+                                       &boxes, 1);
+         assert(ret == PIPE_OK);
+      }
+      *boxes = box;
+      SVGA_FIFOCommitAll(ss->swc);
+      pipe_mutex_unlock(ss->swc_mutex);
+   }
+}
+
+
+struct svga_winsys_surface *
+svga_texture_view_surface(struct pipe_context *pipe,
+                          struct svga_texture *tex,
+                          SVGA3dSurfaceFormat format,
+                          unsigned start_mip,
+                          unsigned num_mip,
+                          int face_pick,
+                          int zslice_pick,
+                          struct svga_host_surface_cache_key *key) /* OUT */
+{
+   struct svga_screen *ss = svga_screen(pipe->screen);
+   struct svga_winsys_surface *handle;
+   uint32_t i, j;
+   unsigned z_offset = 0;
+
+   SVGA_DBG(DEBUG_PERF, 
+            "svga: Create surface view: face %d zslice %d mips %d..%d\n",
+            face_pick, zslice_pick, start_mip, start_mip+num_mip-1);
+
+   key->flags = 0;
+   key->format = format;
+   key->numMipLevels = num_mip;
+   key->size.width = u_minify(tex->b.b.width0, start_mip);
+   key->size.height = u_minify(tex->b.b.height0, start_mip);
+   key->size.depth = zslice_pick < 0 ? u_minify(tex->b.b.depth0, start_mip) : 1;
+   key->cachable = 1;
+   assert(key->size.depth == 1);
+   
+   if(tex->b.b.target == PIPE_TEXTURE_CUBE && face_pick < 0) {
+      key->flags |= SVGA3D_SURFACE_CUBEMAP;
+      key->numFaces = 6;
+   } else {
+      key->numFaces = 1;
+   }
+
+   if(key->format == SVGA3D_FORMAT_INVALID) {
+      key->cachable = 0;
+      return NULL;
+   }
+
+   SVGA_DBG(DEBUG_DMA, "surface_create for texture view\n");
+   handle = svga_screen_surface_create(ss, key);
+   if (!handle) {
+      key->cachable = 0;
+      return NULL;
+   }
+
+   SVGA_DBG(DEBUG_DMA, " --> got sid %p (texture view)\n", handle);
+
+   if (face_pick < 0)
+      face_pick = 0;
+
+   if (zslice_pick >= 0)
+       z_offset = zslice_pick;
+
+   for (i = 0; i < key->numMipLevels; i++) {
+      for (j = 0; j < key->numFaces; j++) {
+         if(tex->defined[j + face_pick][i + start_mip]) {
+            unsigned depth = (zslice_pick < 0 ?
+                              u_minify(tex->b.b.depth0, i + start_mip) :
+                              1);
+
+            svga_texture_copy_handle(svga_context(pipe),
+                                     ss,
+                                     tex->handle, 
+                                     0, 0, z_offset, 
+                                     i + start_mip, 
+                                     j + face_pick,
+                                     handle, 0, 0, 0, i, j,
+                                     u_minify(tex->b.b.width0, i + start_mip),
+                                     u_minify(tex->b.b.height0, i + start_mip),
+                                     depth);
+         }
+      }
+   }
+
+   return handle;
+}
+
+
+static struct pipe_surface *
+svga_get_tex_surface(struct pipe_screen *screen,
+                     struct pipe_resource *pt,
+                     unsigned face, unsigned level, unsigned zslice,
+                     unsigned flags)
+{
+   struct svga_texture *tex = svga_texture(pt);
+   struct svga_surface *s;
+   boolean render = (flags & (PIPE_BIND_RENDER_TARGET |
+			      PIPE_BIND_DEPTH_STENCIL)) ? TRUE : FALSE;
+   boolean view = FALSE;
+   SVGA3dSurfaceFormat format;
+
+   s = CALLOC_STRUCT(svga_surface);
+   if (!s)
+      return NULL;
+
+   pipe_reference_init(&s->base.reference, 1);
+   pipe_resource_reference(&s->base.texture, pt);
+   s->base.format = pt->format;
+   s->base.width = u_minify(pt->width0, level);
+   s->base.height = u_minify(pt->height0, level);
+   s->base.usage = flags;
+   s->base.level = level;
+   s->base.face = face;
+   s->base.zslice = zslice;
+
+   if (!render)
+      format = svga_translate_format(pt->format);
+   else
+      format = svga_translate_format_render(pt->format);
+
+   assert(format != SVGA3D_FORMAT_INVALID);
+
+   if (svga_screen(screen)->debug.force_surface_view)
+      view = TRUE;
+
+   /* Currently only used for compressed textures */
+   if (render && 
+       format != svga_translate_format(pt->format)) {
+      view = TRUE;
+   }
+
+   if (level != 0 && 
+       svga_screen(screen)->debug.force_level_surface_view)
+      view = TRUE;
+
+   if (pt->target == PIPE_TEXTURE_3D)
+      view = TRUE;
+
+   if (svga_screen(screen)->debug.no_surface_view)
+      view = FALSE;
+
+   if (view) {
+      SVGA_DBG(DEBUG_VIEWS, "svga: Surface view: yes %p, level %u face %u z %u, %p\n",
+               pt, level, face, zslice, s);
+
+      s->handle = svga_texture_view_surface(NULL, tex, format, level, 1, face, zslice,
+                                            &s->key);
+      s->real_face = 0;
+      s->real_level = 0;
+      s->real_zslice = 0;
+   } else {
+      SVGA_DBG(DEBUG_VIEWS, "svga: Surface view: no %p, level %u, face %u, z %u, %p\n",
+               pt, level, face, zslice, s);
+
+      memset(&s->key, 0, sizeof s->key);
+      s->handle = tex->handle;
+      s->real_face = face;
+      s->real_level = level;
+      s->real_zslice = zslice;
+   }
+
+   return &s->base;
+}
+
+
+static void
+svga_tex_surface_destroy(struct pipe_surface *surf)
+{
+   struct svga_surface *s = svga_surface(surf);
+   struct svga_texture *t = svga_texture(surf->texture);
+   struct svga_screen *ss = svga_screen(surf->texture->screen);
+
+   if(s->handle != t->handle) {
+      SVGA_DBG(DEBUG_DMA, "unref sid %p (tex surface)\n", s->handle);
+      svga_screen_surface_destroy(ss, &s->key, &s->handle);
+   }
+
+   pipe_resource_reference(&surf->texture, NULL);
+   FREE(surf);
+}
+
+
+static INLINE void 
+svga_mark_surface_dirty(struct pipe_surface *surf)
+{
+   struct svga_surface *s = svga_surface(surf);
+
+   if(!s->dirty) {
+      struct svga_texture *tex = svga_texture(surf->texture);
+
+      s->dirty = TRUE;
+
+      if (s->handle == tex->handle)
+         tex->defined[surf->face][surf->level] = TRUE;
+      else {
+         /* this will happen later in svga_propagate_surface */
+      }
+   }
+}
+
+
+void svga_mark_surfaces_dirty(struct svga_context *svga)
+{
+   unsigned i;
+
+   for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
+      if (svga->curr.framebuffer.cbufs[i])
+         svga_mark_surface_dirty(svga->curr.framebuffer.cbufs[i]);
+   }
+   if (svga->curr.framebuffer.zsbuf)
+      svga_mark_surface_dirty(svga->curr.framebuffer.zsbuf);
+}
+
+
+/**
+ * Progagate any changes from surfaces to texture.
+ * pipe is optional context to inline the blit command in.
+ */
+void
+svga_propagate_surface(struct pipe_context *pipe, struct pipe_surface *surf)
+{
+   struct svga_surface *s = svga_surface(surf);
+   struct svga_texture *tex = svga_texture(surf->texture);
+   struct svga_screen *ss = svga_screen(surf->texture->screen);
+
+   if (!s->dirty)
+      return;
+
+   s->dirty = FALSE;
+   ss->texture_timestamp++;
+   tex->view_age[surf->level] = ++(tex->age);
+
+   if (s->handle != tex->handle) {
+      SVGA_DBG(DEBUG_VIEWS, "svga: Surface propagate: tex %p, level %u, from %p\n", tex, surf->level, surf);
+      svga_texture_copy_handle(svga_context(pipe), ss,
+                               s->handle, 0, 0, 0, s->real_level, s->real_face,
+                               tex->handle, 0, 0, surf->zslice, surf->level, surf->face,
+                               u_minify(tex->b.b.width0, surf->level),
+                               u_minify(tex->b.b.height0, surf->level), 1);
+      tex->defined[surf->face][surf->level] = TRUE;
+   }
+}
+
+/**
+ * Check if we should call svga_propagate_surface on the surface.
+ */
+boolean
+svga_surface_needs_propagation(struct pipe_surface *surf)
+{
+   struct svga_surface *s = svga_surface(surf);
+   struct svga_texture *tex = svga_texture(surf->texture);
+
+   return s->dirty && s->handle != tex->handle;
+}
+
+
+
+
+
+
+void
+svga_screen_init_surface_functions(struct pipe_screen *screen)
+{
+   screen->get_tex_surface = svga_get_tex_surface;
+   screen->tex_surface_destroy = svga_tex_surface_destroy;
+}
+
diff --git a/src/gallium/drivers/svga/svga_surface.h b/src/gallium/drivers/svga/svga_surface.h
new file mode 100644
index 00000000000..b50ecdc9942
--- /dev/null
+++ b/src/gallium/drivers/svga/svga_surface.h
@@ -0,0 +1,97 @@
+/**********************************************************
+ * Copyright 2008-2009 VMware, Inc.  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, sublicense, 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 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
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * 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 SVGA_SURFACE_H
+#define SVGA_SURFACE_H
+
+
+#include "pipe/p_compiler.h"
+#include "pipe/p_state.h"
+#include "util/u_inlines.h"
+#include "svga_screen_cache.h"
+
+struct pipe_context;
+struct pipe_screen;
+struct svga_context;
+struct svga_texture;
+struct svga_winsys_surface;
+enum SVGA3dSurfaceFormat;
+
+
+struct svga_surface
+{
+   struct pipe_surface base;
+
+   struct svga_host_surface_cache_key key;
+   struct svga_winsys_surface *handle;
+
+   unsigned real_face;
+   unsigned real_level;
+   unsigned real_zslice;
+
+   boolean dirty;
+};
+
+
+extern void
+svga_propagate_surface(struct pipe_context *pipe, struct pipe_surface *surf);
+
+extern boolean
+svga_surface_needs_propagation(struct pipe_surface *surf);
+
+struct svga_winsys_surface *
+svga_texture_view_surface(struct pipe_context *pipe,
+                          struct svga_texture *tex,
+                          SVGA3dSurfaceFormat format,
+                          unsigned start_mip,
+                          unsigned num_mip,
+                          int face_pick,
+                          int zslice_pick,
+                          struct svga_host_surface_cache_key *key); /* OUT */
+
+
+void
+svga_texture_copy_handle(struct svga_context *svga,
+                         struct svga_screen *ss,
+                         struct svga_winsys_surface *src_handle,
+                         unsigned src_x, unsigned src_y, unsigned src_z,
+                         unsigned src_level, unsigned src_face,
+                         struct svga_winsys_surface *dst_handle,
+                         unsigned dst_x, unsigned dst_y, unsigned dst_z,
+                         unsigned dst_level, unsigned dst_face,
+                         unsigned width, unsigned height, unsigned depth);
+
+
+static INLINE struct svga_surface *
+svga_surface(struct pipe_surface *surface)
+{
+   assert(surface);
+   return (struct svga_surface *)surface;
+}
+
+void
+svga_screen_init_surface_functions(struct pipe_screen *screen);
+
+#endif
diff --git a/src/gallium/drivers/svga/svga_swtnl.h b/src/gallium/drivers/svga/svga_swtnl.h
index 4882f26b170..096ed410b5b 100644
--- a/src/gallium/drivers/svga/svga_swtnl.h
+++ b/src/gallium/drivers/svga/svga_swtnl.h
@@ -40,7 +40,7 @@ void svga_destroy_swtnl( struct svga_context *svga );
 
 enum pipe_error
 svga_swtnl_draw_range_elements(struct svga_context *svga,
-                               struct pipe_buffer *indexBuffer,
+                               struct pipe_resource *indexBuffer,
                                unsigned indexSize,
                                unsigned min_index,
                                unsigned max_index,
diff --git a/src/gallium/drivers/svga/svga_swtnl_backend.c b/src/gallium/drivers/svga/svga_swtnl_backend.c
index e9d7942fb57..e6498136083 100644
--- a/src/gallium/drivers/svga/svga_swtnl_backend.c
+++ b/src/gallium/drivers/svga/svga_swtnl_backend.c
@@ -79,21 +79,19 @@ svga_vbuf_render_allocate_vertices( struct vbuf_render *render,
       new_vbuf = TRUE;
 
    if (new_vbuf)
-      pipe_buffer_reference(&svga_render->vbuf, NULL);
+      pipe_resource_reference(&svga_render->vbuf, NULL);
    if (new_ibuf)
-      pipe_buffer_reference(&svga_render->ibuf, NULL);
+      pipe_resource_reference(&svga_render->ibuf, NULL);
 
    if (!svga_render->vbuf) {
       svga_render->vbuf_size = MAX2(size, svga_render->vbuf_alloc_size);
       svga_render->vbuf = pipe_buffer_create(screen,
-                                             16,
-                                             PIPE_BUFFER_USAGE_VERTEX,
+                                             PIPE_BIND_VERTEX_BUFFER,
                                              svga_render->vbuf_size);
       if(!svga_render->vbuf) {
          svga_context_flush(svga, NULL);
          svga_render->vbuf = pipe_buffer_create(screen,
-                                                16,
-                                                PIPE_BUFFER_USAGE_VERTEX,
+                                                PIPE_BIND_VERTEX_BUFFER,
                                                 svga_render->vbuf_size);
          assert(svga_render->vbuf);
       }
@@ -117,14 +115,14 @@ svga_vbuf_render_map_vertices( struct vbuf_render *render )
 {
    struct svga_vbuf_render *svga_render = svga_vbuf_render(render);
    struct svga_context *svga = svga_render->svga;
-   struct pipe_screen *screen = svga->pipe.screen;
 
-   char *ptr = (char*)pipe_buffer_map(screen,
+   char *ptr = (char*)pipe_buffer_map(&svga->pipe,
                                       svga_render->vbuf,
-                                      PIPE_BUFFER_USAGE_CPU_WRITE | 
-                                      PIPE_BUFFER_USAGE_FLUSH_EXPLICIT |
-                                      PIPE_BUFFER_USAGE_DISCARD |
-                                      PIPE_BUFFER_USAGE_UNSYNCHRONIZED);
+                                      PIPE_TRANSFER_WRITE | 
+                                      PIPE_TRANSFER_FLUSH_EXPLICIT |
+                                      PIPE_TRANSFER_DISCARD |
+                                      PIPE_TRANSFER_UNSYNCHRONIZED,
+				      &svga_render->vbuf_transfer);
    return ptr + svga_render->vbuf_offset;
 }
 
@@ -135,14 +133,15 @@ svga_vbuf_render_unmap_vertices( struct vbuf_render *render,
 {
    struct svga_vbuf_render *svga_render = svga_vbuf_render(render);
    struct svga_context *svga = svga_render->svga;
-   struct pipe_screen *screen = svga->pipe.screen;
    unsigned offset, length;
    size_t used = svga_render->vertex_size * ((size_t)max_index + 1);
 
    offset = svga_render->vbuf_offset + svga_render->vertex_size * min_index;
    length = svga_render->vertex_size * (max_index + 1 - min_index);
-   pipe_buffer_flush_mapped_range(screen, svga_render->vbuf, offset, length);
-   pipe_buffer_unmap(screen, svga_render->vbuf);
+   pipe_buffer_flush_mapped_range(&svga->pipe,
+				  svga_render->vbuf_transfer,
+				  offset, length);
+   pipe_buffer_unmap(&svga->pipe, svga_render->vbuf, svga_render->vbuf_transfer);
    svga_render->min_index = min_index;
    svga_render->max_index = max_index;
    svga_render->vbuf_used = MAX2(svga_render->vbuf_used, used);
@@ -255,19 +254,18 @@ svga_vbuf_render_draw( struct vbuf_render *render,
    assert(( svga_render->vbuf_offset - svga_render->vdecl_offset) % svga_render->vertex_size == 0);
    
    if (svga_render->ibuf_size < svga_render->ibuf_offset + size)
-      pipe_buffer_reference(&svga_render->ibuf, NULL);
+      pipe_resource_reference(&svga_render->ibuf, NULL);
 
    if (!svga_render->ibuf) {
       svga_render->ibuf_size = MAX2(size, svga_render->ibuf_alloc_size);
       svga_render->ibuf = pipe_buffer_create(screen,
-                                             2,
-                                             PIPE_BUFFER_USAGE_VERTEX,
+                                             PIPE_BIND_INDEX_BUFFER,
                                              svga_render->ibuf_size);
       svga_render->ibuf_offset = 0;
    }
 
-   pipe_buffer_write_nooverlap(screen, svga_render->ibuf,
-                                 svga_render->ibuf_offset, 2 * nr_indices, indices);
+   pipe_buffer_write_nooverlap(&svga->pipe, svga_render->ibuf,
+			       svga_render->ibuf_offset, 2 * nr_indices, indices);
 
 
    /* off to hardware */
@@ -315,8 +313,8 @@ svga_vbuf_render_destroy( struct vbuf_render *render )
 {
    struct svga_vbuf_render *svga_render = svga_vbuf_render(render);
 
-   pipe_buffer_reference(&svga_render->vbuf, NULL);
-   pipe_buffer_reference(&svga_render->ibuf, NULL);
+   pipe_resource_reference(&svga_render->vbuf, NULL);
+   pipe_resource_reference(&svga_render->ibuf, NULL);
    FREE(svga_render);
 }
 
diff --git a/src/gallium/drivers/svga/svga_swtnl_draw.c b/src/gallium/drivers/svga/svga_swtnl_draw.c
index da15be155c8..f771dd59d32 100644
--- a/src/gallium/drivers/svga/svga_swtnl_draw.c
+++ b/src/gallium/drivers/svga/svga_swtnl_draw.c
@@ -37,12 +37,15 @@
 
 enum pipe_error
 svga_swtnl_draw_range_elements(struct svga_context *svga,
-                               struct pipe_buffer *indexBuffer,
+                               struct pipe_resource *indexBuffer,
                                unsigned indexSize,
                                unsigned min_index,
                                unsigned max_index,
                                unsigned prim, unsigned start, unsigned count)
 {
+   struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
+   struct pipe_transfer *ib_transfer = NULL;
+   struct pipe_transfer *cb_transfer = NULL;
    struct draw_context *draw = svga->swtnl.draw;
    unsigned i;
    const void *map;
@@ -64,17 +67,19 @@ svga_swtnl_draw_range_elements(struct svga_context *svga,
     * Map vertex buffers
     */
    for (i = 0; i < svga->curr.num_vertex_buffers; i++) {
-      map = pipe_buffer_map(svga->pipe.screen,
+      map = pipe_buffer_map(&svga->pipe,
                             svga->curr.vb[i].buffer,
-                            PIPE_BUFFER_USAGE_CPU_READ);
+                            PIPE_TRANSFER_READ,
+			    &vb_transfer[i]);
 
       draw_set_mapped_vertex_buffer(draw, i, map);
    }
 
    /* Map index buffer, if present */
    if (indexBuffer) {
-      map = pipe_buffer_map(svga->pipe.screen, indexBuffer,
-                            PIPE_BUFFER_USAGE_CPU_READ);
+      map = pipe_buffer_map(&svga->pipe, indexBuffer,
+                            PIPE_TRANSFER_READ,
+			    &ib_transfer);
 
       draw_set_mapped_element_buffer_range(draw, 
                                            indexSize, 
@@ -84,14 +89,15 @@ svga_swtnl_draw_range_elements(struct svga_context *svga,
    }
    
    if (svga->curr.cb[PIPE_SHADER_VERTEX]) {
-      map = pipe_buffer_map(svga->pipe.screen,
+      map = pipe_buffer_map(&svga->pipe,
                             svga->curr.cb[PIPE_SHADER_VERTEX],
-                            PIPE_BUFFER_USAGE_CPU_READ);
+                            PIPE_TRANSFER_READ,
+			    &cb_transfer);
       assert(map);
       draw_set_mapped_constant_buffer(
          draw, PIPE_SHADER_VERTEX, 0,
          map,
-         svga->curr.cb[PIPE_SHADER_VERTEX]->size);
+         svga->curr.cb[PIPE_SHADER_VERTEX]->width0);
    }
 
    draw_arrays(svga->swtnl.draw, prim, start, count);
@@ -105,18 +111,20 @@ svga_swtnl_draw_range_elements(struct svga_context *svga,
     * unmap vertex/index buffers
     */
    for (i = 0; i < svga->curr.num_vertex_buffers; i++) {
-      pipe_buffer_unmap(svga->pipe.screen, svga->curr.vb[i].buffer);
+      pipe_buffer_unmap(&svga->pipe, svga->curr.vb[i].buffer, 
+			vb_transfer[i]);
       draw_set_mapped_vertex_buffer(draw, i, NULL);
    }
 
    if (indexBuffer) {
-      pipe_buffer_unmap(svga->pipe.screen, indexBuffer);
+      pipe_buffer_unmap(&svga->pipe, indexBuffer, ib_transfer);
       draw_set_mapped_element_buffer(draw, 0, NULL);
    }
 
    if (svga->curr.cb[PIPE_SHADER_VERTEX]) {
-      pipe_buffer_unmap(svga->pipe.screen,
-                        svga->curr.cb[PIPE_SHADER_VERTEX]);
+      pipe_buffer_unmap(&svga->pipe,
+                        svga->curr.cb[PIPE_SHADER_VERTEX],
+			cb_transfer);
    }
 
    return ret;
diff --git a/src/gallium/drivers/svga/svga_swtnl_private.h b/src/gallium/drivers/svga/svga_swtnl_private.h
index 9bbb42910f5..8d080708438 100644
--- a/src/gallium/drivers/svga/svga_swtnl_private.h
+++ b/src/gallium/drivers/svga/svga_swtnl_private.h
@@ -45,8 +45,10 @@ struct svga_vbuf_render {
 
    unsigned prim;
 
-   struct pipe_buffer *vbuf;
-   struct pipe_buffer *ibuf;
+   struct pipe_resource *vbuf;
+   struct pipe_resource *ibuf;
+   struct pipe_transfer *vbuf_transfer;
+   struct pipe_transfer *ibuf_transfer;
 
    /* current size of buffer */
    size_t vbuf_size;
diff --git a/src/gallium/drivers/svga/svga_winsys.h b/src/gallium/drivers/svga/svga_winsys.h
index d4bb176f9a8..3892addafd1 100644
--- a/src/gallium/drivers/svga/svga_winsys.h
+++ b/src/gallium/drivers/svga/svga_winsys.h
@@ -49,13 +49,18 @@ struct svga_winsys_buffer;
 struct pipe_screen;
 struct pipe_context;
 struct pipe_fence_handle;
-struct pipe_texture;
+struct pipe_resource;
 struct svga_region;
 struct winsys_handle;
 
 
-#define SVGA_BUFFER_USAGE_PINNED  (PIPE_BUFFER_USAGE_CUSTOM << 0)
-#define SVGA_BUFFER_USAGE_WRAPPED (PIPE_BUFFER_USAGE_CUSTOM << 1)
+#define SVGA_BUFFER_USAGE_PINNED  (1 << 0)
+#define SVGA_BUFFER_USAGE_WRAPPED (1 << 1)
+
+
+#define SVGA_RELOC_WRITE 0x1
+#define SVGA_RELOC_READ  0x2
+
 
 
 /** Opaque surface handle */
@@ -189,7 +194,7 @@ struct svga_winsys_screen
 
    /**
     * Creates a surface from a winsys handle.
-    * Used to implement pipe_screen::texture_from_handle.
+    * Used to implement pipe_screen::resource_from_handle.
     */
    struct svga_winsys_surface *
    (*surface_from_handle)(struct svga_winsys_screen *sws,
@@ -198,7 +203,7 @@ struct svga_winsys_screen
 
    /**
     * Get a winsys_handle from a surface.
-    * Used to implement pipe_screen::texture_get_handle.
+    * Used to implement pipe_screen::resource_get_handle.
     */
    boolean
    (*surface_get_handle)(struct svga_winsys_screen *sws,
@@ -225,13 +230,7 @@ struct svga_winsys_screen
    /**
     * Buffer management. Buffer attributes are mostly fixed over its lifetime.
     *
-    * Remember that gallium gets to choose the interface it needs, and the
-    * window systems must then implement that interface (rather than the
-    * other way around...).
-    *
-    * usage is a bitmask of PIPE_BUFFER_USAGE_PIXEL/VERTEX/INDEX/CONSTANT. This
-    * usage argument is only an optimization hint, not a guarantee, therefore 
-    * proper behavior must be observed in all circumstances.
+    * XXX usage seems to be a bitmask of SVGA_BUFFER_USAGE_* flags.
     *
     * alignment indicates the client's alignment requirements, eg for
     * SSE instructions.
@@ -245,9 +244,9 @@ struct svga_winsys_screen
    /** 
     * Map the entire data store of a buffer object into the client's address.
     * flags is a bitmask of:
-    * - PIPE_BUFFER_USAGE_CPU_READ/WRITE
-    * - PIPE_BUFFER_USAGE_DONTBLOCK
-    * - PIPE_BUFFER_USAGE_UNSYNCHRONIZED
+    * - PB_USAGE_CPU_READ/WRITE
+    * - PB_USAGE_DONTBLOCK
+    * - PB_USAGE_UNSYNCHRONIZED
     */
    void *
    (*buffer_map)( struct svga_winsys_screen *sws, 
@@ -298,12 +297,12 @@ svga_screen_create(struct svga_winsys_screen *sws);
 struct svga_winsys_screen *
 svga_winsys_screen(struct pipe_screen *screen);
 
-struct pipe_buffer *
+struct pipe_resource *
 svga_screen_buffer_wrap_surface(struct pipe_screen *screen,
 				enum SVGA3dSurfaceFormat format,
 				struct svga_winsys_surface *srf);
 
 struct svga_winsys_surface *
-svga_screen_buffer_get_winsys_surface(struct pipe_buffer *buffer);
+svga_screen_buffer_get_winsys_surface(struct pipe_resource *buffer);
 
 #endif /* SVGA_WINSYS_H_ */
diff --git a/src/gallium/drivers/sw/SConscript b/src/gallium/drivers/sw/SConscript
index 6fbbdf3cc46..37d0a0d63ce 100644
--- a/src/gallium/drivers/sw/SConscript
+++ b/src/gallium/drivers/sw/SConscript
@@ -12,22 +12,16 @@
 
 Import('*')
 
-if not set(('softpipe', 'llvmpipe', 'cell')).intersection(env['drivers']):
-    print 'warning: no supported pipe driver: skipping build of sw meta-driver'
-    Return()
-
 env = env.Clone()
 
-if 'softpipe' in env['drivers']:
+if True:
     env.Append(CPPDEFINES = 'GALLIUM_SOFTPIPE')
     env.Prepend(LIBS = [softpipe])
 
-if 'llvmpipe' in env['drivers']:
-    env.Tool('llvm')
-    if 'LLVM_VERSION' in env:
-        env.Append(CPPDEFINES = 'GALLIUM_LLVMPIPE')
-        env.Tool('udis86')
-        env.Prepend(LIBS = [llvmpipe])
+if env['llvm']:
+    env.Append(CPPDEFINES = 'GALLIUM_LLVMPIPE')
+    env.Tool('udis86')
+    env.Prepend(LIBS = [llvmpipe])
     
 if 'cell' in env['drivers']:
     env.Append(CPPDEFINES = 'GALLIUM_CELL')
diff --git a/src/gallium/drivers/trace/Makefile b/src/gallium/drivers/trace/Makefile
index dd6831c70ab..78f6347dc72 100644
--- a/src/gallium/drivers/trace/Makefile
+++ b/src/gallium/drivers/trace/Makefile
@@ -4,7 +4,6 @@ include $(TOP)/configs/current
 LIBNAME = trace
 
 C_SOURCES = \
-	tr_buffer.c \
 	tr_context.c \
 	tr_dump.c \
 	tr_dump_state.c \
diff --git a/src/gallium/drivers/trace/SConscript b/src/gallium/drivers/trace/SConscript
index c1675d1c165..5f1fb17966a 100644
--- a/src/gallium/drivers/trace/SConscript
+++ b/src/gallium/drivers/trace/SConscript
@@ -5,7 +5,6 @@ env = env.Clone()
 trace = env.ConvenienceLibrary(
     target = 'trace',
     source = [
-        'tr_buffer.c',
         'tr_context.c',
         'tr_drm.c',
         'tr_dump.c',
diff --git a/src/gallium/drivers/trace/tr_buffer.c b/src/gallium/drivers/trace/tr_buffer.c
deleted file mode 100644
index fa2ac068ebc..00000000000
--- a/src/gallium/drivers/trace/tr_buffer.c
+++ /dev/null
@@ -1,76 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.
- * 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.
- *
- **************************************************************************/
-
-
-#include "util/u_inlines.h"
-#include "util/u_memory.h"
-#include "util/u_simple_list.h"
-
-#include "tr_buffer.h"
-
-struct pipe_buffer *
-trace_buffer_create(struct trace_screen *tr_scr,
-                    struct pipe_buffer *buffer)
-{
-   struct trace_buffer *tr_buf;
-
-   if(!buffer)
-      goto error;
-
-   assert(buffer->screen == tr_scr->screen);
-
-   tr_buf = CALLOC_STRUCT(trace_buffer);
-   if(!tr_buf)
-      goto error;
-
-   memcpy(&tr_buf->base, buffer, sizeof(struct pipe_buffer));
-
-   pipe_reference_init(&tr_buf->base.reference, 1);
-   tr_buf->base.screen = &tr_scr->base;
-   tr_buf->buffer = buffer;
-
-   trace_screen_add_to_list(tr_scr, buffers, tr_buf);
-
-   return &tr_buf->base;
-
-error:
-   pipe_buffer_reference(&buffer, NULL);
-   return NULL;
-}
-
-
-void
-trace_buffer_destroy(struct trace_screen *tr_scr,
-                     struct pipe_buffer *buffer)
-{
-   struct trace_buffer *tr_buf = trace_buffer(buffer);
-
-   trace_screen_remove_from_list(tr_scr, buffers, tr_buf);
-
-   pipe_buffer_reference(&tr_buf->buffer, NULL);
-   FREE(tr_buf);
-}
diff --git a/src/gallium/drivers/trace/tr_buffer.h b/src/gallium/drivers/trace/tr_buffer.h
deleted file mode 100644
index 1a2d0b9aeae..00000000000
--- a/src/gallium/drivers/trace/tr_buffer.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.
- * 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 TR_BUFFER_H_
-#define TR_BUFFER_H_
-
-
-#include "pipe/p_compiler.h"
-#include "pipe/p_state.h"
-
-#include "tr_screen.h"
-
-
-struct trace_buffer
-{
-   struct pipe_buffer base;
-
-   struct pipe_buffer *buffer;
-
-   struct tr_list list;
-
-   void *map;
-   boolean range_flushed;
-};
-
-
-static INLINE struct trace_buffer *
-trace_buffer(struct pipe_buffer *buffer)
-{
-   if(!buffer)
-      return NULL;
-   (void)trace_screen(buffer->screen);
-   return (struct trace_buffer *)buffer;
-}
-
-
-struct pipe_buffer *
-trace_buffer_create(struct trace_screen *tr_scr,
-                    struct pipe_buffer *buffer);
-
-void
-trace_buffer_destroy(struct trace_screen *tr_scr,
-                     struct pipe_buffer *buffer);
-
-
-#endif
diff --git a/src/gallium/drivers/trace/tr_context.c b/src/gallium/drivers/trace/tr_context.c
index 5c24bd1f7df..512acb7d13c 100644
--- a/src/gallium/drivers/trace/tr_context.c
+++ b/src/gallium/drivers/trace/tr_context.c
@@ -36,43 +36,26 @@
 #include "tr_dump.h"
 #include "tr_dump_state.h"
 #include "tr_state.h"
-#include "tr_buffer.h"
 #include "tr_screen.h"
 #include "tr_texture.h"
 
 
-static INLINE struct pipe_buffer *
-trace_buffer_unwrap(struct trace_context *tr_ctx,
-                     struct pipe_buffer *buffer)
-{
-   struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
-   struct trace_buffer *tr_buf;
-
-   if(!buffer)
-      return NULL;
-
-   tr_buf = trace_buffer(buffer);
 
-   assert(tr_buf->buffer);
-   assert(tr_buf->buffer->screen == tr_scr->screen);
-   (void) tr_scr;
-   return tr_buf->buffer;
-}
 
 
-static INLINE struct pipe_texture *
-trace_texture_unwrap(struct trace_context *tr_ctx,
-                     struct pipe_texture *texture)
+static INLINE struct pipe_resource *
+trace_resource_unwrap(struct trace_context *tr_ctx,
+                     struct pipe_resource *resource)
 {
-   struct trace_texture *tr_tex;
+   struct trace_resource *tr_tex;
 
-   if(!texture)
+   if(!resource)
       return NULL;
 
-   tr_tex = trace_texture(texture);
+   tr_tex = trace_resource(resource);
 
-   assert(tr_tex->texture);
-   return tr_tex->texture;
+   assert(tr_tex->resource);
+   return tr_tex->resource;
 }
 
 
@@ -193,22 +176,20 @@ trace_context_draw_arrays(struct pipe_context *_pipe,
 
 static INLINE void
 trace_context_draw_elements(struct pipe_context *_pipe,
-                          struct pipe_buffer *_indexBuffer,
+                          struct pipe_resource *_indexBuffer,
                           unsigned indexSize,
                           unsigned mode, unsigned start, unsigned count)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
+   struct trace_resource *tr_buf = trace_resource(_indexBuffer);
    struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_buffer *indexBuffer = tr_buf->buffer;
+   struct pipe_resource *indexBuffer = tr_buf->resource;
 
    if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
       return;
 
    trace_context_draw_block(tr_ctx, 1);
 
-   trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
-
    trace_dump_call_begin("pipe_context", "draw_elements");
 
    trace_dump_arg(ptr, pipe);
@@ -228,7 +209,7 @@ trace_context_draw_elements(struct pipe_context *_pipe,
 
 static INLINE void
 trace_context_draw_range_elements(struct pipe_context *_pipe,
-                                  struct pipe_buffer *_indexBuffer,
+                                  struct pipe_resource *_indexBuffer,
                                   unsigned indexSize,
                                   unsigned minIndex,
                                   unsigned maxIndex,
@@ -237,17 +218,15 @@ trace_context_draw_range_elements(struct pipe_context *_pipe,
                                   unsigned count)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
+   struct trace_resource *tr_buf = trace_resource(_indexBuffer);
    struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_buffer *indexBuffer = tr_buf->buffer;
+   struct pipe_resource *indexBuffer = tr_buf->resource;
 
    if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
       return;
 
    trace_context_draw_block(tr_ctx, 1);
 
-   trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
-
    trace_dump_call_begin("pipe_context", "draw_range_elements");
 
    trace_dump_arg(ptr, pipe);
@@ -897,14 +876,13 @@ trace_context_set_clip_state(struct pipe_context *_pipe,
 static INLINE void
 trace_context_set_constant_buffer(struct pipe_context *_pipe,
                                   uint shader, uint index,
-                                  struct pipe_buffer *buffer)
+                                  struct pipe_resource *buffer)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
    struct pipe_context *pipe = tr_ctx->pipe;
 
    if (buffer) {
-      trace_screen_user_buffer_update(_pipe->screen, buffer);
-      buffer = trace_buffer_unwrap(tr_ctx, buffer);
+      buffer = trace_resource_unwrap(tr_ctx, buffer);
    }
 
    trace_dump_call_begin("pipe_context", "set_constant_buffer");
@@ -933,11 +911,11 @@ trace_context_set_framebuffer_state(struct pipe_context *_pipe,
       tr_ctx->curr.nr_cbufs = state->nr_cbufs;
       for (i = 0; i < state->nr_cbufs; i++)
          if (state->cbufs[i])
-            tr_ctx->curr.cbufs[i] = trace_texture(state->cbufs[i]->texture);
+            tr_ctx->curr.cbufs[i] = trace_resource(state->cbufs[i]->texture);
          else
             tr_ctx->curr.cbufs[i] = NULL;
       if (state->zsbuf)
-         tr_ctx->curr.zsbuf = trace_texture(state->zsbuf->texture);
+         tr_ctx->curr.zsbuf = trace_resource(state->zsbuf->texture);
       else
          tr_ctx->curr.zsbuf = NULL;
    }
@@ -1018,34 +996,41 @@ trace_context_set_viewport_state(struct pipe_context *_pipe,
 
 static struct pipe_sampler_view *
 trace_create_sampler_view(struct pipe_context *_pipe,
-                          struct pipe_texture *_texture,
+                          struct pipe_resource *_resource,
                           const struct pipe_sampler_view *templ)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_texture *tr_tex = trace_texture(_texture);
+   struct trace_resource *tr_tex = trace_resource(_resource);
    struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_texture *texture = tr_tex->texture;
-   struct trace_sampler_view *result = CALLOC_STRUCT(trace_sampler_view);
+   struct pipe_resource *texture = tr_tex->resource;
+   struct pipe_sampler_view *result;
+   struct trace_sampler_view *tr_view;
 
    trace_dump_call_begin("pipe_context", "create_sampler_view");
 
    trace_dump_arg(ptr, pipe);
    trace_dump_arg(ptr, texture);
-   trace_dump_arg(ptr, templ);
+   trace_dump_arg(sampler_view_template, templ);
 
-   result->sampler_view = pipe->create_sampler_view(pipe, texture, templ);
-
-   result->base = *templ;
-   result->base.reference.count = 1;
-   result->base.texture = NULL;
-   pipe_texture_reference(&result->base.texture, _texture);
-   result->base.context = _pipe;
+   result = pipe->create_sampler_view(pipe, texture, templ);
 
    trace_dump_ret(ptr, result);
 
    trace_dump_call_end();
 
-   return &result->base;
+   /*
+    * Wrap pipe_sampler_view
+    */
+   tr_view = CALLOC_STRUCT(trace_sampler_view);
+   tr_view->base = *templ;
+   tr_view->base.reference.count = 1;
+   tr_view->base.texture = NULL;
+   pipe_resource_reference(&tr_view->base.texture, _resource);
+   tr_view->base.context = _pipe;
+   tr_view->sampler_view = result;
+   result = &tr_view->base;
+
+   return result;
 }
 
 
@@ -1067,7 +1052,7 @@ trace_sampler_view_destroy(struct pipe_context *_pipe,
 
    trace_dump_call_end();
 
-   pipe_texture_reference(&_view->texture, NULL);
+   pipe_resource_reference(&_view->texture, NULL);
    FREE(_view);
 }
 
@@ -1143,9 +1128,6 @@ trace_context_set_vertex_buffers(struct pipe_context *_pipe,
    struct pipe_context *pipe = tr_ctx->pipe;
    unsigned i;
 
-   for(i = 0; i < num_buffers; ++i)
-      trace_screen_user_buffer_update(_pipe->screen, buffers[i].buffer);
-
    trace_dump_call_begin("pipe_context", "set_vertex_buffers");
 
    trace_dump_arg(ptr, pipe);
@@ -1159,7 +1141,7 @@ trace_context_set_vertex_buffers(struct pipe_context *_pipe,
       struct pipe_vertex_buffer *_buffers = malloc(num_buffers * sizeof(*_buffers));
       memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
       for (i = 0; i < num_buffers; i++)
-         _buffers[i].buffer = trace_buffer_unwrap(tr_ctx, buffers[i].buffer);
+         _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer);
       pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
       free(_buffers);
    } else {
@@ -1296,45 +1278,23 @@ trace_context_destroy(struct pipe_context *_pipe)
 }
 
 static unsigned int
-trace_is_texture_referenced( struct pipe_context *_pipe,
-			    struct pipe_texture *_texture,
-			    unsigned face, unsigned level)
+trace_is_resource_referenced( struct pipe_context *_pipe,
+			      struct pipe_resource *_resource,
+			      unsigned face, unsigned level)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_texture *tr_tex = trace_texture(_texture);
+   struct trace_resource *tr_tex = trace_resource(_resource);
    struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_texture *texture = tr_tex->texture;
+   struct pipe_resource *texture = tr_tex->resource;
    unsigned int referenced;
 
-   trace_dump_call_begin("pipe_context", "is_texture_referenced");
+   trace_dump_call_begin("pipe_context", "is_resource_referenced");
    trace_dump_arg(ptr, pipe);
    trace_dump_arg(ptr, texture);
    trace_dump_arg(uint, face);
    trace_dump_arg(uint, level);
 
-   referenced = pipe->is_texture_referenced(pipe, texture, face, level);
-
-   trace_dump_ret(uint, referenced);
-   trace_dump_call_end();
-
-   return referenced;
-}
-
-static unsigned int
-trace_is_buffer_referenced( struct pipe_context *_pipe,
-			    struct pipe_buffer *_buf)
-{
-   struct trace_context *tr_ctx = trace_context(_pipe);
-   struct trace_buffer *tr_buf = trace_buffer(_buf);
-   struct pipe_context *pipe = tr_ctx->pipe;
-   struct pipe_buffer *buf = tr_buf->buffer;
-   unsigned int referenced;
-
-   trace_dump_call_begin("pipe_context", "is_buffer_referenced");
-   trace_dump_arg(ptr, pipe);
-   trace_dump_arg(ptr, buf);
-
-   referenced = pipe->is_buffer_referenced(pipe, buf);
+   referenced = pipe->is_resource_referenced(pipe, texture, face, level);
 
    trace_dump_ret(uint, referenced);
    trace_dump_call_end();
@@ -1349,41 +1309,26 @@ trace_is_buffer_referenced( struct pipe_context *_pipe,
 
 
 static struct pipe_transfer *
-trace_context_get_tex_transfer(struct pipe_context *_context,
-                              struct pipe_texture *_texture,
-                              unsigned face, unsigned level,
-                              unsigned zslice,
-                              enum pipe_transfer_usage usage,
-                              unsigned x, unsigned y, unsigned w, unsigned h)
+trace_context_get_transfer(struct pipe_context *_context,
+			   struct pipe_resource *_resource,
+			   struct pipe_subresource sr,
+			   unsigned usage,
+			   const struct pipe_box *box)
 {
    struct trace_context *tr_context = trace_context(_context);
-   struct trace_texture *tr_tex = trace_texture(_texture);
+   struct trace_resource *tr_tex = trace_resource(_resource);
    struct pipe_context *context = tr_context->pipe;
-   struct pipe_texture *texture = tr_tex->texture;
+   struct pipe_resource *texture = tr_tex->resource;
    struct pipe_transfer *result = NULL;
 
    assert(texture->screen == context->screen);
 
-   trace_dump_call_begin("pipe_context", "get_tex_transfer");
-
-   trace_dump_arg(ptr, context);
-   trace_dump_arg(ptr, texture);
-   trace_dump_arg(uint, face);
-   trace_dump_arg(uint, level);
-   trace_dump_arg(uint, zslice);
-   trace_dump_arg(uint, usage);
+   /*
+    * Map and transfers can't be serialized so we convert all write transfers
+    * to transfer_inline_write and ignore read transfers.
+    */
 
-   trace_dump_arg(uint, x);
-   trace_dump_arg(uint, y);
-   trace_dump_arg(uint, w);
-   trace_dump_arg(uint, h);
-
-   result = context->get_tex_transfer(context, texture, face, level, zslice, usage,
-				      x, y, w, h);
-
-   trace_dump_ret(ptr, result);
-
-   trace_dump_call_end();
+   result = context->get_transfer(context, texture, sr, usage, box);
 
    if (result)
       result = trace_transfer_create(tr_context, tr_tex, result);
@@ -1393,20 +1338,11 @@ trace_context_get_tex_transfer(struct pipe_context *_context,
 
 
 static void
-trace_context_tex_transfer_destroy(struct pipe_context *_context,
+trace_context_transfer_destroy(struct pipe_context *_context,
                                    struct pipe_transfer *_transfer)
 {
    struct trace_context *tr_context = trace_context(_context);
    struct trace_transfer *tr_trans = trace_transfer(_transfer);
-   struct pipe_context *context = tr_context->pipe;
-   struct pipe_transfer *transfer = tr_trans->transfer;
-
-   trace_dump_call_begin("pipe_context", "tex_transfer_destroy");
-
-   trace_dump_arg(ptr, context);
-   trace_dump_arg(ptr, transfer);
-
-   trace_dump_call_end();
 
    trace_transfer_destroy(tr_context, tr_trans);
 }
@@ -1435,6 +1371,21 @@ trace_context_transfer_map(struct pipe_context *_context,
 
 
 static void
+trace_context_transfer_flush_region( struct pipe_context *_context,
+				     struct pipe_transfer *_transfer,
+				     const struct pipe_box *box)
+{
+   struct trace_context *tr_context = trace_context(_context);
+   struct trace_transfer *tr_transfer = trace_transfer(_transfer);
+   struct pipe_context *context = tr_context->pipe;
+   struct pipe_transfer *transfer = tr_transfer->transfer;
+
+   context->transfer_flush_region(context,
+				  transfer,
+				  box);
+}
+
+static void
 trace_context_transfer_unmap(struct pipe_context *_context,
 			     struct pipe_transfer *_transfer)
 {
@@ -1444,25 +1395,35 @@ trace_context_transfer_unmap(struct pipe_context *_context,
    struct pipe_transfer *transfer = tr_trans->transfer;
 
    if(tr_trans->map) {
-      size_t size = util_format_get_nblocksy(transfer->texture->format, transfer->height) * transfer->stride;
-
-      trace_dump_call_begin("pipe_context", "transfer_write");
+      /*
+       * Fake a transfer_inline_write
+       */
 
-      trace_dump_arg(ptr, context);
+      struct pipe_resource *resource = transfer->resource;
+      struct pipe_subresource sr = transfer->sr;
+      unsigned usage = transfer->usage;
+      const struct pipe_box *box = &transfer->box;
+      unsigned stride = transfer->stride;
+      unsigned slice_stride = transfer->slice_stride;
 
-      trace_dump_arg(ptr, transfer);
+      trace_dump_call_begin("pipe_context", "transfer_inline_write");
 
-      trace_dump_arg_begin("stride");
-      trace_dump_uint(transfer->stride);
-      trace_dump_arg_end();
+      trace_dump_arg(ptr, context);
+      trace_dump_arg(ptr, resource);
+      trace_dump_arg_struct(subresource, sr);
+      trace_dump_arg(uint, usage);
+      trace_dump_arg(box, box);
 
       trace_dump_arg_begin("data");
-      trace_dump_bytes(tr_trans->map, size);
+      trace_dump_box_bytes(tr_trans->map,
+                           resource->format,
+                           box,
+                           stride,
+                           slice_stride);
       trace_dump_arg_end();
 
-      trace_dump_arg_begin("size");
-      trace_dump_uint(size);
-      trace_dump_arg_end();
+      trace_dump_arg(uint, stride);
+      trace_dump_arg(uint, slice_stride);
 
       trace_dump_call_end();
 
@@ -1472,6 +1433,52 @@ trace_context_transfer_unmap(struct pipe_context *_context,
    context->transfer_unmap(context, transfer);
 }
 
+
+static void
+trace_context_transfer_inline_write(struct pipe_context *_context,
+				    struct pipe_resource *_resource,
+				    struct pipe_subresource sr,
+				    unsigned usage,
+				    const struct pipe_box *box,
+				    const void *data,
+				    unsigned stride,
+				    unsigned slice_stride)
+{
+   struct trace_context *tr_context = trace_context(_context);
+   struct trace_resource *tr_tex = trace_resource(_resource);
+   struct pipe_context *context = tr_context->pipe;
+   struct pipe_resource *resource = tr_tex->resource;
+
+   assert(resource->screen == context->screen);
+
+   trace_dump_call_begin("pipe_context", "transfer_inline_write");
+
+   trace_dump_arg(ptr, context);
+   trace_dump_arg(ptr, resource);
+   trace_dump_arg_struct(subresource, sr);
+   trace_dump_arg(uint, usage);
+   trace_dump_arg(box, box);
+
+   trace_dump_arg_begin("data");
+   trace_dump_box_bytes(data,
+                        resource->format,
+                        box,
+                        stride,
+                        slice_stride);
+   trace_dump_arg_end();
+
+   trace_dump_arg(uint, stride);
+   trace_dump_arg(uint, slice_stride);
+
+   trace_dump_call_end();
+
+   context->transfer_inline_write(context, resource,
+				  sr, usage, box, data, stride, slice_stride);
+}
+
+
+
+
 static const struct debug_named_value rbug_blocker_flags[] = {
    {"before", 1},
    {"after", 2},
@@ -1555,13 +1562,14 @@ trace_context_create(struct trace_screen *tr_scr,
       tr_ctx->base.surface_fill = trace_context_surface_fill;
    tr_ctx->base.clear = trace_context_clear;
    tr_ctx->base.flush = trace_context_flush;
-   tr_ctx->base.is_texture_referenced = trace_is_texture_referenced;
-   tr_ctx->base.is_buffer_referenced = trace_is_buffer_referenced;
+   tr_ctx->base.is_resource_referenced = trace_is_resource_referenced;
 
-   tr_ctx->base.get_tex_transfer = trace_context_get_tex_transfer;
-   tr_ctx->base.tex_transfer_destroy = trace_context_tex_transfer_destroy;
+   tr_ctx->base.get_transfer = trace_context_get_transfer;
+   tr_ctx->base.transfer_destroy = trace_context_transfer_destroy;
    tr_ctx->base.transfer_map = trace_context_transfer_map;
    tr_ctx->base.transfer_unmap = trace_context_transfer_unmap;
+   tr_ctx->base.transfer_flush_region = trace_context_transfer_flush_region;
+   tr_ctx->base.transfer_inline_write = trace_context_transfer_inline_write;
 
    tr_ctx->pipe = pipe;
 
diff --git a/src/gallium/drivers/trace/tr_context.h b/src/gallium/drivers/trace/tr_context.h
index feec9b6bbf3..1b4121d80a9 100644
--- a/src/gallium/drivers/trace/tr_context.h
+++ b/src/gallium/drivers/trace/tr_context.h
@@ -60,8 +60,8 @@ struct trace_context
       unsigned num_vert_sampler_views;
 
       unsigned nr_cbufs;
-      struct trace_texture *cbufs[PIPE_MAX_COLOR_BUFS];
-      struct trace_texture *zsbuf;
+      struct trace_resource *cbufs[PIPE_MAX_COLOR_BUFS];
+      struct trace_resource *zsbuf;
    } curr;
 
    struct {
@@ -69,7 +69,7 @@ struct trace_context
       struct trace_shader *vs;
 
       struct trace_sampler_view *sampler_view;
-      struct trace_texture *surf;
+      struct trace_resource *surf;
 
       int blocker;
    } draw_rule;
diff --git a/src/gallium/drivers/trace/tr_dump.c b/src/gallium/drivers/trace/tr_dump.c
index 1affafdddc6..8ff25fb1e85 100644
--- a/src/gallium/drivers/trace/tr_dump.c
+++ b/src/gallium/drivers/trace/tr_dump.c
@@ -50,11 +50,12 @@
 #include "util/u_debug.h"
 #include "util/u_memory.h"
 #include "util/u_string.h"
+#include "util/u_math.h"
+#include "util/u_format.h"
 
 #include "tr_dump.h"
 #include "tr_screen.h"
 #include "tr_texture.h"
-#include "tr_buffer.h"
 
 
 static struct os_stream *stream = NULL;
@@ -471,6 +472,17 @@ void trace_dump_bytes(const void *data,
    trace_dump_writes("</bytes>");
 }
 
+void trace_dump_box_bytes(const void *data,
+			  enum pipe_format format,
+			  const struct pipe_box *box,
+			  unsigned stride,
+			  unsigned slice_stride)
+{
+   size_t size = MAX2(util_format_get_nblocksy(format, box->height) * stride,
+                      box->depth * slice_stride);
+   trace_dump_bytes(data, size);
+}
+
 void trace_dump_string(const char *str)
 {
    if (!dumping)
@@ -574,27 +586,15 @@ void trace_dump_ptr(const void *value)
       trace_dump_null();
 }
 
-void trace_dump_buffer_ptr(struct pipe_buffer *_buffer)
-{
-   if (!dumping)
-      return;
-
-   if (_buffer) {
-      struct trace_buffer *tr_buf = trace_buffer(_buffer);
-      trace_dump_ptr(tr_buf->buffer);
-   } else {
-      trace_dump_null();
-   }
-}
 
-void trace_dump_texture_ptr(struct pipe_texture *_texture)
+void trace_dump_resource_ptr(struct pipe_resource *_resource)
 {
    if (!dumping)
       return;
 
-   if (_texture) {
-      struct trace_texture *tr_tex = trace_texture(_texture);
-      trace_dump_ptr(tr_tex->texture);
+   if (_resource) {
+      struct trace_resource *tr_resource = trace_resource(_resource);
+      trace_dump_ptr(tr_resource->resource);
    } else {
       trace_dump_null();
    }
diff --git a/src/gallium/drivers/trace/tr_dump.h b/src/gallium/drivers/trace/tr_dump.h
index 32592bab12f..f21f72b0c79 100644
--- a/src/gallium/drivers/trace/tr_dump.h
+++ b/src/gallium/drivers/trace/tr_dump.h
@@ -35,12 +35,13 @@
 
 
 #include "pipe/p_compiler.h"
-
+#include "pipe/p_format.h"
 
 struct pipe_buffer;
-struct pipe_texture;
+struct pipe_resource;
 struct pipe_surface;
 struct pipe_transfer;
+struct pipe_box;
 
 /*
  * Call before use.
@@ -92,6 +93,11 @@ void trace_dump_int(long long int value);
 void trace_dump_uint(long long unsigned value);
 void trace_dump_float(double value);
 void trace_dump_bytes(const void *data, size_t size);
+void trace_dump_box_bytes(const void *data,
+			  enum pipe_format format,
+			  const struct pipe_box *box,
+			  unsigned stride,
+			  unsigned slice_stride);
 void trace_dump_string(const char *str);
 void trace_dump_enum(const char *value);
 void trace_dump_array_begin(void);
@@ -105,8 +111,7 @@ void trace_dump_member_end(void);
 void trace_dump_null(void);
 void trace_dump_ptr(const void *value);
 /* will turn a wrapped object into the real one and dump ptr */
-void trace_dump_buffer_ptr(struct pipe_buffer *_buffer);
-void trace_dump_texture_ptr(struct pipe_texture *_texture);
+void trace_dump_resource_ptr(struct pipe_resource *_texture);
 void trace_dump_surface_ptr(struct pipe_surface *_surface);
 void trace_dump_transfer_ptr(struct pipe_transfer *_transfer);
 
@@ -121,6 +126,13 @@ void trace_dump_transfer_ptr(struct pipe_transfer *_transfer);
       trace_dump_arg_end(); \
    } while(0)
 
+#define trace_dump_arg_struct(_type, _arg) \
+   do { \
+      trace_dump_arg_begin(#_arg); \
+      trace_dump_##_type(&_arg); \
+      trace_dump_arg_end(); \
+   } while(0)
+
 #define trace_dump_ret(_type, _arg) \
    do { \
       trace_dump_ret_begin(); \
diff --git a/src/gallium/drivers/trace/tr_dump_state.c b/src/gallium/drivers/trace/tr_dump_state.c
index f82dd01c697..ab347182ed9 100644
--- a/src/gallium/drivers/trace/tr_dump_state.c
+++ b/src/gallium/drivers/trace/tr_dump_state.c
@@ -44,7 +44,7 @@ void trace_dump_format(enum pipe_format format)
 }
 
 
-void trace_dump_template(const struct pipe_texture *templat)
+void trace_dump_resource_template(const struct pipe_resource *templat)
 {
    if (!trace_dumping_enabled_locked())
       return;
@@ -54,7 +54,7 @@ void trace_dump_template(const struct pipe_texture *templat)
       return;
    }
 
-   trace_dump_struct_begin("pipe_texture");
+   trace_dump_struct_begin("pipe_resource");
 
    trace_dump_member(int, templat, target);
    trace_dump_member(format, templat, format);
@@ -72,7 +72,51 @@ void trace_dump_template(const struct pipe_texture *templat)
    trace_dump_member_end();
 
    trace_dump_member(uint, templat, last_level);
-   trace_dump_member(uint, templat, tex_usage);
+   trace_dump_member(uint, templat, _usage);
+   trace_dump_member(uint, templat, bind);
+   trace_dump_member(uint, templat, flags);
+
+   trace_dump_struct_end();
+}
+
+
+void trace_dump_subresource(const struct pipe_subresource *subresource)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if(!subresource) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_subresource");
+
+   trace_dump_member(uint, subresource, face);
+   trace_dump_member(uint, subresource, level);
+
+   trace_dump_struct_end();
+}
+
+
+void trace_dump_box(const struct pipe_box *box)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if(!box) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_box");
+
+   trace_dump_member(uint, box, x);
+   trace_dump_member(uint, box, y);
+   trace_dump_member(uint, box, z);
+   trace_dump_member(uint, box, width);
+   trace_dump_member(uint, box, height);
+   trace_dump_member(uint, box, depth);
 
    trace_dump_struct_end();
 }
@@ -387,6 +431,30 @@ void trace_dump_sampler_state(const struct pipe_sampler_state *state)
 }
 
 
+void trace_dump_sampler_view_template(const struct pipe_sampler_view *state)
+{
+   if (!trace_dumping_enabled_locked())
+      return;
+
+   if(!state) {
+      trace_dump_null();
+      return;
+   }
+
+   trace_dump_struct_begin("pipe_sampler_view");
+
+   trace_dump_member(format, state, format);
+   trace_dump_member(uint, state, first_level);
+   trace_dump_member(uint, state, last_level);
+   trace_dump_member(uint, state, swizzle_r);
+   trace_dump_member(uint, state, swizzle_g);
+   trace_dump_member(uint, state, swizzle_b);
+   trace_dump_member(uint, state, swizzle_a);
+
+   trace_dump_struct_end();
+}
+
+
 void trace_dump_surface(const struct pipe_surface *state)
 {
    if (!trace_dumping_enabled_locked())
@@ -428,16 +496,16 @@ void trace_dump_transfer(const struct pipe_transfer *state)
 
    trace_dump_struct_begin("pipe_transfer");
 
-   trace_dump_member(uint, state, width);
-   trace_dump_member(uint, state, height);
+   trace_dump_member(uint, state, box.width);
+   trace_dump_member(uint, state, box.height);
 
    trace_dump_member(uint, state, stride);
    trace_dump_member(uint, state, usage);
 
-   trace_dump_member(ptr, state, texture);
-   trace_dump_member(uint, state, face);
-   trace_dump_member(uint, state, level);
-   trace_dump_member(uint, state, zslice);
+   trace_dump_member(ptr, state, resource);
+   trace_dump_member(uint, state, sr.face);
+   trace_dump_member(uint, state, sr.level);
+   trace_dump_member(uint, state, box.z);
 
    trace_dump_struct_end();
 }
@@ -458,7 +526,7 @@ void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state)
    trace_dump_member(uint, state, stride);
    trace_dump_member(uint, state, max_index);
    trace_dump_member(uint, state, buffer_offset);
-   trace_dump_member(buffer_ptr, state, buffer);
+   trace_dump_member(resource_ptr, state, buffer);
 
    trace_dump_struct_end();
 }
diff --git a/src/gallium/drivers/trace/tr_dump_state.h b/src/gallium/drivers/trace/tr_dump_state.h
index 3400367d82a..e614e8355e3 100644
--- a/src/gallium/drivers/trace/tr_dump_state.h
+++ b/src/gallium/drivers/trace/tr_dump_state.h
@@ -35,7 +35,11 @@
 
 void trace_dump_format(enum pipe_format format);
 
-void trace_dump_template(const struct pipe_texture *templat);
+void trace_dump_resource_template(const struct pipe_resource *templat);
+
+void trace_dump_subresource(const struct pipe_subresource *subresource);
+
+void trace_dump_box(const struct pipe_box *box);
 
 void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state);
 
@@ -63,6 +67,8 @@ void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state);
 
 void trace_dump_sampler_state(const struct pipe_sampler_state *state);
 
+void trace_dump_sampler_view_template(const struct pipe_sampler_view *view);
+
 void trace_dump_surface(const struct pipe_surface *state);
 
 void trace_dump_transfer(const struct pipe_transfer *state);
diff --git a/src/gallium/drivers/trace/tr_rbug.c b/src/gallium/drivers/trace/tr_rbug.c
index 53ab8c686d8..3ce1b85854b 100644
--- a/src/gallium/drivers/trace/tr_rbug.c
+++ b/src/gallium/drivers/trace/tr_rbug.c
@@ -29,6 +29,7 @@
 #include "os/os_thread.h"
 #include "util/u_format.h"
 #include "util/u_string.h"
+#include "util/u_inlines.h"
 #include "util/u_memory.h"
 #include "util/u_simple_list.h"
 #include "util/u_network.h"
@@ -38,7 +39,6 @@
 
 #include "tr_dump.h"
 #include "tr_state.h"
-#include "tr_buffer.h"
 #include "tr_texture.h"
 
 #include "rbug/rbug.h"
@@ -150,7 +150,7 @@ static int
 trace_rbug_texture_list(struct trace_rbug *tr_rbug, struct rbug_header *header, uint32_t serial)
 {
    struct trace_screen *tr_scr = tr_rbug->tr_scr;
-   struct trace_texture *tr_tex = NULL;
+   struct trace_resource *tr_tex = NULL;
    struct tr_list *ptr;
    rbug_texture_t *texs;
    int i = 0;
@@ -158,7 +158,7 @@ trace_rbug_texture_list(struct trace_rbug *tr_rbug, struct rbug_header *header,
    pipe_mutex_lock(tr_scr->list_mutex);
    texs = MALLOC(tr_scr->num_textures * sizeof(rbug_texture_t));
    foreach(ptr, &tr_scr->textures) {
-      tr_tex = (struct trace_texture *)((char*)ptr - offsetof(struct trace_texture, list));
+      tr_tex = (struct trace_resource *)((char*)ptr - offsetof(struct trace_resource, list));
       texs[i++] = VOID2U64(tr_tex);
    }
    pipe_mutex_unlock(tr_scr->list_mutex);
@@ -173,14 +173,14 @@ static int
 trace_rbug_texture_info(struct trace_rbug *tr_rbug, struct rbug_header *header, uint32_t serial)
 {
    struct trace_screen *tr_scr = tr_rbug->tr_scr;
-   struct trace_texture *tr_tex = NULL;
+   struct trace_resource *tr_tex = NULL;
    struct rbug_proto_texture_info *gpti = (struct rbug_proto_texture_info *)header;
    struct tr_list *ptr;
-   struct pipe_texture *t;
+   struct pipe_resource *t;
 
    pipe_mutex_lock(tr_scr->list_mutex);
    foreach(ptr, &tr_scr->textures) {
-      tr_tex = (struct trace_texture *)((char*)ptr - offsetof(struct trace_texture, list));
+      tr_tex = (struct trace_resource *)((char*)ptr - offsetof(struct trace_resource, list));
       if (gpti->texture == VOID2U64(tr_tex))
          break;
       tr_tex = NULL;
@@ -191,7 +191,7 @@ trace_rbug_texture_info(struct trace_rbug *tr_rbug, struct rbug_header *header,
       return -ESRCH;
    }
 
-   t = tr_tex->texture;
+   t = tr_tex->resource;
    rbug_send_texture_info_reply(tr_rbug->con, serial,
                                t->target, t->format,
                                &t->width0, 1,
@@ -202,7 +202,7 @@ trace_rbug_texture_info(struct trace_rbug *tr_rbug, struct rbug_header *header,
                                util_format_get_blocksize(t->format),
                                t->last_level,
                                t->nr_samples,
-                               t->tex_usage,
+                               t->bind,
                                NULL);
 
    pipe_mutex_unlock(tr_scr->list_mutex);
@@ -216,18 +216,18 @@ trace_rbug_texture_read(struct trace_rbug *tr_rbug, struct rbug_header *header,
    struct rbug_proto_texture_read *gptr = (struct rbug_proto_texture_read *)header;
 
    struct trace_screen *tr_scr = tr_rbug->tr_scr;
-   struct trace_texture *tr_tex = NULL;
+   struct trace_resource *tr_tex = NULL;
    struct tr_list *ptr;
 
    struct pipe_context *context = tr_scr->private_context;
-   struct pipe_texture *tex;
+   struct pipe_resource *tex;
    struct pipe_transfer *t;
 
    void *map;
 
    pipe_mutex_lock(tr_scr->list_mutex);
    foreach(ptr, &tr_scr->textures) {
-      tr_tex = (struct trace_texture *)((char*)ptr - offsetof(struct trace_texture, list));
+      tr_tex = (struct trace_resource *)((char*)ptr - offsetof(struct trace_resource, list));
       if (gptr->texture == VOID2U64(tr_tex))
          break;
       tr_tex = NULL;
@@ -238,8 +238,8 @@ trace_rbug_texture_read(struct trace_rbug *tr_rbug, struct rbug_header *header,
       return -ESRCH;
    }
 
-   tex = tr_tex->texture;
-   t = context->get_tex_transfer(context, tex,
+   tex = tr_tex->resource;
+   t = pipe_get_transfer(context, tex,
 				 gptr->face, gptr->level, gptr->zslice,
 				 PIPE_TRANSFER_READ,
 				 gptr->x, gptr->y, gptr->w, gptr->h);
@@ -247,17 +247,18 @@ trace_rbug_texture_read(struct trace_rbug *tr_rbug, struct rbug_header *header,
    map = context->transfer_map(context, t);
 
    rbug_send_texture_read_reply(tr_rbug->con, serial,
-                                t->texture->format,
-                                util_format_get_blockwidth(t->texture->format),
-                                util_format_get_blockheight(t->texture->format),
-                                util_format_get_blocksize(t->texture->format),
+                                t->resource->format,
+                                util_format_get_blockwidth(t->resource->format),
+                                util_format_get_blockheight(t->resource->format),
+                                util_format_get_blocksize(t->resource->format),
                                 (uint8_t*)map,
-                                t->stride * util_format_get_nblocksy(t->texture->format, t->height),
+                                t->stride * util_format_get_nblocksy(t->resource->format,
+								     t->box.height),
                                 t->stride,
                                 NULL);
 
    context->transfer_unmap(context, t);
-   context->tex_transfer_destroy(context, t);
+   context->transfer_destroy(context, t);
 
    pipe_mutex_unlock(tr_scr->list_mutex);
 
diff --git a/src/gallium/drivers/trace/tr_screen.c b/src/gallium/drivers/trace/tr_screen.c
index 25990bdac7f..63a45d7e512 100644
--- a/src/gallium/drivers/trace/tr_screen.c
+++ b/src/gallium/drivers/trace/tr_screen.c
@@ -29,7 +29,6 @@
 #include "util/u_memory.h"
 #include "util/u_simple_list.h"
 
-#include "tr_buffer.h"
 #include "tr_dump.h"
 #include "tr_dump_state.h"
 #include "tr_texture.h"
@@ -37,7 +36,6 @@
 #include "tr_screen.h"
 #include "tr_public.h"
 
-#include "util/u_inlines.h"
 #include "pipe/p_format.h"
 
 
@@ -213,72 +211,73 @@ trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
  */
 
 
-static struct pipe_texture *
-trace_screen_texture_create(struct pipe_screen *_screen,
-                            const struct pipe_texture *templat)
+static struct pipe_resource *
+trace_screen_resource_create(struct pipe_screen *_screen,
+                            const struct pipe_resource *templat)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_texture *result;
+   struct pipe_resource *result;
 
-   trace_dump_call_begin("pipe_screen", "texture_create");
+   trace_dump_call_begin("pipe_screen", "resource_create");
 
    trace_dump_arg(ptr, screen);
-   trace_dump_arg(template, templat);
+   trace_dump_arg(resource_template, templat);
 
-   result = screen->texture_create(screen, templat);
+   result = screen->resource_create(screen, templat);
 
    trace_dump_ret(ptr, result);
 
    trace_dump_call_end();
 
-   result = trace_texture_create(tr_scr, result);
+   result = trace_resource_create(tr_scr, result);
 
    return result;
 }
 
-static struct pipe_texture *
-trace_screen_texture_from_handle(struct pipe_screen *_screen,
-                                 const struct pipe_texture *templ,
+static struct pipe_resource *
+trace_screen_resource_from_handle(struct pipe_screen *_screen,
+                                 const struct pipe_resource *templ,
                                  struct winsys_handle *handle)
 {
    struct trace_screen *tr_screen = trace_screen(_screen);
    struct pipe_screen *screen = tr_screen->screen;
-   struct pipe_texture *result;
+   struct pipe_resource *result;
 
    /* TODO trace call */
 
-   result = screen->texture_from_handle(screen, templ, handle);
+   result = screen->resource_from_handle(screen, templ, handle);
 
-   result = trace_texture_create(trace_screen(_screen), result);
+   result = trace_resource_create(trace_screen(_screen), result);
 
    return result;
 }
 
 static boolean
-trace_screen_texture_get_handle(struct pipe_screen *_screen,
-                                struct pipe_texture *_texture,
+trace_screen_resource_get_handle(struct pipe_screen *_screen,
+                                struct pipe_resource *_texture,
                                 struct winsys_handle *handle)
 {
    struct trace_screen *tr_screen = trace_screen(_screen);
-   struct trace_texture *tr_texture = trace_texture(_texture);
+   struct trace_resource *tr_texture = trace_resource(_texture);
    struct pipe_screen *screen = tr_screen->screen;
-   struct pipe_texture *texture = tr_texture->texture;
+   struct pipe_resource *texture = tr_texture->resource;
 
    /* TODO trace call */
 
-   return screen->texture_get_handle(screen, texture, handle);
+   return screen->resource_get_handle(screen, texture, handle);
 }
 
 
 
 static void
-trace_screen_texture_destroy(struct pipe_texture *_texture)
+trace_screen_resource_destroy(struct pipe_screen *_screen,
+			      struct pipe_resource *_texture)
 {
-   struct trace_screen *tr_scr = trace_screen(_texture->screen);
-   struct trace_texture *tr_tex = trace_texture(_texture);
+   struct trace_screen *tr_scr = trace_screen(_screen);
+   struct trace_resource *tr_tex = trace_resource(_texture);
    struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_texture *texture = tr_tex->texture;
+   struct pipe_resource *texture = tr_tex->resource;
 
    assert(texture->screen == screen);
 
@@ -289,7 +288,7 @@ trace_screen_texture_destroy(struct pipe_texture *_texture)
 
    trace_dump_call_end();
 
-   trace_texture_destroy(tr_tex);
+   trace_resource_destroy(tr_scr, tr_tex);
 }
 
 
@@ -300,15 +299,15 @@ trace_screen_texture_destroy(struct pipe_texture *_texture)
 
 static struct pipe_surface *
 trace_screen_get_tex_surface(struct pipe_screen *_screen,
-                             struct pipe_texture *_texture,
+                             struct pipe_resource *_texture,
                              unsigned face, unsigned level,
                              unsigned zslice,
                              unsigned usage)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_texture *tr_tex = trace_texture(_texture);
+   struct trace_resource *tr_tex = trace_resource(_texture);
    struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_texture *texture = tr_tex->texture;
+   struct pipe_resource *texture = tr_tex->resource;
    struct pipe_surface *result = NULL;
 
    assert(texture->screen == screen);
@@ -362,53 +361,15 @@ trace_screen_tex_surface_destroy(struct pipe_surface *_surface)
 
 
 
-
-
-static struct pipe_buffer *
-trace_screen_buffer_create(struct pipe_screen *_screen,
-                           unsigned alignment,
-                           unsigned usage,
-                           unsigned size)
-{
-   struct trace_screen *tr_scr = trace_screen(_screen);
-   struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_buffer *result;
-
-   trace_dump_call_begin("pipe_screen", "buffer_create");
-
-   trace_dump_arg(ptr, screen);
-   trace_dump_arg(uint, alignment);
-   trace_dump_arg(uint, usage);
-   trace_dump_arg(uint, size);
-
-   result = screen->buffer_create(screen, alignment, usage, size);
-
-   trace_dump_ret(ptr, result);
-
-   trace_dump_call_end();
-
-   /* Zero the buffer to avoid dumping uninitialized memory */
-   if(result->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
-      void *map;
-      map = pipe_buffer_map(screen, result, PIPE_BUFFER_USAGE_CPU_WRITE);
-      if(map) {
-         memset(map, 0, result->size);
-         screen->buffer_unmap(screen, result);
-      }
-   }
-
-   return trace_buffer_create(tr_scr, result);
-}
-
-
-static struct pipe_buffer *
+static struct pipe_resource *
 trace_screen_user_buffer_create(struct pipe_screen *_screen,
                                 void *data,
-                                unsigned size)
+                                unsigned size,
+				unsigned usage)
 {
    struct trace_screen *tr_scr = trace_screen(_screen);
    struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_buffer *result;
+   struct pipe_resource *result;
 
    trace_dump_call_begin("pipe_screen", "user_buffer_create");
 
@@ -417,189 +378,23 @@ trace_screen_user_buffer_create(struct pipe_screen *_screen,
    trace_dump_bytes(data, size);
    trace_dump_arg_end();
    trace_dump_arg(uint, size);
+   trace_dump_arg(uint, usage);
 
-   result = screen->user_buffer_create(screen, data, size);
+   result = screen->user_buffer_create(screen, data, size, usage);
 
    trace_dump_ret(ptr, result);
 
    trace_dump_call_end();
 
    if(result) {
-      assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
-      result->usage |= TRACE_BUFFER_USAGE_USER;
-   }
-
-   return trace_buffer_create(tr_scr, result);
-}
-
-
-/**
- * This function is used to track if data has been changed on a user buffer
- * without map/unmap being called.
- */
-void
-trace_screen_user_buffer_update(struct pipe_screen *_screen,
-                                struct pipe_buffer *_buffer)
-{
-#if 0
-   struct trace_screen *tr_scr = trace_screen(_screen);
-   struct pipe_screen *screen = tr_scr->screen;
-   const void *map;
-
-   if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
-      map = screen->buffer_map(screen, buffer, PIPE_BUFFER_USAGE_CPU_READ);
-      if(map) {
-         trace_dump_call_begin("pipe_winsys", "buffer_write");
-
-         trace_dump_arg(ptr, screen);
-
-         trace_dump_arg(ptr, buffer);
-
-         trace_dump_arg_begin("data");
-         trace_dump_bytes(map, buffer->size);
-         trace_dump_arg_end();
-
-         trace_dump_arg_begin("size");
-         trace_dump_uint(buffer->size);
-         trace_dump_arg_end();
-
-         trace_dump_call_end();
-
-         screen->buffer_unmap(screen, buffer);
-      }
-   }
-#endif
-}
-
-
-static void *
-trace_screen_buffer_map(struct pipe_screen *_screen,
-                        struct pipe_buffer *_buffer,
-                        unsigned usage)
-{
-   struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_buffer *tr_buf = trace_buffer(_buffer);
-   struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_buffer *buffer = tr_buf->buffer;
-   void *map;
-
-   assert(screen->buffer_map);
-   map = screen->buffer_map(screen, buffer, usage);
-   if(map) {
-      if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
-         tr_buf->map = map;
-      }
-   }
-
-   return map;
-}
-
-
-static void *
-trace_screen_buffer_map_range(struct pipe_screen *_screen,
-                              struct pipe_buffer *_buffer,
-                              unsigned offset,
-                              unsigned length,
-                              unsigned usage)
-{
-   struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_buffer *tr_buf = trace_buffer(_buffer);
-   struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_buffer *buffer = tr_buf->buffer;
-   void *map;
-
-   assert(screen->buffer_map_range);
-   map = screen->buffer_map_range(screen, buffer, offset, length, usage);
-   if(map) {
-      if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
-         tr_buf->map = map;
-      }
+      assert(!(result->flags & TRACE_FLAG_USER_BUFFER));
+      result->flags |= TRACE_FLAG_USER_BUFFER;
    }
 
-   return map;
-}
-
-
-static void
-buffer_write(struct pipe_screen *screen,
-             struct pipe_buffer *buffer,
-             unsigned offset,
-             const char *map,
-             unsigned size)
-{
-   assert(map);
-
-   trace_dump_call_begin("pipe_screen", "buffer_write");
-
-   trace_dump_arg(ptr, screen);
-
-   trace_dump_arg(ptr, buffer);
-
-   trace_dump_arg(uint, offset);
-
-   trace_dump_arg_begin("data");
-   trace_dump_bytes(map + offset, size);
-   trace_dump_arg_end();
-
-   trace_dump_arg(uint, size);
-
-   trace_dump_call_end();
-
-}
-
-
-static void
-trace_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
-                                       struct pipe_buffer *_buffer,
-                                       unsigned offset,
-                                       unsigned length)
-{
-   struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_buffer *tr_buf = trace_buffer(_buffer);
-   struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_buffer *buffer = tr_buf->buffer;
-
-   assert(tr_buf->map);
-   buffer_write(screen, buffer, offset, tr_buf->map, length);
-   tr_buf->range_flushed = TRUE;
-   screen->buffer_flush_mapped_range(screen, buffer, offset, length);
+   return trace_resource_create(tr_scr, result);
 }
 
 
-static void
-trace_screen_buffer_unmap(struct pipe_screen *_screen,
-                          struct pipe_buffer *_buffer)
-{
-   struct trace_screen *tr_scr = trace_screen(_screen);
-   struct trace_buffer *tr_buf = trace_buffer(_buffer);
-   struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_buffer *buffer = tr_buf->buffer;
-
-   if (tr_buf->map && !tr_buf->range_flushed)
-      buffer_write(screen, buffer, 0, tr_buf->map, buffer->size);
-   tr_buf->map = NULL;
-   tr_buf->range_flushed = FALSE;
-   screen->buffer_unmap(screen, buffer);
-}
-
-
-static void
-trace_screen_buffer_destroy(struct pipe_buffer *_buffer)
-{
-   struct trace_screen *tr_scr = trace_screen(_buffer->screen);
-   struct trace_buffer *tr_buf = trace_buffer(_buffer);
-   struct pipe_screen *screen = tr_scr->screen;
-   struct pipe_buffer *buffer = tr_buf->buffer;
-
-   trace_dump_call_begin("pipe_screen", "buffer_destroy");
-
-   trace_dump_arg(ptr, screen);
-   trace_dump_arg(ptr, buffer);
-
-   trace_dump_call_end();
-
-   trace_buffer_destroy(tr_scr, _buffer);
-}
 
 
 /********************************************************************
@@ -769,23 +564,13 @@ trace_screen_create(struct pipe_screen *screen)
    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
    assert(screen->context_create);
    tr_scr->base.context_create = trace_screen_context_create;
-   tr_scr->base.texture_create = trace_screen_texture_create;
-   tr_scr->base.texture_from_handle = trace_screen_texture_from_handle;
-   tr_scr->base.texture_get_handle = trace_screen_texture_get_handle;
-   tr_scr->base.texture_destroy = trace_screen_texture_destroy;
+   tr_scr->base.resource_create = trace_screen_resource_create;
+   tr_scr->base.resource_from_handle = trace_screen_resource_from_handle;
+   tr_scr->base.resource_get_handle = trace_screen_resource_get_handle;
+   tr_scr->base.resource_destroy = trace_screen_resource_destroy;
    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
    tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
-   tr_scr->base.buffer_create = trace_screen_buffer_create;
    tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
-   if (screen->buffer_map)
-      tr_scr->base.buffer_map = trace_screen_buffer_map;
-   if (screen->buffer_map_range)
-      tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
-   if (screen->buffer_flush_mapped_range)
-      tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
-   if (screen->buffer_unmap)
-      tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
-   tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
    tr_scr->base.fence_reference = trace_screen_fence_reference;
    tr_scr->base.fence_signalled = trace_screen_fence_signalled;
    tr_scr->base.fence_finish = trace_screen_fence_finish;
diff --git a/src/gallium/drivers/trace/tr_screen.h b/src/gallium/drivers/trace/tr_screen.h
index 9bfbe72e2c0..05ff9ef61f1 100644
--- a/src/gallium/drivers/trace/tr_screen.h
+++ b/src/gallium/drivers/trace/tr_screen.h
@@ -48,7 +48,7 @@ struct tr_list {
  * without mapping/unmapping. This flag marks user buffers, so that their
  * contents can be dumpped before being used by the pipe context.
  */
-#define TRACE_BUFFER_USAGE_USER  (1 << 31)
+#define TRACE_FLAG_USER_BUFFER  (1 << 31)
 
 
 struct trace_screen
@@ -100,10 +100,6 @@ trace_enabled(void);
 struct trace_screen *
 trace_screen(struct pipe_screen *screen);
 
-void
-trace_screen_user_buffer_update(struct pipe_screen *screen,
-                                struct pipe_buffer *buffer);
-
 #define trace_screen_add_to_list(tr_scr, name, obj) \
    do {                                             \
       pipe_mutex_lock(tr_scr->list_mutex);          \
diff --git a/src/gallium/drivers/trace/tr_texture.c b/src/gallium/drivers/trace/tr_texture.c
index d818e21bb82..1132dc92724 100644
--- a/src/gallium/drivers/trace/tr_texture.c
+++ b/src/gallium/drivers/trace/tr_texture.c
@@ -35,51 +35,50 @@
 #include "tr_texture.h"
 
 
-struct pipe_texture *
-trace_texture_create(struct trace_screen *tr_scr,
-                     struct pipe_texture *texture)
+struct pipe_resource *
+trace_resource_create(struct trace_screen *tr_scr,
+                     struct pipe_resource *texture)
 {
-   struct trace_texture *tr_tex;
+   struct trace_resource *tr_tex;
 
    if(!texture)
       goto error;
 
    assert(texture->screen == tr_scr->screen);
 
-   tr_tex = CALLOC_STRUCT(trace_texture);
+   tr_tex = CALLOC_STRUCT(trace_resource);
    if(!tr_tex)
       goto error;
 
-   memcpy(&tr_tex->base, texture, sizeof(struct pipe_texture));
+   memcpy(&tr_tex->base, texture, sizeof(struct pipe_resource));
 
    pipe_reference_init(&tr_tex->base.reference, 1);
    tr_tex->base.screen = &tr_scr->base;
-   tr_tex->texture = texture;
+   tr_tex->resource = texture;
 
    trace_screen_add_to_list(tr_scr, textures, tr_tex);
 
    return &tr_tex->base;
 
 error:
-   pipe_texture_reference(&texture, NULL);
+   pipe_resource_reference(&texture, NULL);
    return NULL;
 }
 
 
 void
-trace_texture_destroy(struct trace_texture *tr_tex)
+trace_resource_destroy(struct trace_screen *tr_scr,
+		       struct trace_resource *tr_tex)
 {
-   struct trace_screen *tr_scr = trace_screen(tr_tex->base.screen);
-
    trace_screen_remove_from_list(tr_scr, textures, tr_tex);
 
-   pipe_texture_reference(&tr_tex->texture, NULL);
+   pipe_resource_reference(&tr_tex->resource, NULL);
    FREE(tr_tex);
 }
 
 
 struct pipe_surface *
-trace_surface_create(struct trace_texture *tr_tex,
+trace_surface_create(struct trace_resource *tr_tex,
                      struct pipe_surface *surface)
 {
    struct trace_screen *tr_scr = trace_screen(tr_tex->base.screen);
@@ -88,7 +87,7 @@ trace_surface_create(struct trace_texture *tr_tex,
    if(!surface)
       goto error;
 
-   assert(surface->texture == tr_tex->texture);
+   assert(surface->texture == tr_tex->resource);
 
    tr_surf = CALLOC_STRUCT(trace_surface);
    if(!tr_surf)
@@ -98,7 +97,7 @@ trace_surface_create(struct trace_texture *tr_tex,
 
    pipe_reference_init(&tr_surf->base.reference, 1);
    tr_surf->base.texture = NULL;
-   pipe_texture_reference(&tr_surf->base.texture, &tr_tex->base);
+   pipe_resource_reference(&tr_surf->base.texture, &tr_tex->base);
    tr_surf->surface = surface;
 
    trace_screen_add_to_list(tr_scr, surfaces, tr_surf);
@@ -118,7 +117,7 @@ trace_surface_destroy(struct trace_surface *tr_surf)
 
    trace_screen_remove_from_list(tr_scr, surfaces, tr_surf);
 
-   pipe_texture_reference(&tr_surf->base.texture, NULL);
+   pipe_resource_reference(&tr_surf->base.texture, NULL);
    pipe_surface_reference(&tr_surf->surface, NULL);
    FREE(tr_surf);
 }
@@ -126,7 +125,7 @@ trace_surface_destroy(struct trace_surface *tr_surf)
 
 struct pipe_transfer *
 trace_transfer_create(struct trace_context *tr_ctx,
-		      struct trace_texture *tr_tex,
+		      struct trace_resource *tr_tex,
 		      struct pipe_transfer *transfer)
 {
    struct trace_screen *tr_scr = trace_screen(tr_tex->base.screen);
@@ -135,7 +134,7 @@ trace_transfer_create(struct trace_context *tr_ctx,
    if(!transfer)
       goto error;
 
-   assert(transfer->texture == tr_tex->texture);
+   assert(transfer->resource == tr_tex->resource);
 
    tr_trans = CALLOC_STRUCT(trace_transfer);
    if(!tr_trans)
@@ -143,18 +142,18 @@ trace_transfer_create(struct trace_context *tr_ctx,
 
    memcpy(&tr_trans->base, transfer, sizeof(struct pipe_transfer));
 
-   tr_trans->base.texture = NULL;
+   tr_trans->base.resource = NULL;
    tr_trans->transfer = transfer;
 
-   pipe_texture_reference(&tr_trans->base.texture, &tr_tex->base);
-   assert(tr_trans->base.texture == &tr_tex->base);
+   pipe_resource_reference(&tr_trans->base.resource, &tr_tex->base);
+   assert(tr_trans->base.resource == &tr_tex->base);
 
    trace_screen_add_to_list(tr_scr, transfers, tr_trans);
 
    return &tr_trans->base;
 
 error:
-   tr_ctx->pipe->tex_transfer_destroy(tr_ctx->pipe, transfer);
+   tr_ctx->pipe->transfer_destroy(tr_ctx->pipe, transfer);
    return NULL;
 }
 
@@ -169,8 +168,8 @@ trace_transfer_destroy(struct trace_context *tr_context,
 
    trace_screen_remove_from_list(tr_scr, transfers, tr_trans);
 
-   pipe_texture_reference(&tr_trans->base.texture, NULL);
-   context->tex_transfer_destroy(context, transfer);
+   pipe_resource_reference(&tr_trans->base.resource, NULL);
+   context->transfer_destroy(context, transfer);
    FREE(tr_trans);
 }
 
diff --git a/src/gallium/drivers/trace/tr_texture.h b/src/gallium/drivers/trace/tr_texture.h
index 66250465e44..6513995d505 100644
--- a/src/gallium/drivers/trace/tr_texture.h
+++ b/src/gallium/drivers/trace/tr_texture.h
@@ -36,11 +36,11 @@
 
 struct trace_context;
 
-struct trace_texture
+struct trace_resource
 {
-   struct pipe_texture base;
+   struct pipe_resource base;
 
-   struct pipe_texture *texture;
+   struct pipe_resource *resource;
 
    struct tr_list list;
 };
@@ -77,13 +77,13 @@ struct trace_transfer
 };
 
 
-static INLINE struct trace_texture *
-trace_texture(struct pipe_texture *texture)
+static INLINE struct trace_resource *
+trace_resource(struct pipe_resource *texture)
 {
    if(!texture)
       return NULL;
    (void)trace_screen(texture->screen);
-   return (struct trace_texture *)texture;
+   return (struct trace_resource *)texture;
 }
 
 
@@ -92,7 +92,7 @@ trace_surface(struct pipe_surface *surface)
 {
    if(!surface)
       return NULL;
-   (void)trace_texture(surface->texture);
+   (void)trace_resource(surface->texture);
    return (struct trace_surface *)surface;
 }
 
@@ -111,20 +111,21 @@ trace_transfer(struct pipe_transfer *transfer)
 {
    if(!transfer)
       return NULL;
-   (void)trace_texture(transfer->texture);
+   (void)trace_resource(transfer->resource);
    return (struct trace_transfer *)transfer;
 }
 
 
-struct pipe_texture *
-trace_texture_create(struct trace_screen *tr_scr,
-                     struct pipe_texture *texture);
+struct pipe_resource *
+trace_resource_create(struct trace_screen *tr_scr,
+                     struct pipe_resource *texture);
 
 void
-trace_texture_destroy(struct trace_texture *tr_tex);
+trace_resource_destroy(struct trace_screen *tr_scr,
+		       struct trace_resource *tr_tex);
 
 struct pipe_surface *
-trace_surface_create(struct trace_texture *tr_tex,
+trace_surface_create(struct trace_resource *tr_tex,
                      struct pipe_surface *surface);
 
 void
@@ -132,7 +133,7 @@ trace_surface_destroy(struct trace_surface *tr_surf);
 
 struct pipe_transfer *
 trace_transfer_create(struct trace_context *tr_ctx,
-		      struct trace_texture *tr_tex,
+		      struct trace_resource *tr_tex,
 		      struct pipe_transfer *transfer);
 
 void
diff --git a/src/gallium/include/pipe/p_compiler.h b/src/gallium/include/pipe/p_compiler.h
index d645fd09bf0..09d6b6c9e2f 100644
--- a/src/gallium/include/pipe/p_compiler.h
+++ b/src/gallium/include/pipe/p_compiler.h
@@ -74,8 +74,6 @@ typedef unsigned char boolean;
 #define FALSE false
 #endif
 
-typedef unsigned short half;
-
 /* Function inlining */
 #ifndef INLINE
 #  ifdef __cplusplus
diff --git a/src/gallium/include/pipe/p_context.h b/src/gallium/include/pipe/p_context.h
index 6aba6ef1eee..1aa0cbe4dca 100644
--- a/src/gallium/include/pipe/p_context.h
+++ b/src/gallium/include/pipe/p_context.h
@@ -65,7 +65,7 @@ struct pipe_context {
                         unsigned mode, unsigned start, unsigned count);
 
    void (*draw_elements)( struct pipe_context *pipe,
-                          struct pipe_buffer *indexBuffer,
+                          struct pipe_resource *indexBuffer,
                           unsigned indexSize,
                           unsigned mode, unsigned start, unsigned count);
 
@@ -77,7 +77,7 @@ struct pipe_context {
                                  unsigned instanceCount);
 
    void (*draw_elements_instanced)(struct pipe_context *pipe,
-                                   struct pipe_buffer *indexBuffer,
+                                   struct pipe_resource *indexBuffer,
                                    unsigned indexSize,
                                    unsigned mode,
                                    unsigned start,
@@ -91,7 +91,7 @@ struct pipe_context {
     * module.
     */
    void (*draw_range_elements)( struct pipe_context *pipe,
-                                struct pipe_buffer *indexBuffer,
+                                struct pipe_resource *indexBuffer,
                                 unsigned indexSize,
                                 unsigned minIndex,
                                 unsigned maxIndex,
@@ -200,7 +200,7 @@ struct pipe_context {
 
    void (*set_constant_buffer)( struct pipe_context *,
                                 uint shader, uint index,
-                                struct pipe_buffer *buf );
+                                struct pipe_resource *buf );
 
    void (*set_framebuffer_state)( struct pipe_context *,
                                   const struct pipe_framebuffer_state * );
@@ -291,27 +291,15 @@ struct pipe_context {
     * \param level  mipmap level.
     * \return mask of PIPE_REFERENCED_FOR_READ/WRITE or PIPE_UNREFERENCED
     */
-   unsigned int (*is_texture_referenced)(struct pipe_context *pipe,
-					 struct pipe_texture *texture,
-					 unsigned face, unsigned level);
-
-   /**
-    * Check whether a buffer is referenced by an unflushed hw command.
-    * The state-tracker uses this function to avoid unnecessary flushes.
-    * It is safe (but wasteful) to always return
-    * PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE.
-    * \param pipe  context whose unflushed hw commands will be checked.
-    * \param buf  buffer to check.
-    * \return mask of PIPE_REFERENCED_FOR_READ/WRITE or PIPE_UNREFERENCED
-    */
-   unsigned int (*is_buffer_referenced)(struct pipe_context *pipe,
-					struct pipe_buffer *buf);
+   unsigned int (*is_resource_referenced)(struct pipe_context *pipe,
+					  struct pipe_resource *texture,
+					  unsigned face, unsigned level);
 
    /**
     * Create a view on a texture to be used by a shader stage.
     */
    struct pipe_sampler_view * (*create_sampler_view)(struct pipe_context *ctx,
-                                                     struct pipe_texture *texture,
+                                                     struct pipe_resource *texture,
                                                      const struct pipe_sampler_view *templat);
 
    void (*sampler_view_destroy)(struct pipe_context *ctx,
@@ -324,24 +312,42 @@ struct pipe_context {
     * Transfers are (by default) context-private and allow uploads to be
     * interleaved with
     */
-   struct pipe_transfer *(*get_tex_transfer)(struct pipe_context *,
-                                             struct pipe_texture *texture,
-                                             unsigned face, unsigned level,
-                                             unsigned zslice,
-                                             enum pipe_transfer_usage usage,
-                                             unsigned x, unsigned y,
-                                             unsigned w, unsigned h);
-
-   void (*tex_transfer_destroy)(struct pipe_context *,
+   struct pipe_transfer *(*get_transfer)(struct pipe_context *,
+					 struct pipe_resource *resource,
+					 struct pipe_subresource,
+					 unsigned usage,  /* a combination of PIPE_TRANSFER_x */
+					 const struct pipe_box *);
+
+   void (*transfer_destroy)(struct pipe_context *,
                                 struct pipe_transfer *);
    
    void *(*transfer_map)( struct pipe_context *,
                           struct pipe_transfer *transfer );
 
+   /* If transfer was created with WRITE|FLUSH_EXPLICIT, only the
+    * regions specified with this call are guaranteed to be written to
+    * the resource.
+    */
+   void (*transfer_flush_region)( struct pipe_context *,
+				  struct pipe_transfer *transfer,
+				  const struct pipe_box *);
+
    void (*transfer_unmap)( struct pipe_context *,
                            struct pipe_transfer *transfer );
 
 
+   /* One-shot transfer operation with data supplied in a user
+    * pointer.  XXX: strides??
+    */
+   void (*transfer_inline_write)( struct pipe_context *,
+				  struct pipe_resource *,
+				  struct pipe_subresource,
+				  unsigned usage, /* a combination of PIPE_TRANSFER_x */
+				  const struct pipe_box *,
+				  const void *data,
+				  unsigned stride,
+				  unsigned slice_stride);
+
 };
 
 
diff --git a/src/gallium/include/pipe/p_defines.h b/src/gallium/include/pipe/p_defines.h
index c1e291b9da4..0a4bd584aec 100644
--- a/src/gallium/include/pipe/p_defines.h
+++ b/src/gallium/include/pipe/p_defines.h
@@ -137,10 +137,11 @@ enum pipe_error {
 
 /** Texture types */
 enum pipe_texture_target {
-   PIPE_TEXTURE_1D   = 0,
-   PIPE_TEXTURE_2D   = 1,
-   PIPE_TEXTURE_3D   = 2,
-   PIPE_TEXTURE_CUBE = 3,
+   PIPE_BUFFER       = 0,
+   PIPE_TEXTURE_1D   = 1,
+   PIPE_TEXTURE_2D   = 2,
+   PIPE_TEXTURE_3D   = 3,
+   PIPE_TEXTURE_CUBE = 4,
    PIPE_MAX_TEXTURE_TYPES
 };
 
@@ -175,22 +176,10 @@ enum pipe_texture_target {
 #define PIPE_TEX_COMPARE_NONE          0
 #define PIPE_TEX_COMPARE_R_TO_TEXTURE  1
 
-#define PIPE_TEXTURE_USAGE_RENDER_TARGET   0x1
-#define PIPE_TEXTURE_USAGE_DISPLAY_TARGET  0x2  /* windows presentable buffer, ie a backbuffer */
-#define PIPE_TEXTURE_USAGE_SCANOUT         0x4  /* ie a frontbuffer */
-#define PIPE_TEXTURE_USAGE_DEPTH_STENCIL   0x8
-#define PIPE_TEXTURE_USAGE_SAMPLER         0x10
-#define PIPE_TEXTURE_USAGE_DYNAMIC         0x20
-#define PIPE_TEXTURE_USAGE_SHARED          0x40
-/** Pipe driver custom usage flags should be greater or equal to this value */
-#define PIPE_TEXTURE_USAGE_CUSTOM          (1 << 16)
-
-#define PIPE_TEXTURE_GEOM_NON_SQUARE       0x1
-#define PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO 0x2
-
 
 /**
- * Surface layout
+ * Surface layout -- a hint?  Or some driver-internal poking out into
+ * the interface?
  */
 #define PIPE_SURFACE_LAYOUT_LINEAR  0
 
@@ -208,10 +197,23 @@ enum pipe_texture_target {
  * Transfer object usage flags
  */
 enum pipe_transfer_usage {
+   /**
+    * Resource contents read back (or accessed directly) at transfer
+    * create time.
+    */
    PIPE_TRANSFER_READ = (1 << 0),
+   
+   /**
+    * Resource contents will be written back at transfer_destroy
+    * time (or modified as a result of being accessed directly).
+    */
    PIPE_TRANSFER_WRITE = (1 << 1),
-   /** Read/modify/write */
+
+   /**
+    * Read/modify/write
+    */
    PIPE_TRANSFER_READ_WRITE = PIPE_TRANSFER_READ | PIPE_TRANSFER_WRITE,
+
    /** 
     * The transfer should map the texture storage directly. The driver may
     * return NULL if that isn't possible, and the state tracker needs to cope
@@ -221,89 +223,116 @@ enum pipe_transfer_usage {
     * does read/modify/write cycles on them directly, and a more complicated
     * path which uses minimal read and write transfers.
     */
-   PIPE_TRANSFER_MAP_DIRECTLY = (1 << 2)
-};
+   PIPE_TRANSFER_MAP_DIRECTLY = (1 << 2),
+
+   /**
+    * Discards the memory within the mapped region.
+    *
+    * It should not be used with PIPE_TRANSFER_CPU_READ.
+    *
+    * See also:
+    * - OpenGL's ARB_map_buffer_range extension, MAP_INVALIDATE_RANGE_BIT flag.
+    * - Direct3D's D3DLOCK_DISCARD flag.
+    */
+   PIPE_TRANSFER_DISCARD = (1 << 8),
 
+   /**
+    * Fail if the resource cannot be mapped immediately.
+    *
+    * See also:
+    * - Direct3D's D3DLOCK_DONOTWAIT flag.
+    * - Mesa3D's MESA_MAP_NOWAIT_BIT flag.
+    * - WDDM's D3DDDICB_LOCKFLAGS.DonotWait flag.
+    */
+   PIPE_TRANSFER_DONTBLOCK = (1 << 9),
 
-/*
- * Buffer usage flags
- */
+   /**
+    * Do not attempt to synchronize pending operations on the resource when mapping.
+    *
+    * It should not be used with PIPE_TRANSFER_CPU_READ.
+    *
+    * See also:
+    * - OpenGL's ARB_map_buffer_range extension, MAP_UNSYNCHRONIZED_BIT flag.
+    * - Direct3D's D3DLOCK_NOOVERWRITE flag.
+    * - WDDM's D3DDDICB_LOCKFLAGS.IgnoreSync flag.
+    */
+   PIPE_TRANSFER_UNSYNCHRONIZED = (1 << 10),
+   PIPE_TRANSFER_NOOVERWRITE = (1 << 10), /* are these really the same?? */
+
+   /**
+    * Written ranges will be notified later with
+    * pipe_context::transfer_flush_region.
+    *
+    * It should not be used with PIPE_TRANSFER_CPU_READ.
+    *
+    * See also:
+    * - pipe_context::transfer_flush_region
+    * - OpenGL's ARB_map_buffer_range extension, MAP_FLUSH_EXPLICIT_BIT flag.
+    */
+   PIPE_TRANSFER_FLUSH_EXPLICIT = (1 << 11),
+
+};
 
-#define PIPE_BUFFER_USAGE_CPU_READ  (1 << 0)
-#define PIPE_BUFFER_USAGE_CPU_WRITE (1 << 1)
-#define PIPE_BUFFER_USAGE_GPU_READ  (1 << 2)
-#define PIPE_BUFFER_USAGE_GPU_WRITE (1 << 3)
-#define PIPE_BUFFER_USAGE_PIXEL     (1 << 4)
-#define PIPE_BUFFER_USAGE_VERTEX    (1 << 5)
-#define PIPE_BUFFER_USAGE_INDEX     (1 << 6)
-#define PIPE_BUFFER_USAGE_CONSTANT  (1 << 7)
 
 /*
- * CPU access flags.
- *
- * These flags should only be used for texture transfers or when mapping
- * buffers.
- *
- * Note that the PIPE_BUFFER_USAGE_CPU_xxx flags above are also used for
- * mapping. Either PIPE_BUFFER_USAGE_CPU_READ or PIPE_BUFFER_USAGE_CPU_WRITE
- * must be set.
+ * Resource binding flags -- state tracker must specify in advance all
+ * the ways a resource might be used.
  */
-
-/**
- * Discards the memory within the mapped region.
+#define PIPE_BIND_DEPTH_STENCIL        (1 << 0) /* get_tex_surface */
+#define PIPE_BIND_RENDER_TARGET        (1 << 1) /* get_tex_surface */
+#define PIPE_BIND_SAMPLER_VIEW         (1 << 2) /* get_sampler_view */
+#define PIPE_BIND_VERTEX_BUFFER        (1 << 3) /* set_vertex_buffers */
+#define PIPE_BIND_INDEX_BUFFER         (1 << 4) /* draw_elements */
+#define PIPE_BIND_CONSTANT_BUFFER      (1 << 5) /* set_constant_buffer */
+#define PIPE_BIND_BLIT_SOURCE          (1 << 6) /* surface_copy */
+#define PIPE_BIND_BLIT_DESTINATION     (1 << 7) /* surface_copy, fill */
+#define PIPE_BIND_DISPLAY_TARGET       (1 << 8) /* flush_front_buffer */
+#define PIPE_BIND_TRANSFER_WRITE       (1 << 9) /* get_transfer */
+#define PIPE_BIND_TRANSFER_READ        (1 << 10) /* get_transfer */
+#define PIPE_BIND_CUSTOM               (1 << 16) /* state-tracker/winsys usages */
+
+/* The first two flags were previously part of the amorphous
+ * TEXTURE_USAGE, most of which are now descriptions of the ways a
+ * particular texture can be bound to the gallium pipeline.  These two
+ * do not fit within that and probably need to be migrated to some
+ * other place.
  *
- * It should not be used with PIPE_BUFFER_USAGE_CPU_READ.
+ * It seems like scanout is used by the Xorg state tracker to ask for
+ * a texture suitable for actual scanout (hence the name), which
+ * implies extra layout constraints on some hardware.  It may also
+ * have some special meaning regarding mouse cursor images.
  *
- * See also:
- * - OpenGL's ARB_map_buffer_range extension, MAP_INVALIDATE_RANGE_BIT flag.
- * - Direct3D's D3DLOCK_DISCARD flag.
+ * The shared flag is quite underspecified, but certainly isn't a
+ * binding flag - it seems more like a message to the winsys to create
+ * a shareable allocation.  Could it mean that this texture is a valid argument for 
  */
-#define PIPE_BUFFER_USAGE_DISCARD   (1 << 8)
+#define PIPE_BIND_SCANOUT     (1 << 14) /*  */
+#define PIPE_BIND_SHARED      (1 << 15) /* get_texture_handle ??? */
 
-/**
- * Fail if the resource cannot be mapped immediately.
- *
- * See also:
- * - Direct3D's D3DLOCK_DONOTWAIT flag.
- * - Mesa3D's MESA_MAP_NOWAIT_BIT flag.
- * - WDDM's D3DDDICB_LOCKFLAGS.DonotWait flag.
- */
-#define PIPE_BUFFER_USAGE_DONTBLOCK (1 << 9)
 
-/**
- * Do not attempt to synchronize pending operations on the resource when mapping.
- *
- * It should not be used with PIPE_BUFFER_USAGE_CPU_READ.
- *
- * See also:
- * - OpenGL's ARB_map_buffer_range extension, MAP_UNSYNCHRONIZED_BIT flag.
- * - Direct3D's D3DLOCK_NOOVERWRITE flag.
- * - WDDM's D3DDDICB_LOCKFLAGS.IgnoreSync flag.
+/* Flags for the driver about resource behaviour:
  */
-#define PIPE_BUFFER_USAGE_UNSYNCHRONIZED (1 << 10)
+#define PIPE_RESOURCE_FLAG_GEN_MIPS    (1 << 0)  /* Driver performs autogen mips */
+#define PIPE_RESOURCE_FLAG_DRV_PRIV    (1 << 16) /* driver/winsys private */
+#define PIPE_RESOURCE_FLAG_ST_PRIV     (1 << 24) /* state-tracker/winsys private */
 
-/**
- * Written ranges will be notified later with
- * pipe_screen::buffer_flush_mapped_range.
- *
- * It should not be used with PIPE_BUFFER_USAGE_CPU_READ.
- *
- * See also:
- * - pipe_screen::buffer_flush_mapped_range
- * - OpenGL's ARB_map_buffer_range extension, MAP_FLUSH_EXPLICIT_BIT flag.
+/* Hint about the expected lifecycle of a resource.
  */
-#define PIPE_BUFFER_USAGE_FLUSH_EXPLICIT (1 << 11)
+#define PIPE_USAGE_DEFAULT        0 /* many uploads, draws intermixed */
+#define PIPE_USAGE_DYNAMIC        1 /* many uploads, draws intermixed */
+#define PIPE_USAGE_STATIC         2 /* same as immutable?? */
+#define PIPE_USAGE_IMMUTABLE      3 /* no change after first upload */
+#define PIPE_USAGE_STREAM         4 /* upload, draw, upload, draw */
 
-/** Pipe driver custom usage flags should be greater or equal to this value */
-#define PIPE_BUFFER_USAGE_CUSTOM    (1 << 16)
 
-/* Convenient shortcuts */
-#define PIPE_BUFFER_USAGE_CPU_READ_WRITE \
-   ( PIPE_BUFFER_USAGE_CPU_READ | PIPE_BUFFER_USAGE_CPU_WRITE )
-#define PIPE_BUFFER_USAGE_GPU_READ_WRITE \
-   ( PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE )
-#define PIPE_BUFFER_USAGE_WRITE \
-   ( PIPE_BUFFER_USAGE_CPU_WRITE | PIPE_BUFFER_USAGE_GPU_WRITE )
+/* These are intended to be used in calls to is_format_supported, but
+ * no driver actually uses these flags, and only the glx/xlib state
+ * tracker issues them.
+ *
+ * Deprecate?
+ */
+#define PIPE_TEXTURE_GEOM_NON_SQUARE       0x1
+#define PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO 0x2
 
 
 /** 
@@ -435,30 +464,6 @@ enum pipe_transfer_usage {
 #define PIPE_REFERENCED_FOR_WRITE (1 << 1)
 
 
-enum pipe_video_codec
-{
-   PIPE_VIDEO_CODEC_UNKNOWN = 0,
-   PIPE_VIDEO_CODEC_MPEG12,   /**< MPEG1, MPEG2 */
-   PIPE_VIDEO_CODEC_MPEG4,    /**< DIVX, XVID */
-   PIPE_VIDEO_CODEC_VC1,      /**< WMV */
-   PIPE_VIDEO_CODEC_MPEG4_AVC /**< H.264 */
-};
-
-enum pipe_video_profile
-{
-   PIPE_VIDEO_PROFILE_MPEG1,
-   PIPE_VIDEO_PROFILE_MPEG2_SIMPLE,
-   PIPE_VIDEO_PROFILE_MPEG2_MAIN,
-   PIPE_VIDEO_PROFILE_MPEG4_SIMPLE,
-   PIPE_VIDEO_PROFILE_MPEG4_ADVANCED_SIMPLE,
-   PIPE_VIDEO_PROFILE_VC1_SIMPLE,
-   PIPE_VIDEO_PROFILE_VC1_MAIN,
-   PIPE_VIDEO_PROFILE_VC1_ADVANCED,
-   PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE,
-   PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN,
-   PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH
-};
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/gallium/include/pipe/p_format.h b/src/gallium/include/pipe/p_format.h
index c7a90a09a12..436c3f627a8 100644
--- a/src/gallium/include/pipe/p_format.h
+++ b/src/gallium/include/pipe/p_format.h
@@ -171,6 +171,7 @@ enum pipe_format {
    PIPE_FORMAT_R8SG8SB8UX8U_NORM       = 119,
    PIPE_FORMAT_R5SG5SB6U_NORM          = 120,
 
+   /* TODO: re-order these */
    PIPE_FORMAT_A8B8G8R8_UNORM          = 121,
    PIPE_FORMAT_B5G5R5X1_UNORM          = 122,
    PIPE_FORMAT_R10G10B10A2_USCALED     = 123,
@@ -178,29 +179,19 @@ enum pipe_format {
    PIPE_FORMAT_R9G9B9E5_FLOAT          = 125,
    PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED = 126,
    PIPE_FORMAT_R1_UNORM                = 127,
+   PIPE_FORMAT_R10G10B10X2_USCALED     = 128,
+   PIPE_FORMAT_R10G10B10X2_SNORM       = 129,
+   PIPE_FORMAT_L4A4_UNORM              = 130,
+   PIPE_FORMAT_B10G10R10A2_UNORM       = 131,
+   PIPE_FORMAT_R10SG10SB10SA2U_NORM    = 132,
+   PIPE_FORMAT_R8G8Bx_SNORM            = 133,
+   PIPE_FORMAT_R8G8B8X8_UNORM          = 134,
+   PIPE_FORMAT_B4G4R4X4_UNORM          = 135,
 
    PIPE_FORMAT_COUNT
 };
 
 
-enum pipe_video_chroma_format
-{
-   PIPE_VIDEO_CHROMA_FORMAT_420,
-   PIPE_VIDEO_CHROMA_FORMAT_422,
-   PIPE_VIDEO_CHROMA_FORMAT_444
-};
-
-#if 0
-enum pipe_video_surface_format
-{
-   PIPE_VIDEO_SURFACE_FORMAT_NV12,  /**< Planar; Y plane, UV plane */
-   PIPE_VIDEO_SURFACE_FORMAT_YV12,  /**< Planar; Y plane, U plane, V plane */
-   PIPE_VIDEO_SURFACE_FORMAT_YUYV,  /**< Interleaved; Y,U,Y,V,Y,U,Y,V */
-   PIPE_VIDEO_SURFACE_FORMAT_UYVY,  /**< Interleaved; U,Y,V,Y,U,Y,V,Y */
-   PIPE_VIDEO_SURFACE_FORMAT_VUYA   /**< Packed; A31-24|Y23-16|U15-8|V7-0 */
-};
-#endif
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/gallium/include/pipe/p_screen.h b/src/gallium/include/pipe/p_screen.h
index b7cb83abbe5..06ab4a848a4 100644
--- a/src/gallium/include/pipe/p_screen.h
+++ b/src/gallium/include/pipe/p_screen.h
@@ -54,10 +54,9 @@ struct winsys_handle;
 /** Opaque type */
 struct pipe_fence_handle;
 struct pipe_winsys;
-struct pipe_buffer;
 struct pipe_texture;
+struct pipe_resource;
 struct pipe_surface;
-struct pipe_video_surface;
 struct pipe_transfer;
 
 
@@ -94,7 +93,7 @@ struct pipe_screen {
    /**
     * Check if the given pipe_format is supported as a texture or
     * drawing surface.
-    * \param tex_usage  bitmask of PIPE_TEXTURE_USAGE_*
+    * \param tex_usage  bitmask of PIPE_BIND_*
     * \param geom_flags  bitmask of PIPE_TEXTURE_GEOM_*
     */
    boolean (*is_format_supported)( struct pipe_screen *,
@@ -106,35 +105,36 @@ struct pipe_screen {
    /**
     * Create a new texture object, using the given template info.
     */
-   struct pipe_texture * (*texture_create)(struct pipe_screen *,
-                                           const struct pipe_texture *templat);
+   struct pipe_resource * (*resource_create)(struct pipe_screen *,
+					     const struct pipe_resource *templat);
 
    /**
     * Create a texture from a winsys_handle. The handle is often created in
     * another process by first creating a pipe texture and then calling
     * texture_get_handle.
     */
-   struct pipe_texture * (*texture_from_handle)(struct pipe_screen *,
-                                                const struct pipe_texture *templat,
-                                                struct winsys_handle *handle);
+   struct pipe_resource * (*resource_from_handle)(struct pipe_screen *,
+						  const struct pipe_resource *templat,
+						  struct winsys_handle *handle);
 
    /**
     * Get a winsys_handle from a texture. Some platforms/winsys requires
     * that the texture is created with a special usage flag like
     * DISPLAYTARGET or PRIMARY.
     */
-   boolean (*texture_get_handle)(struct pipe_screen *,
-                                 struct pipe_texture *tex,
-                                 struct winsys_handle *handle);
+   boolean (*resource_get_handle)(struct pipe_screen *,
+				  struct pipe_resource *tex,
+				  struct winsys_handle *handle);
 
 
-   void (*texture_destroy)(struct pipe_texture *pt);
+   void (*resource_destroy)(struct pipe_screen *,
+			    struct pipe_resource *pt);
 
    /** Get a 2D surface which is a "view" into a texture
-    * \param usage  bitmaks of PIPE_BUFFER_USAGE_* read/write flags
+    * \param usage  bitmaks of PIPE_BIND_* flags
     */
    struct pipe_surface *(*get_tex_surface)(struct pipe_screen *,
-                                           struct pipe_texture *texture,
+                                           struct pipe_resource *resource,
                                            unsigned face, unsigned level,
                                            unsigned zslice,
                                            unsigned usage );
@@ -144,17 +144,6 @@ struct pipe_screen {
 
 
    /**
-    * Create a new buffer.
-    * \param alignment  buffer start address alignment in bytes
-    * \param usage  bitmask of PIPE_BUFFER_USAGE_x
-    * \param size  size in bytes
-    */
-   struct pipe_buffer *(*buffer_create)( struct pipe_screen *screen,
-                                         unsigned alignment,
-                                         unsigned usage,
-                                         unsigned size );
-
-   /**
     * Create a buffer that wraps user-space data.
     *
     * Effectively this schedules a delayed call to buffer_create
@@ -175,83 +164,10 @@ struct pipe_screen {
     * Note that ptr may be accessed at any time upto the time when the
     * buffer is destroyed, so the data must not be freed before then.
     */
-   struct pipe_buffer *(*user_buffer_create)(struct pipe_screen *screen,
-                                             void *ptr,
-                                             unsigned bytes);
-
-
-
-   /**
-    * Map the entire data store of a buffer object into the client's address.
-    * flags is bitmask of PIPE_BUFFER_USAGE_CPU_READ/WRITE flags.
-    */
-   void *(*buffer_map)( struct pipe_screen *screen,
-			struct pipe_buffer *buf,
-			unsigned usage );
-   /**
-    * Map a subrange of the buffer data store into the client's address space.
-    *
-    * The returned pointer is always relative to buffer start, regardless of 
-    * the specified range. This is different from the ARB_map_buffer_range
-    * semantics because we don't forbid multiple mappings of the same buffer
-    * (yet).
-    */
-   void *(*buffer_map_range)( struct pipe_screen *screen,
-                              struct pipe_buffer *buf,
-                              unsigned offset,
-                              unsigned length,
-                              unsigned usage);
-
-   /**
-    * Notify a range that was actually written into.
-    * 
-    * Can only be used if the buffer was mapped with the 
-    * PIPE_BUFFER_USAGE_CPU_WRITE and PIPE_BUFFER_USAGE_FLUSH_EXPLICIT flags 
-    * set.
-    * 
-    * The range is relative to the buffer start, regardless of the range 
-    * specified to buffer_map_range. This is different from the 
-    * ARB_map_buffer_range semantics because we don't forbid multiple mappings 
-    * of the same buffer (yet).
-    * 
-    */
-   void (*buffer_flush_mapped_range)( struct pipe_screen *screen,
-                                      struct pipe_buffer *buf,
-                                      unsigned offset,
-                                      unsigned length);
-
-   /**
-    * Unmap buffer.
-    * 
-    * If the buffer was mapped with PIPE_BUFFER_USAGE_CPU_WRITE flag but not
-    * PIPE_BUFFER_USAGE_FLUSH_EXPLICIT then the pipe driver will
-    * assume that the whole buffer was written. This is mostly for backward 
-    * compatibility purposes and may affect performance -- the state tracker 
-    * should always specify exactly what got written while the buffer was 
-    * mapped.
-    */
-   void (*buffer_unmap)( struct pipe_screen *screen,
-                         struct pipe_buffer *buf );
-
-   void (*buffer_destroy)( struct pipe_buffer *buf );
-
-   /**
-    * Create a video surface suitable for use as a decoding target by the
-    * driver's pipe_video_context.
-    */
-   struct pipe_video_surface*
-   (*video_surface_create)( struct pipe_screen *screen,
-                            enum pipe_video_chroma_format chroma_format,
-                            unsigned width, unsigned height );
-
-   void (*video_surface_destroy)( struct pipe_video_surface *vsfc );
-
-   /**
-    * Do any special operations to ensure buffer size is correct
-    * \param context_private  the private data of the calling context
-    */
-   void (*update_buffer)( struct pipe_screen *ws,
-                          void *context_private );
+   struct pipe_resource *(*user_buffer_create)(struct pipe_screen *screen,
+					       void *ptr,
+					       unsigned bytes,
+					       unsigned bind_flags);
 
    /**
     * Do any special operations to ensure frontbuffer contents are
diff --git a/src/gallium/include/pipe/p_state.h b/src/gallium/include/pipe/p_state.h
index 11072407d93..d281d69ff27 100644
--- a/src/gallium/include/pipe/p_state.h
+++ b/src/gallium/include/pipe/p_state.h
@@ -71,19 +71,6 @@ struct pipe_reference
 };
 
 
-/**
- * The driver will certainly subclass this to include actual memory
- * management information.
- */
-struct pipe_buffer
-{
-   struct pipe_reference  reference;
-   unsigned               size;
-   struct pipe_screen    *screen;
-   unsigned               alignment;
-   unsigned               usage;
-};
-
 
 /**
  * Primitive (point/line/tri) rasterization info
@@ -285,20 +272,25 @@ struct pipe_sampler_state
 struct pipe_surface
 {
    struct pipe_reference reference;
+   struct pipe_resource *texture; /**< resource into which this is a view  */
    enum pipe_format format;
+
    unsigned width;               /**< logical width in pixels */
    unsigned height;              /**< logical height in pixels */
+
    unsigned layout;              /**< PIPE_SURFACE_LAYOUT_x */
    unsigned offset;              /**< offset from start of buffer, in bytes */
-   unsigned usage;               /**< bitmask of PIPE_BUFFER_USAGE_x */
+   unsigned usage;               /**< bitmask of PIPE_BIND_x */
 
    unsigned zslice;
-   struct pipe_texture *texture; /**< texture into which this is a view  */
    unsigned face;
    unsigned level;
 };
 
 
+
+
+
 /**
  * A view into a texture that can be bound to a shader stage.
  */
@@ -306,7 +298,7 @@ struct pipe_sampler_view
 {
    struct pipe_reference reference;
    enum pipe_format format;      /**< typed PIPE_FORMAT_x */
-   struct pipe_texture *texture; /**< texture into which this is a view  */
+   struct pipe_resource *texture; /**< texture into which this is a view  */
    struct pipe_context *context; /**< context this view belongs to */
    unsigned first_level:8;       /**< first mipmap level */
    unsigned last_level:8;        /**< last mipmap level */
@@ -317,32 +309,22 @@ struct pipe_sampler_view
 };
 
 
-/**
- * Transfer object.  For data transfer to/from a texture.
- */
-struct pipe_transfer
+struct pipe_box
 {
-   unsigned x;                   /**< x offset from start of texture image */
-   unsigned y;                   /**< y offset from start of texture image */
-   unsigned width;               /**< logical width in pixels */
-   unsigned height;              /**< logical height in pixels */
-   unsigned stride;              /**< stride in bytes between rows of blocks */
-   enum pipe_transfer_usage usage; /**< PIPE_TRANSFER_*  */
-
-   struct pipe_texture *texture; /**< texture to transfer to/from  */
-   unsigned face;
-   unsigned level;
-   unsigned zslice;
+   unsigned x;
+   unsigned y;
+   unsigned z;
+   unsigned width;
+   unsigned height;
+   unsigned depth;
 };
 
 
-/**
- * Texture object.
- */
-struct pipe_texture
-{ 
-   struct pipe_reference reference;
 
+struct pipe_resource
+{
+   struct pipe_reference reference;
+   struct pipe_screen *screen; /**< screen that this texture belongs to */
    enum pipe_texture_target target; /**< PIPE_TEXTURE_x */
    enum pipe_format format;         /**< PIPE_FORMAT_x */
 
@@ -351,15 +333,37 @@ struct pipe_texture
    unsigned depth0;
 
    unsigned last_level:8;    /**< Index of last mipmap level present/defined */
-
    unsigned nr_samples:8;    /**< for multisampled surfaces, nr of samples */
+   unsigned _usage:8;	       /* PIPE_USAGE_x (not a bitmask) */
 
-   unsigned tex_usage;       /**< bitmask of PIPE_TEXTURE_USAGE_* */
+   unsigned bind;	       /* PIPE_BIND_x */
+   unsigned flags;	       /* PIPE_RESOURCE_FLAG_x */
+};
 
-   struct pipe_screen *screen; /**< screen that this texture belongs to */
+
+struct pipe_subresource
+{
+   unsigned face:16;
+   unsigned level:16;
+};
+
+
+/**
+ * Transfer object.  For data transfer to/from a texture.
+ */
+struct pipe_transfer
+{
+   struct pipe_resource *resource; /**< resource to transfer to/from  */
+   struct pipe_subresource sr;
+   enum pipe_transfer_usage usage;
+   struct pipe_box box;
+   unsigned stride;
+   unsigned slice_stride;
+   void *data;
 };
 
 
+
 /**
  * A vertex buffer.  Typically, all the vertex data/attributes for
  * drawing something will be in one buffer.  But it's also possible, for
@@ -370,7 +374,7 @@ struct pipe_vertex_buffer
    unsigned stride;    /**< stride to same attrib in next vertex, in bytes */
    unsigned max_index;   /**< number of vertices in this buffer */
    unsigned buffer_offset;  /**< offset to start of data in buffer, in bytes */
-   struct pipe_buffer *buffer;  /**< the actual buffer */
+   struct pipe_resource *buffer;  /**< the actual buffer */
 };
 
 
diff --git a/src/gallium/include/pipe/p_video_context.h b/src/gallium/include/pipe/p_video_context.h
deleted file mode 100644
index 6ae31418fa8..00000000000
--- a/src/gallium/include/pipe/p_video_context.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 PIPE_VIDEO_CONTEXT_H
-#define PIPE_VIDEO_CONTEXT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <pipe/p_video_state.h>
-
-struct pipe_screen;
-struct pipe_buffer;
-struct pipe_surface;
-struct pipe_video_surface;
-struct pipe_macroblock;
-struct pipe_picture_desc;
-struct pipe_fence_handle;
-
-/**
- * Gallium video rendering context
- */
-struct pipe_video_context
-{
-   struct pipe_screen *screen;
-   enum pipe_video_profile profile;
-   enum pipe_video_chroma_format chroma_format;
-   unsigned width;
-   unsigned height;
-
-   void *priv; /**< context private data (for DRI for example) */
-
-   void (*destroy)(struct pipe_video_context *vpipe);
-
-   /**
-    * Picture decoding and displaying
-    */
-   /*@{*/
-   void (*decode_bitstream)(struct pipe_video_context *vpipe,
-                            unsigned num_bufs,
-                            struct pipe_buffer **bitstream_buf);
-
-   void (*decode_macroblocks)(struct pipe_video_context *vpipe,
-                              struct pipe_video_surface *past,
-                              struct pipe_video_surface *future,
-                              unsigned num_macroblocks,
-                              struct pipe_macroblock *macroblocks,
-                              struct pipe_fence_handle **fence);
-
-   void (*clear_surface)(struct pipe_video_context *vpipe,
-                         unsigned x, unsigned y,
-                         unsigned width, unsigned height,
-                         unsigned value,
-                         struct pipe_surface *surface);
-
-   void (*render_picture)(struct pipe_video_context     *vpipe,
-                          /*struct pipe_surface         *backround,
-                          struct pipe_video_rect        *backround_area,*/
-                          struct pipe_video_surface     *src_surface,
-                          enum pipe_mpeg12_picture_type picture_type,
-                          /*unsigned                    num_past_surfaces,
-                          struct pipe_video_surface     *past_surfaces,
-                          unsigned                      num_future_surfaces,
-                          struct pipe_video_surface     *future_surfaces,*/
-                          struct pipe_video_rect        *src_area,
-                          struct pipe_surface           *dst_surface,
-                          struct pipe_video_rect        *dst_area,
-                          /*unsigned                      num_layers,
-                          struct pipe_texture           *layers,
-                          struct pipe_video_rect        *layer_src_areas,
-                          struct pipe_video_rect        *layer_dst_areas,*/
-                          struct pipe_fence_handle      **fence);
-   /*@}*/
-
-   /**
-    * Parameter-like states (or properties)
-    */
-   /*@{*/
-   void (*set_picture_desc)(struct pipe_video_context *vpipe,
-                            const struct pipe_picture_desc *desc);
-
-   void (*set_decode_target)(struct pipe_video_context *vpipe,
-                             struct pipe_video_surface *dt);
-
-   void (*set_csc_matrix)(struct pipe_video_context *vpipe, const float *mat);
-
-   /* TODO: Interface for scaling modes, post-processing, etc. */
-   /*@}*/
-};
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* PIPE_VIDEO_CONTEXT_H */
diff --git a/src/gallium/include/pipe/p_video_state.h b/src/gallium/include/pipe/p_video_state.h
deleted file mode 100644
index 77e22d0a566..00000000000
--- a/src/gallium/include/pipe/p_video_state.h
+++ /dev/null
@@ -1,185 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 PIPE_VIDEO_STATE_H
-#define PIPE_VIDEO_STATE_H
-
-/* u_reduce_video_profile() needs these */
-#include <pipe/p_compiler.h>
-
-#include <pipe/p_defines.h>
-#include <pipe/p_format.h>
-#include <pipe/p_state.h>
-#include <pipe/p_screen.h>
-#include <util/u_inlines.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct pipe_video_surface
-{
-   struct pipe_reference reference;
-   struct pipe_screen *screen;
-   enum pipe_video_chroma_format chroma_format;
-   /*enum pipe_video_surface_format surface_format;*/
-   unsigned width;
-   unsigned height;
-};
-
-static INLINE void
-pipe_video_surface_reference(struct pipe_video_surface **ptr, struct pipe_video_surface *surf)
-{
-   struct pipe_video_surface *old_surf = *ptr;
-
-   if (pipe_reference(&(*ptr)->reference, &surf->reference))
-      old_surf->screen->video_surface_destroy(old_surf);
-   *ptr = surf;
-}
-
-struct pipe_video_rect
-{
-   unsigned x, y, w, h;
-};
-
-static INLINE enum pipe_video_codec
-u_reduce_video_profile(enum pipe_video_profile profile)
-{
-   switch (profile)
-   {
-      case PIPE_VIDEO_PROFILE_MPEG1:
-      case PIPE_VIDEO_PROFILE_MPEG2_SIMPLE:
-      case PIPE_VIDEO_PROFILE_MPEG2_MAIN:
-         return PIPE_VIDEO_CODEC_MPEG12;
-
-      case PIPE_VIDEO_PROFILE_MPEG4_SIMPLE:
-      case PIPE_VIDEO_PROFILE_MPEG4_ADVANCED_SIMPLE:
-         return PIPE_VIDEO_CODEC_MPEG4;
-
-      case PIPE_VIDEO_PROFILE_VC1_SIMPLE:
-      case PIPE_VIDEO_PROFILE_VC1_MAIN:
-      case PIPE_VIDEO_PROFILE_VC1_ADVANCED:
-         return PIPE_VIDEO_CODEC_VC1;
-
-      case PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE:
-      case PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN:
-      case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH:
-         return PIPE_VIDEO_CODEC_MPEG4_AVC;
-
-      default:
-         assert(0);
-         return PIPE_VIDEO_CODEC_UNKNOWN;
-   }
-}
-
-enum pipe_mpeg12_picture_type
-{
-   PIPE_MPEG12_PICTURE_TYPE_FIELD_TOP,
-   PIPE_MPEG12_PICTURE_TYPE_FIELD_BOTTOM,
-   PIPE_MPEG12_PICTURE_TYPE_FRAME
-};
-
-enum pipe_mpeg12_macroblock_type
-{
-   PIPE_MPEG12_MACROBLOCK_TYPE_INTRA,
-   PIPE_MPEG12_MACROBLOCK_TYPE_FWD,
-   PIPE_MPEG12_MACROBLOCK_TYPE_BKWD,
-   PIPE_MPEG12_MACROBLOCK_TYPE_BI,
-	
-   PIPE_MPEG12_MACROBLOCK_NUM_TYPES
-};
-
-enum pipe_mpeg12_motion_type
-{
-   PIPE_MPEG12_MOTION_TYPE_FIELD,
-   PIPE_MPEG12_MOTION_TYPE_FRAME,
-   PIPE_MPEG12_MOTION_TYPE_DUALPRIME,
-   PIPE_MPEG12_MOTION_TYPE_16x8
-};
-
-enum pipe_mpeg12_dct_type
-{
-   PIPE_MPEG12_DCT_TYPE_FIELD,
-   PIPE_MPEG12_DCT_TYPE_FRAME
-};
-
-struct pipe_macroblock
-{
-   enum pipe_video_codec codec;
-};
-
-struct pipe_mpeg12_macroblock
-{
-   struct pipe_macroblock base;
-
-   unsigned mbx;
-   unsigned mby;
-   enum pipe_mpeg12_macroblock_type mb_type;
-   enum pipe_mpeg12_motion_type mo_type;
-   enum pipe_mpeg12_dct_type dct_type;
-   signed pmv[2][2][2];
-   unsigned cbp;
-   void *blocks;
-};
-
-#if 0
-struct pipe_picture_desc
-{
-   enum pipe_video_format format;
-};
-
-struct pipe_mpeg12_picture_desc
-{
-   struct pipe_picture_desc base;
-
-   /* TODO: Use bitfields where possible? */
-   struct pipe_surface *forward_reference;
-   struct pipe_surface *backward_reference;
-   unsigned picture_coding_type;
-   unsigned fcode;
-   unsigned intra_dc_precision;
-   unsigned picture_structure;
-   unsigned top_field_first;
-   unsigned frame_pred_frame_dct;
-   unsigned concealment_motion_vectors;
-   unsigned q_scale_type;
-   unsigned intra_vlc_format;
-   unsigned alternate_scan;
-   unsigned full_pel_forward_vector;
-   unsigned full_pel_backward_vector;
-   struct pipe_buffer *intra_quantizer_matrix;
-   struct pipe_buffer *non_intra_quantizer_matrix;
-   struct pipe_buffer *chroma_intra_quantizer_matrix;
-   struct pipe_buffer *chroma_non_intra_quantizer_matrix;
-};
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* PIPE_VIDEO_STATE_H */
diff --git a/src/gallium/include/state_tracker/dri1_api.h b/src/gallium/include/state_tracker/dri1_api.h
index bb1cd6d1d82..a48c5de5a05 100644
--- a/src/gallium/include/state_tracker/dri1_api.h
+++ b/src/gallium/include/state_tracker/dri1_api.h
@@ -11,7 +11,7 @@ struct pipe_screen;
 struct pipe_winsys;
 struct pipe_buffer;
 struct pipe_context;
-struct pipe_texture;
+struct pipe_resource;
 
 struct drm_clip_rect;
 
diff --git a/src/gallium/include/state_tracker/drm_api.h b/src/gallium/include/state_tracker/drm_api.h
index 9780cf250b8..50c8c1cf191 100644
--- a/src/gallium/include/state_tracker/drm_api.h
+++ b/src/gallium/include/state_tracker/drm_api.h
@@ -8,7 +8,7 @@ struct pipe_screen;
 struct pipe_winsys;
 struct pipe_buffer;
 struct pipe_context;
-struct pipe_texture;
+struct pipe_resource;
 
 enum drm_create_screen_mode {
 	DRM_CREATE_NORMAL = 0,
diff --git a/src/gallium/include/state_tracker/st_api.h b/src/gallium/include/state_tracker/st_api.h
index 70ad215bfce..8897ff7c259 100644
--- a/src/gallium/include/state_tracker/st_api.h
+++ b/src/gallium/include/state_tracker/st_api.h
@@ -119,7 +119,7 @@ enum st_context_resource_type {
 typedef void (*st_proc_t)(void);
 
 struct pipe_context;
-struct pipe_texture;
+struct pipe_resource;
 struct pipe_fence_handle;
 
 /**
@@ -132,7 +132,7 @@ struct st_context_resource
    void *resource;
 
    /* this is owned by the caller */
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
 };
 
 /**
@@ -145,7 +145,7 @@ struct st_egl_image
    void *egl_image;
 
    /* this is owned by the caller */
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
 
    unsigned face;
    unsigned level;
@@ -239,7 +239,7 @@ struct st_framebuffer_iface
    boolean (*validate)(struct st_framebuffer_iface *stfbi,
                        const enum st_attachment_type *statts,
                        unsigned count,
-                       struct pipe_texture **out);
+                       struct pipe_resource **out);
 };
 
 /**
@@ -292,7 +292,7 @@ struct st_context_iface
     */
    boolean (*teximage)(struct st_context_iface *stctxi, enum st_texture_type target,
                        int level, enum pipe_format internal_format,
-                       struct pipe_texture *tex, boolean mipmap);
+                       struct pipe_resource *tex, boolean mipmap);
 
    /**
     * Used to implement glXCopyContext.
diff --git a/src/gallium/include/state_tracker/sw_winsys.h b/src/gallium/include/state_tracker/sw_winsys.h
index a87650dc77d..d461dedb90e 100644
--- a/src/gallium/include/state_tracker/sw_winsys.h
+++ b/src/gallium/include/state_tracker/sw_winsys.h
@@ -47,7 +47,7 @@ extern "C" {
 struct winsys_handle;
 struct pipe_screen;
 struct pipe_context;
-struct pipe_texture;
+struct pipe_resource;
 
 
 /**
@@ -81,7 +81,7 @@ struct sw_winsys
     * pools, or obtained directly from the windowing system.
     *  
     * This callback is invoked by the pipe_screen when creating a texture marked
-    * with the PIPE_TEXTURE_USAGE_DISPLAY_TARGET flag to get the underlying 
+    * with the PIPE_BIND_DISPLAY_TARGET flag to get the underlying 
     * storage.
     */
    struct sw_displaytarget *
@@ -97,7 +97,7 @@ struct sw_winsys
     */
    struct sw_displaytarget *
    (*displaytarget_from_handle)( struct sw_winsys *ws,
-                                 const struct pipe_texture *templat,
+                                 const struct pipe_resource *template,
                                  struct winsys_handle *whandle,
                                  unsigned *stride );
 
@@ -110,7 +110,7 @@ struct sw_winsys
                                 struct winsys_handle *whandle );
 
    /**
-    * \param flags  bitmask of PIPE_BUFFER_USAGE_x flags
+    * \param flags  bitmask of PIPE_TRANSFER_x flags
     */
    void *
    (*displaytarget_map)( struct sw_winsys *ws, 
diff --git a/src/gallium/state_trackers/dri/common/dri1_helper.c b/src/gallium/state_trackers/dri/common/dri1_helper.c
index 7eeb868d422..b0dd974a964 100644
--- a/src/gallium/state_trackers/dri/common/dri1_helper.c
+++ b/src/gallium/state_trackers/dri/common/dri1_helper.c
@@ -84,7 +84,7 @@ dri1_swap_fences_clear(struct dri_drawable *drawable)
 }
 
 struct pipe_surface *
-dri1_get_pipe_surface(struct dri_drawable *drawable, struct pipe_texture *ptex)
+dri1_get_pipe_surface(struct dri_drawable *drawable, struct pipe_resource *ptex)
 {
    struct pipe_screen *pipe_screen = dri_screen(drawable->sPriv)->pipe_screen;
    struct pipe_surface *psurf = drawable->dri1_surface;
@@ -93,7 +93,7 @@ dri1_get_pipe_surface(struct dri_drawable *drawable, struct pipe_texture *ptex)
       pipe_surface_reference(&drawable->dri1_surface, NULL);
 
       drawable->dri1_surface = pipe_screen->get_tex_surface(pipe_screen,
-            ptex, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ);
+            ptex, 0, 0, 0, PIPE_BIND_BLIT_SOURCE);
 
       psurf = drawable->dri1_surface;
    }
diff --git a/src/gallium/state_trackers/dri/common/dri1_helper.h b/src/gallium/state_trackers/dri/common/dri1_helper.h
index 3254b7ff872..c98adf2df22 100644
--- a/src/gallium/state_trackers/dri/common/dri1_helper.h
+++ b/src/gallium/state_trackers/dri/common/dri1_helper.h
@@ -47,7 +47,7 @@ void
 dri1_swap_fences_clear(struct dri_drawable *drawable);
 
 struct pipe_surface *
-dri1_get_pipe_surface(struct dri_drawable *drawable, struct pipe_texture *ptex);
+dri1_get_pipe_surface(struct dri_drawable *drawable, struct pipe_resource *ptex);
 
 void
 dri1_destroy_pipe_surface(struct dri_drawable *drawable);
diff --git a/src/gallium/state_trackers/dri/common/dri_drawable.h b/src/gallium/state_trackers/dri/common/dri_drawable.h
index 98abeb9ec05..315b7781654 100644
--- a/src/gallium/state_trackers/dri/common/dri_drawable.h
+++ b/src/gallium/state_trackers/dri/common/dri_drawable.h
@@ -55,7 +55,7 @@ struct dri_drawable
    unsigned old_w;
    unsigned old_h;
 
-   struct pipe_texture *textures[ST_ATTACHMENT_COUNT];
+   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
    unsigned int texture_mask, texture_stamp;
 
    struct pipe_fence_handle *swap_fences[DRI_SWAP_FENCES_MAX];
diff --git a/src/gallium/state_trackers/dri/common/dri_screen.c b/src/gallium/state_trackers/dri/common/dri_screen.c
index 6fc7487071b..83616744ad0 100644
--- a/src/gallium/state_trackers/dri/common/dri_screen.c
+++ b/src/gallium/state_trackers/dri/common/dri_screen.c
@@ -93,34 +93,34 @@ dri_fill_in_modes(struct dri_screen *screen,
 
    pf_x8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24X8_UNORM,
 					    PIPE_TEXTURE_2D,
-					    PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+					    PIPE_BIND_DEPTH_STENCIL, 0);
    pf_z24x8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_X8Z24_UNORM,
 					    PIPE_TEXTURE_2D,
-					    PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+					    PIPE_BIND_DEPTH_STENCIL, 0);
    pf_s8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 					    PIPE_TEXTURE_2D,
-					    PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+					    PIPE_BIND_DEPTH_STENCIL, 0);
    pf_z24s8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
 					    PIPE_TEXTURE_2D,
-					    PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+					    PIPE_BIND_DEPTH_STENCIL, 0);
    pf_a8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8A8_UNORM,
 					       PIPE_TEXTURE_2D,
-					       PIPE_TEXTURE_USAGE_RENDER_TARGET, 0);
+					       PIPE_BIND_RENDER_TARGET, 0);
    pf_x8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8X8_UNORM,
 					       PIPE_TEXTURE_2D,
-					       PIPE_TEXTURE_USAGE_RENDER_TARGET, 0);
+					       PIPE_BIND_RENDER_TARGET, 0);
    pf_r5g6b5 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B5G6R5_UNORM,
 					     PIPE_TEXTURE_2D,
-					     PIPE_TEXTURE_USAGE_RENDER_TARGET, 0);
+					     PIPE_BIND_RENDER_TARGET, 0);
 
    /* We can only get a 16 or 32 bit depth buffer with getBuffersWithFormat */
    if (dri_with_format(screen->sPriv)) {
       pf_z16 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z16_UNORM,
                                              PIPE_TEXTURE_2D,
-                                             PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+                                             PIPE_BIND_DEPTH_STENCIL, 0);
       pf_z32 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z32_UNORM,
                                              PIPE_TEXTURE_2D,
-                                             PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+                                             PIPE_BIND_DEPTH_STENCIL, 0);
    } else {
       pf_z16 = FALSE;
       pf_z32 = FALSE;
@@ -288,12 +288,14 @@ dri_destroy_option_cache(struct dri_screen * screen)
 {
    int i;
 
-   for (i = 0; i < (1 << screen->optionCache.tableSize); ++i) {
-      FREE(screen->optionCache.info[i].name);
-      FREE(screen->optionCache.info[i].ranges);
+   if (screen->optionCache.info) {
+      for (i = 0; i < (1 << screen->optionCache.tableSize); ++i) {
+         FREE(screen->optionCache.info[i].name);
+         FREE(screen->optionCache.info[i].ranges);
+      }
+      FREE(screen->optionCache.info);
    }
 
-   FREE(screen->optionCache.info);
    FREE(screen->optionCache.values);
 }
 
diff --git a/src/gallium/state_trackers/dri/common/dri_st_api.c b/src/gallium/state_trackers/dri/common/dri_st_api.c
index 1a5259c68ba..261bae75a28 100644
--- a/src/gallium/state_trackers/dri/common/dri_st_api.c
+++ b/src/gallium/state_trackers/dri/common/dri_st_api.c
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
@@ -46,7 +47,7 @@ static boolean
 dri_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
                             const enum st_attachment_type *statts,
                             unsigned count,
-                            struct pipe_texture **out)
+                            struct pipe_resource **out)
 {
    struct dri_drawable *drawable =
       (struct dri_drawable *) stfbi->st_manager_private;
@@ -99,7 +100,7 @@ dri_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
 
    for (i = 0; i < count; i++) {
       out[i] = NULL;
-      pipe_texture_reference(&out[i], drawable->textures[statts[i]]);
+      pipe_resource_reference(&out[i], drawable->textures[statts[i]]);
    }
 
    return TRUE;
@@ -156,7 +157,7 @@ dri_destroy_st_framebuffer(struct st_framebuffer_iface *stfbi)
    int i;
 
    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
-      pipe_texture_reference(&drawable->textures[i], NULL);
+      pipe_resource_reference(&drawable->textures[i], NULL);
 
    FREE(stfbi);
 }
@@ -224,6 +225,31 @@ _dri_put_st_api(void)
    }
 }
 
+static boolean
+dri_st_manager_get_egl_image(struct st_manager *smapi,
+                             struct st_egl_image *stimg)
+{
+   __DRIimage *img = NULL;
+
+#ifndef __NOT_HAVE_DRM_H
+   if (!__dri1_api_hooks) {
+      struct dri_context *ctx = (struct dri_context *)
+         stimg->stctxi->st_manager_private;
+      img = dri2_lookup_egl_image(ctx, stimg->egl_image);
+   }
+#endif
+   if (!img)
+      return FALSE;
+
+   stimg->texture = NULL;
+   pipe_resource_reference(&stimg->texture, img->texture);
+   stimg->face = img->face;
+   stimg->level = img->level;
+   stimg->zslice = img->zslice;
+
+   return TRUE;
+}
+
 /**
  * Create a state tracker manager from the given screen.
  */
@@ -235,6 +261,7 @@ dri_create_st_manager(struct dri_screen *screen)
    smapi = CALLOC_STRUCT(st_manager);
    if (smapi) {
       smapi->screen = screen->pipe_screen;
+      smapi->get_egl_image = dri_st_manager_get_egl_image;
       _dri_get_st_api();
    }
 
diff --git a/src/gallium/state_trackers/dri/common/dri_st_api.h b/src/gallium/state_trackers/dri/common/dri_st_api.h
index 99a217bfa79..11d86cfbdf7 100644
--- a/src/gallium/state_trackers/dri/common/dri_st_api.h
+++ b/src/gallium/state_trackers/dri/common/dri_st_api.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
@@ -33,6 +34,15 @@
 struct dri_screen;
 struct dri_drawable;
 
+struct __DRIimageRec {
+   struct pipe_resource *texture;
+   unsigned face;
+   unsigned level;
+   unsigned zslice;
+
+   void *loader_private;
+};
+
 struct st_api *
 dri_get_st_api(void);
 
diff --git a/src/gallium/state_trackers/dri/drm/SConscript b/src/gallium/state_trackers/dri/drm/SConscript
index b9726ee3113..1dfaa402f2d 100644
--- a/src/gallium/state_trackers/dri/drm/SConscript
+++ b/src/gallium/state_trackers/dri/drm/SConscript
@@ -7,6 +7,8 @@ if env['dri']:
 
     env = env.Clone()
 
+    env.ParseConfig('pkg-config --cflags --libs libdrm')
+
     env.Append(CPPPATH = [
         '#/src/mesa',
 	'#/src/gallium/state_trackers/dri/common',
diff --git a/src/gallium/state_trackers/dri/drm/dri1.c b/src/gallium/state_trackers/dri/drm/dri1.c
index cca7cd8f0c3..3cac1557cad 100644
--- a/src/gallium/state_trackers/dri/drm/dri1.c
+++ b/src/gallium/state_trackers/dri/drm/dri1.c
@@ -172,7 +172,7 @@ dri1_swap_copy(struct pipe_context *pipe,
 
 static void
 dri1_present_texture_locked(__DRIdrawable * dPriv,
-                            struct pipe_texture *ptex,
+                            struct pipe_resource *ptex,
                             const struct drm_clip_rect *sub_box,
                             struct pipe_fence_handle **fence)
 {
@@ -216,7 +216,7 @@ dri1_present_texture_locked(__DRIdrawable * dPriv,
 
 static void
 dri1_copy_to_front(struct dri_context *ctx,
-		   struct pipe_texture *ptex,
+		   struct pipe_resource *ptex,
 		   __DRIdrawable * dPriv,
 		   const struct drm_clip_rect *sub_box,
 		   struct pipe_fence_handle **fence)
@@ -254,7 +254,7 @@ dri1_flush_frontbuffer(struct dri_drawable *draw,
    struct dri_screen *screen = dri_screen(draw->sPriv);
    struct pipe_screen *pipe_screen = screen->pipe_screen;
    struct pipe_fence_handle *dummy_fence;
-   struct pipe_texture *ptex;
+   struct pipe_resource *ptex;
 
    if (!ctx)
       return;			       /* For now */
@@ -278,7 +278,7 @@ dri1_swap_buffers(__DRIdrawable * dPriv)
    struct dri_screen *screen = dri_screen(draw->sPriv);
    struct pipe_screen *pipe_screen = screen->pipe_screen;
    struct pipe_fence_handle *fence;
-   struct pipe_texture *ptex;
+   struct pipe_resource *ptex;
 
    assert(__dri1_api_hooks != NULL);
 
@@ -308,7 +308,7 @@ dri1_copy_sub_buffer(__DRIdrawable * dPriv, int x, int y, int w, int h)
    struct drm_clip_rect sub_bbox;
    struct dri_drawable *draw = dri_drawable(dPriv);
    struct pipe_fence_handle *dummy_fence;
-   struct pipe_texture *ptex;
+   struct pipe_resource *ptex;
 
    assert(__dri1_api_hooks != NULL);
 
@@ -340,7 +340,7 @@ dri1_allocate_textures(struct dri_drawable *drawable,
                        unsigned mask)
 {
    struct dri_screen *screen = dri_screen(drawable->sPriv);
-   struct pipe_texture templ;
+   struct pipe_resource templ;
    unsigned width, height;
    boolean resized;
    int i;
@@ -354,7 +354,7 @@ dri1_allocate_textures(struct dri_drawable *drawable,
    /* remove outdated textures */
    if (resized) {
       for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
-         pipe_texture_reference(&drawable->textures[i], NULL);
+         pipe_resource_reference(&drawable->textures[i], NULL);
    }
 
    memset(&templ, 0, sizeof(templ));
@@ -379,12 +379,12 @@ dri1_allocate_textures(struct dri_drawable *drawable,
       case ST_ATTACHMENT_FRONT_RIGHT:
       case ST_ATTACHMENT_BACK_RIGHT:
          format = drawable->stvis.color_format;
-         tex_usage = PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                     PIPE_TEXTURE_USAGE_RENDER_TARGET;
+         tex_usage = PIPE_BIND_DISPLAY_TARGET |
+                     PIPE_BIND_RENDER_TARGET;
          break;
       case ST_ATTACHMENT_DEPTH_STENCIL:
          format = drawable->stvis.depth_stencil_format;
-         tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
+         tex_usage = PIPE_BIND_DEPTH_STENCIL;
          break;
       default:
          format = PIPE_FORMAT_NONE;
@@ -393,10 +393,10 @@ dri1_allocate_textures(struct dri_drawable *drawable,
 
       if (format != PIPE_FORMAT_NONE) {
          templ.format = format;
-         templ.tex_usage = tex_usage;
+         templ.bind = tex_usage;
 
          drawable->textures[i] =
-            screen->pipe_screen->texture_create(screen->pipe_screen, &templ);
+            screen->pipe_screen->resource_create(screen->pipe_screen, &templ);
       }
    }
 
diff --git a/src/gallium/state_trackers/dri/drm/dri2.c b/src/gallium/state_trackers/dri/drm/dri2.c
index c632f0fe4f3..c6655847e9c 100644
--- a/src/gallium/state_trackers/dri/drm/dri2.c
+++ b/src/gallium/state_trackers/dri/drm/dri2.c
@@ -77,16 +77,32 @@ dri2_set_tex_buffer2(__DRIcontext *pDRICtx, GLint target,
 {
    struct dri_context *ctx = dri_context(pDRICtx);
    struct dri_drawable *drawable = dri_drawable(dPriv);
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
 
    dri_st_framebuffer_validate_att(drawable->stfb, ST_ATTACHMENT_FRONT_LEFT);
 
    pt = drawable->textures[ST_ATTACHMENT_FRONT_LEFT];
 
    if (pt) {
+      enum pipe_format internal_format = pt->format;
+
+      if (format == __DRI_TEXTURE_FORMAT_RGB)  {
+         /* only need to cover the formats recognized by dri_fill_st_visual */
+         switch (internal_format) {
+         case PIPE_FORMAT_B8G8R8A8_UNORM:
+            internal_format = PIPE_FORMAT_B8G8R8X8_UNORM;
+            break;
+         case PIPE_FORMAT_A8R8G8B8_UNORM:
+            internal_format = PIPE_FORMAT_X8R8G8B8_UNORM;
+            break;
+         default:
+            break;
+         }
+      }
+
       ctx->st->teximage(ctx->st,
             (target == GL_TEXTURE_2D) ? ST_TEXTURE_2D : ST_TEXTURE_RECT,
-            0, drawable->stvis.color_format, pt, FALSE);
+            0, internal_format, pt, FALSE);
    }
 }
 
@@ -130,6 +146,7 @@ dri2_drawable_get_format(struct dri_drawable *drawable,
    return format;
 }
 
+
 /**
  * Retrieve __DRIbuffer from the DRI loader.
  */
@@ -235,7 +252,7 @@ dri2_drawable_get_buffers(struct dri_drawable *drawable,
 }
 
 /**
- * Process __DRIbuffer and convert them into pipe_textures.
+ * Process __DRIbuffer and convert them into pipe_resources.
  */
 static void
 dri2_drawable_process_buffers(struct dri_drawable *drawable,
@@ -243,7 +260,7 @@ dri2_drawable_process_buffers(struct dri_drawable *drawable,
 {
    struct dri_screen *screen = dri_screen(drawable->sPriv);
    __DRIdrawable *dri_drawable = drawable->dPriv;
-   struct pipe_texture templ;
+   struct pipe_resource templ;
    struct winsys_handle whandle;
    boolean have_depth = FALSE;
    unsigned i;
@@ -255,10 +272,10 @@ dri2_drawable_process_buffers(struct dri_drawable *drawable,
       return;
 
    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
-      pipe_texture_reference(&drawable->textures[i], NULL);
+      pipe_resource_reference(&drawable->textures[i], NULL);
 
    memset(&templ, 0, sizeof(templ));
-   templ.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
+   templ.bind = PIPE_BIND_RENDER_TARGET;
    templ.target = PIPE_TEXTURE_2D;
    templ.last_level = 0;
    templ.width0 = dri_drawable->w;
@@ -311,7 +328,7 @@ dri2_drawable_process_buffers(struct dri_drawable *drawable,
       whandle.stride = buf->pitch;
 
       drawable->textures[statt] =
-         screen->pipe_screen->texture_from_handle(screen->pipe_screen,
+         screen->pipe_screen->resource_from_handle(screen->pipe_screen,
                &templ, &whandle);
    }
 
@@ -352,6 +369,110 @@ dri2_flush_frontbuffer(struct dri_drawable *drawable,
    }
 }
 
+__DRIimage *
+dri2_lookup_egl_image(struct dri_context *ctx, void *handle)
+{
+   __DRIimageLookupExtension *loader = ctx->sPriv->dri2.image;
+   __DRIimage *img;
+
+   if (!loader->lookupEGLImage)
+      return NULL;
+
+   img = loader->lookupEGLImage(ctx->cPriv, handle, ctx->cPriv->loaderPrivate);
+
+   return img;
+}
+
+static __DRIimage *
+dri2_create_image_from_name(__DRIcontext *context,
+                            int width, int height, int format,
+                            int name, int pitch, void *loaderPrivate)
+{
+   struct dri_screen *screen = dri_screen(context->driScreenPriv);
+   __DRIimage *img;
+   struct pipe_resource templ;
+   struct winsys_handle whandle;
+   unsigned tex_usage;
+   enum pipe_format pf;
+
+   tex_usage = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
+
+   switch (format) {
+   case __DRI_IMAGE_FORMAT_RGB565:
+      pf = PIPE_FORMAT_B5G6R5_UNORM;
+      break;
+   case __DRI_IMAGE_FORMAT_XRGB8888:
+      pf = PIPE_FORMAT_B8G8R8X8_UNORM;
+      break;
+   case __DRI_IMAGE_FORMAT_ARGB8888:
+      pf = PIPE_FORMAT_B8G8R8A8_UNORM;
+      break;
+   default:
+      pf = PIPE_FORMAT_NONE;
+      break;
+   }
+   if (pf == PIPE_FORMAT_NONE)
+      return NULL;
+
+   img = CALLOC_STRUCT(__DRIimageRec);
+   if (!img)
+      return NULL;
+
+   memset(&templ, 0, sizeof(templ));
+   templ.bind = tex_usage;
+   templ.format = pf;
+   templ.target = PIPE_TEXTURE_2D;
+   templ.last_level = 0;
+   templ.width0 = width;
+   templ.height0 = height;
+   templ.depth0 = 1;
+
+   memset(&whandle, 0, sizeof(whandle));
+   whandle.handle = name;
+   whandle.stride = pitch * util_format_get_blocksize(pf);
+
+   img->texture = screen->pipe_screen->resource_from_handle(screen->pipe_screen,
+         &templ, &whandle);
+   if (!img->texture) {
+      FREE(img);
+      return NULL;
+   }
+
+   img->face = 0;
+   img->level = 0;
+   img->zslice = 0;
+   img->loader_private = loaderPrivate;
+
+   return img;
+}
+
+static __DRIimage *
+dri2_create_image_from_renderbuffer(__DRIcontext *context,
+				    int renderbuffer, void *loaderPrivate)
+{
+   struct dri_context *ctx = dri_context(context->driverPrivate);
+
+   if (!ctx->st->get_resource_for_egl_image)
+      return NULL;
+
+   /* TODO */
+   return NULL;
+}
+
+static void
+dri2_destroy_image(__DRIimage *img)
+{
+   pipe_resource_reference(&img->texture, NULL);
+   FREE(img);
+}
+
+static struct __DRIimageExtensionRec dri2ImageExtension = {
+    { __DRI_IMAGE, __DRI_IMAGE_VERSION },
+    dri2_create_image_from_name,
+    dri2_create_image_from_renderbuffer,
+    dri2_destroy_image,
+};
+
 /*
  * Backend function init_screen.
  */
@@ -364,6 +485,7 @@ static const __DRIextension *dri_screen_extensions[] = {
    &driMediaStreamCounterExtension.base,
    &dri2TexBufferExtension.base,
    &dri2FlushExtension.base,
+   &dri2ImageExtension.base,
    NULL
 };
 
diff --git a/src/gallium/state_trackers/dri/drm/dri2.h b/src/gallium/state_trackers/dri/drm/dri2.h
index 379963431fb..5b28850000b 100644
--- a/src/gallium/state_trackers/dri/drm/dri2.h
+++ b/src/gallium/state_trackers/dri/drm/dri2.h
@@ -43,4 +43,7 @@ dri2_allocate_textures(struct dri_drawable *drawable,
                        const enum st_attachment_type *statts,
                        unsigned count);
 
+__DRIimage *
+dri2_lookup_egl_image(struct dri_context *ctx, void *handle);
+
 #endif /* DRI2_H */
diff --git a/src/gallium/state_trackers/dri/sw/drisw.c b/src/gallium/state_trackers/dri/sw/drisw.c
index 42fa789aaf7..9106f0d5eb4 100644
--- a/src/gallium/state_trackers/dri/sw/drisw.c
+++ b/src/gallium/state_trackers/dri/sw/drisw.c
@@ -89,7 +89,7 @@ drisw_put_image(struct dri_drawable *drawable,
 
 static INLINE void
 drisw_present_texture(__DRIdrawable *dPriv,
-                      struct pipe_texture *ptex)
+                      struct pipe_resource *ptex)
 {
    struct dri_drawable *drawable = dri_drawable(dPriv);
    struct dri_screen *screen = dri_screen(drawable->sPriv);
@@ -117,7 +117,7 @@ drisw_invalidate_drawable(__DRIdrawable *dPriv)
 
 static INLINE void
 drisw_copy_to_front(__DRIdrawable * dPriv,
-                    struct pipe_texture *ptex)
+                    struct pipe_resource *ptex)
 {
    drisw_present_texture(dPriv, ptex);
 
@@ -133,7 +133,7 @@ drisw_swap_buffers(__DRIdrawable *dPriv)
 {
    struct dri_context *ctx = dri_get_current();
    struct dri_drawable *drawable = dri_drawable(dPriv);
-   struct pipe_texture *ptex;
+   struct pipe_resource *ptex;
 
    if (!ctx)
       return;
@@ -152,7 +152,7 @@ drisw_flush_frontbuffer(struct dri_drawable *drawable,
                         enum st_attachment_type statt)
 {
    struct dri_context *ctx = dri_get_current();
-   struct pipe_texture *ptex;
+   struct pipe_resource *ptex;
 
    if (!ctx)
       return;
@@ -180,7 +180,7 @@ drisw_allocate_textures(struct dri_drawable *drawable,
                         unsigned mask)
 {
    struct dri_screen *screen = dri_screen(drawable->sPriv);
-   struct pipe_texture templ;
+   struct pipe_resource templ;
    unsigned width, height;
    boolean resized;
    int i;
@@ -194,7 +194,7 @@ drisw_allocate_textures(struct dri_drawable *drawable,
    /* remove outdated textures */
    if (resized) {
       for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
-         pipe_texture_reference(&drawable->textures[i], NULL);
+         pipe_resource_reference(&drawable->textures[i], NULL);
    }
 
    memset(&templ, 0, sizeof(templ));
@@ -219,12 +219,12 @@ drisw_allocate_textures(struct dri_drawable *drawable,
       case ST_ATTACHMENT_FRONT_RIGHT:
       case ST_ATTACHMENT_BACK_RIGHT:
          format = drawable->stvis.color_format;
-         tex_usage = PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                     PIPE_TEXTURE_USAGE_RENDER_TARGET;
+         tex_usage = PIPE_BIND_DISPLAY_TARGET |
+                     PIPE_BIND_RENDER_TARGET;
          break;
       case ST_ATTACHMENT_DEPTH_STENCIL:
          format = drawable->stvis.depth_stencil_format;
-         tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
+         tex_usage = PIPE_BIND_DEPTH_STENCIL;
          break;
       default:
          format = PIPE_FORMAT_NONE;
@@ -233,10 +233,10 @@ drisw_allocate_textures(struct dri_drawable *drawable,
 
       if (format != PIPE_FORMAT_NONE) {
          templ.format = format;
-         templ.tex_usage = tex_usage;
+         templ.bind = tex_usage;
 
          drawable->textures[i] =
-            screen->pipe_screen->texture_create(screen->pipe_screen, &templ);
+            screen->pipe_screen->resource_create(screen->pipe_screen, &templ);
       }
    }
 
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.c b/src/gallium/state_trackers/egl/common/egl_g3d.c
index 5eabe10558a..3ab72dce2f3 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d.c
+++ b/src/gallium/state_trackers/egl/common/egl_g3d.c
@@ -14,70 +14,28 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-#include "pipe/p_screen.h"
-#include "util/u_memory.h"
-#include "util/u_rect.h"
-#include "util/u_inlines.h"
 #include "egldriver.h"
 #include "eglcurrent.h"
-#include "eglconfigutil.h"
 #include "egllog.h"
 
-#include "native.h"
+#include "pipe/p_screen.h"
+#include "util/u_memory.h"
+#include "util/u_format.h"
+#include "util/u_string.h"
+
 #include "egl_g3d.h"
+#include "egl_g3d_api.h"
 #include "egl_g3d_st.h"
-#include "egl_g3d_image.h"
-
-/**
- * Return the state tracker for the given context.
- */
-static struct st_api *
-egl_g3d_choose_st(_EGLDriver *drv, _EGLContext *ctx)
-{
-   struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
-   struct st_api *stapi;
-   EGLint idx = -1;
-
-   switch (ctx->ClientAPI) {
-   case EGL_OPENGL_ES_API:
-      switch (ctx->ClientVersion) {
-      case 1:
-         idx = ST_API_OPENGL_ES1;
-         break;
-      case 2:
-         idx = ST_API_OPENGL_ES2;
-         break;
-      default:
-         _eglLog(_EGL_WARNING, "unknown client version %d",
-               ctx->ClientVersion);
-         break;
-      }
-      break;
-   case EGL_OPENVG_API:
-      idx = ST_API_OPENVG;
-      break;
-   case EGL_OPENGL_API:
-      idx = ST_API_OPENGL;
-      break;
-   default:
-      _eglLog(_EGL_WARNING, "unknown client API 0x%04x", ctx->ClientAPI);
-      break;
-   }
-
-   stapi = (idx >= 0) ? gdrv->stapis[idx] : NULL;
-   return stapi;
-}
+#include "native.h"
 
 /**
  * Initialize the state trackers.
@@ -157,7 +115,7 @@ egl_g3d_add_screens(_EGLDriver *drv, _EGLDisplay *dpy)
       gdpy->native->modeset->get_connectors(gdpy->native, &num_connectors, NULL);
    if (!num_connectors) {
       if (native_connectors)
-         free(native_connectors);
+         FREE(native_connectors);
       return;
    }
 
@@ -172,13 +130,13 @@ egl_g3d_add_screens(_EGLDriver *drv, _EGLDisplay *dpy)
          gdpy->native->modeset->get_modes(gdpy->native, nconn, &num_modes);
       if (!num_modes) {
          if (native_modes)
-            free(native_modes);
+            FREE(native_modes);
          continue;
       }
 
       gscr = CALLOC_STRUCT(egl_g3d_screen);
       if (!gscr) {
-         free(native_modes);
+         FREE(native_modes);
          continue;
       }
 
@@ -202,41 +160,137 @@ egl_g3d_add_screens(_EGLDriver *drv, _EGLDisplay *dpy)
       _eglAddScreen(dpy, &gscr->base);
    }
 
-   free(native_connectors);
+   FREE(native_connectors);
 }
 
 #endif /* EGL_MESA_screen_surface */
 
 /**
+ * Initialize and validate the EGL config attributes.
+ */
+static EGLBoolean
+init_config_attributes(_EGLConfig *conf, const struct native_config *nconf,
+                       EGLint api_mask, enum pipe_format depth_stencil_format)
+{
+   uint rgba[4], depth_stencil[2], buffer_size;
+   EGLint surface_type;
+   EGLint i;
+
+   /* get the color and depth/stencil component sizes */
+   assert(nconf->color_format != PIPE_FORMAT_NONE);
+   buffer_size = 0;
+   for (i = 0; i < 4; i++) {
+      rgba[i] = util_format_get_component_bits(nconf->color_format,
+            UTIL_FORMAT_COLORSPACE_RGB, i);
+      buffer_size += rgba[i];
+   }
+   for (i = 0; i < 2; i++) {
+      if (depth_stencil_format != PIPE_FORMAT_NONE) {
+         depth_stencil[i] =
+            util_format_get_component_bits(depth_stencil_format,
+               UTIL_FORMAT_COLORSPACE_ZS, i);
+      }
+      else {
+         depth_stencil[i] = 0;
+      }
+   }
+
+   surface_type = 0x0;
+   if (nconf->window_bit)
+      surface_type |= EGL_WINDOW_BIT;
+   if (nconf->pixmap_bit)
+      surface_type |= EGL_PIXMAP_BIT;
+#ifdef EGL_MESA_screen_surface
+   if (nconf->scanout_bit)
+      surface_type |= EGL_SCREEN_BIT_MESA;
+#endif
+
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT))
+      surface_type |= EGL_PBUFFER_BIT;
+
+   SET_CONFIG_ATTRIB(conf, EGL_CONFORMANT, api_mask);
+   SET_CONFIG_ATTRIB(conf, EGL_RENDERABLE_TYPE, api_mask);
+
+   SET_CONFIG_ATTRIB(conf, EGL_RED_SIZE, rgba[0]);
+   SET_CONFIG_ATTRIB(conf, EGL_GREEN_SIZE, rgba[1]);
+   SET_CONFIG_ATTRIB(conf, EGL_BLUE_SIZE, rgba[2]);
+   SET_CONFIG_ATTRIB(conf, EGL_ALPHA_SIZE, rgba[3]);
+   SET_CONFIG_ATTRIB(conf, EGL_BUFFER_SIZE, buffer_size);
+
+   SET_CONFIG_ATTRIB(conf, EGL_DEPTH_SIZE, depth_stencil[0]);
+   SET_CONFIG_ATTRIB(conf, EGL_STENCIL_SIZE, depth_stencil[1]);
+
+   SET_CONFIG_ATTRIB(conf, EGL_SURFACE_TYPE, surface_type);
+
+   SET_CONFIG_ATTRIB(conf, EGL_NATIVE_RENDERABLE, EGL_TRUE);
+   if (surface_type & EGL_WINDOW_BIT) {
+      SET_CONFIG_ATTRIB(conf, EGL_NATIVE_VISUAL_ID, nconf->native_visual_id);
+      SET_CONFIG_ATTRIB(conf, EGL_NATIVE_VISUAL_TYPE,
+            nconf->native_visual_type);
+   }
+
+   if (surface_type & EGL_PBUFFER_BIT) {
+      SET_CONFIG_ATTRIB(conf, EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE);
+      if (rgba[3])
+         SET_CONFIG_ATTRIB(conf, EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE);
+
+      SET_CONFIG_ATTRIB(conf, EGL_MAX_PBUFFER_WIDTH, 4096);
+      SET_CONFIG_ATTRIB(conf, EGL_MAX_PBUFFER_HEIGHT, 4096);
+      SET_CONFIG_ATTRIB(conf, EGL_MAX_PBUFFER_PIXELS, 4096 * 4096);
+   }
+
+   SET_CONFIG_ATTRIB(conf, EGL_LEVEL, nconf->level);
+   SET_CONFIG_ATTRIB(conf, EGL_SAMPLES, nconf->samples);
+   SET_CONFIG_ATTRIB(conf, EGL_SAMPLE_BUFFERS, 1);
+
+   if (nconf->slow_config)
+      SET_CONFIG_ATTRIB(conf, EGL_CONFIG_CAVEAT, EGL_SLOW_CONFIG);
+
+   if (nconf->transparent_rgb) {
+      rgba[0] = nconf->transparent_rgb_values[0];
+      rgba[1] = nconf->transparent_rgb_values[1];
+      rgba[2] = nconf->transparent_rgb_values[2];
+
+      SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_TYPE, EGL_TRANSPARENT_RGB);
+      SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_RED_VALUE, rgba[0]);
+      SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_GREEN_VALUE, rgba[1]);
+      SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_BLUE_VALUE, rgba[2]);
+   }
+
+   return _eglValidateConfig(conf, EGL_FALSE);
+}
+
+/**
  * Initialize an EGL config from the native config.
  */
 static EGLBoolean
 egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy,
-                    _EGLConfig *conf, const struct native_config *nconf)
+                    _EGLConfig *conf, const struct native_config *nconf,
+                    enum pipe_format depth_stencil_format)
 {
    struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
    struct egl_g3d_config *gconf = egl_g3d_config(conf);
-   const __GLcontextModes *mode = &nconf->mode;
    EGLint buffer_mask, api_mask;
    EGLBoolean valid;
    EGLint i;
 
-   buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
-   if (mode->doubleBufferMode)
+   buffer_mask = 0x0;
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_FRONT_LEFT))
+      buffer_mask |= ST_ATTACHMENT_FRONT_LEFT_MASK;
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT))
       buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
-   if (mode->stereoMode) {
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_FRONT_RIGHT))
       buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK;
-      if (mode->doubleBufferMode)
-         buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
-   }
+   if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_RIGHT))
+      buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
 
    gconf->stvis.buffer_mask = buffer_mask;
    gconf->stvis.color_format = nconf->color_format;
-   gconf->stvis.depth_stencil_format = nconf->depth_format;
+   gconf->stvis.depth_stencil_format = depth_stencil_format;
    gconf->stvis.accum_format = PIPE_FORMAT_NONE;
-   gconf->stvis.samples = 0;
+   gconf->stvis.samples = nconf->samples;
 
-   gconf->stvis.render_buffer = (buffer_mask & ST_ATTACHMENT_BACK_LEFT) ?
+   gconf->stvis.render_buffer = (buffer_mask & ST_ATTACHMENT_BACK_LEFT_MASK) ?
       ST_ATTACHMENT_BACK_LEFT : ST_ATTACHMENT_FRONT_LEFT;
 
    api_mask = 0;
@@ -248,29 +302,19 @@ egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy,
       }
    }
    /* this is required by EGL, not by OpenGL ES */
-   if ((mode->drawableType & GLX_WINDOW_BIT) && !mode->doubleBufferMode)
+   if (nconf->window_bit &&
+       gconf->stvis.render_buffer != ST_ATTACHMENT_BACK_LEFT)
       api_mask &= ~(EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT);
 
    if (!api_mask) {
       _eglLog(_EGL_DEBUG, "no state tracker supports config 0x%x",
-            mode->visualID);
+            nconf->native_visual_id);
    }
 
-   valid = _eglConfigFromContextModesRec(&gconf->base,
-         mode, api_mask, api_mask);
-   if (valid) {
-#ifdef EGL_MESA_screen_surface
-      /* check if scanout surface bit is set */
-      if (nconf->scanout_bit) {
-         EGLint val = GET_CONFIG_ATTRIB(&gconf->base, EGL_SURFACE_TYPE);
-         val |= EGL_SCREEN_BIT_MESA;
-         SET_CONFIG_ATTRIB(&gconf->base, EGL_SURFACE_TYPE, val);
-      }
-#endif
-      valid = _eglValidateConfig(&gconf->base, EGL_FALSE);
-   }
+   valid = init_config_attributes(&gconf->base,
+         nconf, api_mask, depth_stencil_format);
    if (!valid) {
-      _eglLog(_EGL_DEBUG, "skip invalid config 0x%x", mode->visualID);
+      _eglLog(_EGL_DEBUG, "skip invalid config 0x%x", nconf->native_visual_id);
       return EGL_FALSE;
    }
 
@@ -280,6 +324,46 @@ egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy,
 }
 
 /**
+ * Get all interested depth/stencil formats of a display.
+ */
+static EGLint
+egl_g3d_fill_depth_stencil_formats(_EGLDisplay *dpy,
+                                   enum pipe_format formats[8])
+{
+   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
+   struct pipe_screen *screen = gdpy->native->screen;
+   const EGLint candidates[] = {
+      1, PIPE_FORMAT_Z16_UNORM,
+      1, PIPE_FORMAT_Z32_UNORM,
+      2, PIPE_FORMAT_Z24_UNORM_S8_USCALED, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
+      2, PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_X8Z24_UNORM,
+      0
+   };
+   const EGLint *fmt = candidates;
+   EGLint count;
+
+   count = 0;
+   formats[count++] = PIPE_FORMAT_NONE;
+
+   while (*fmt) {
+      EGLint i, n = *fmt++;
+
+      /* pick the first supported format */
+      for (i = 0; i < n; i++) {
+         if (screen->is_format_supported(screen, fmt[i],
+                  PIPE_TEXTURE_2D, PIPE_BIND_DEPTH_STENCIL, 0)) {
+            formats[count++] = fmt[i];
+            break;
+         }
+      }
+
+      fmt += n;
+   }
+
+   return count;
+}
+
+/**
  * Add configs to display and return the next config ID.
  */
 static EGLint
@@ -287,32 +371,39 @@ egl_g3d_add_configs(_EGLDriver *drv, _EGLDisplay *dpy, EGLint id)
 {
    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
    const struct native_config **native_configs;
-   int num_configs, i;
+   enum pipe_format depth_stencil_formats[8];
+   int num_formats, num_configs, i, j;
 
    native_configs = gdpy->native->get_configs(gdpy->native, &num_configs);
    if (!num_configs) {
       if (native_configs)
-         free(native_configs);
+         FREE(native_configs);
       return id;
    }
 
+   num_formats = egl_g3d_fill_depth_stencil_formats(dpy,
+         depth_stencil_formats);
+
    for (i = 0; i < num_configs; i++) {
-      struct egl_g3d_config *gconf;
-
-      gconf = CALLOC_STRUCT(egl_g3d_config);
-      if (gconf) {
-         _eglInitConfig(&gconf->base, dpy, id);
-         if (!egl_g3d_init_config(drv, dpy, &gconf->base, native_configs[i])) {
-            free(gconf);
-            continue;
+      for (j = 0; j < num_formats; j++) {
+         struct egl_g3d_config *gconf;
+
+         gconf = CALLOC_STRUCT(egl_g3d_config);
+         if (gconf) {
+            _eglInitConfig(&gconf->base, dpy, id);
+            if (!egl_g3d_init_config(drv, dpy, &gconf->base,
+                     native_configs[i], depth_stencil_formats[j])) {
+               FREE(gconf);
+               break;
+            }
+
+            _eglAddConfig(dpy, &gconf->base);
+            id++;
          }
-
-         _eglAddConfig(dpy, &gconf->base);
-         id++;
       }
    }
 
-   free(native_configs);
+   FREE(native_configs);
    return id;
 }
 
@@ -353,10 +444,10 @@ egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
    if (dpy->Screens) {
       for (i = 0; i < dpy->NumScreens; i++) {
          struct egl_g3d_screen *gscr = egl_g3d_screen(dpy->Screens[i]);
-         free(gscr->native_modes);
-         free(gscr);
+         FREE(gscr->native_modes);
+         FREE(gscr);
       }
-      free(dpy->Screens);
+      FREE(dpy->Screens);
    }
 
    if (gdpy->smapi)
@@ -365,7 +456,7 @@ egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
    if (gdpy->native)
       gdpy->native->destroy(gdpy->native);
 
-   free(gdpy);
+   FREE(gdpy);
    dpy->DriverData = NULL;
 
    return EGL_TRUE;
@@ -435,456 +526,6 @@ fail:
    return EGL_FALSE;
 }
 
-static _EGLContext *
-egl_g3d_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
-                       _EGLContext *share, const EGLint *attribs)
-{
-   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
-   struct egl_g3d_context *gshare = egl_g3d_context(share);
-   struct egl_g3d_config *gconf = egl_g3d_config(conf);
-   struct egl_g3d_context *gctx;
-
-   gctx = CALLOC_STRUCT(egl_g3d_context);
-   if (!gctx) {
-      _eglError(EGL_BAD_ALLOC, "eglCreateContext");
-      return NULL;
-   }
-
-   if (!_eglInitContext(&gctx->base, dpy, conf, attribs)) {
-      free(gctx);
-      return NULL;
-   }
-
-   gctx->stapi = egl_g3d_choose_st(drv, &gctx->base);
-   if (!gctx->stapi) {
-      free(gctx);
-      return NULL;
-   }
-
-   gctx->stctxi = gctx->stapi->create_context(gctx->stapi, gdpy->smapi,
-         &gconf->stvis, (gshare) ? gshare->stctxi : NULL);
-   if (!gctx->stctxi) {
-      free(gctx);
-      return NULL;
-   }
-
-   gctx->stctxi->st_manager_private = (void *) &gctx->base;
-
-   return &gctx->base;
-}
-
-/**
- * Destroy a context.
- */
-static void
-destroy_context(_EGLDisplay *dpy, _EGLContext *ctx)
-{
-   struct egl_g3d_context *gctx = egl_g3d_context(ctx);
-
-   /* FIXME a context might live longer than its display */
-   if (!dpy->Initialized)
-      _eglLog(_EGL_FATAL, "destroy a context with an unitialized display");
-
-   gctx->stctxi->destroy(gctx->stctxi);
-
-   free(gctx);
-}
-
-static EGLBoolean
-egl_g3d_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
-{
-   if (!_eglIsContextBound(ctx))
-      destroy_context(dpy, ctx);
-   return EGL_TRUE;
-}
-
-struct egl_g3d_create_surface_arg {
-   EGLint type;
-   union {
-      EGLNativeWindowType win;
-      EGLNativePixmapType pix;
-   } u;
-};
-
-static _EGLSurface *
-egl_g3d_create_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
-                       struct egl_g3d_create_surface_arg *arg,
-                       const EGLint *attribs)
-{
-   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
-   struct egl_g3d_config *gconf = egl_g3d_config(conf);
-   struct egl_g3d_surface *gsurf;
-   struct native_surface *nsurf;
-   const char *err;
-
-   switch (arg->type) {
-   case EGL_WINDOW_BIT:
-      err = "eglCreateWindowSurface";
-      break;
-   case EGL_PIXMAP_BIT:
-      err = "eglCreatePixmapSurface";
-      break;
-   case EGL_PBUFFER_BIT:
-      err = "eglCreatePBufferSurface";
-      break;
-#ifdef EGL_MESA_screen_surface
-   case EGL_SCREEN_BIT_MESA:
-      err = "eglCreateScreenSurface";
-      break;
-#endif
-   default:
-      err = "eglCreateUnknownSurface";
-      break;
-   }
-
-   gsurf = CALLOC_STRUCT(egl_g3d_surface);
-   if (!gsurf) {
-      _eglError(EGL_BAD_ALLOC, err);
-      return NULL;
-   }
-
-   if (!_eglInitSurface(&gsurf->base, dpy, arg->type, conf, attribs)) {
-      free(gsurf);
-      return NULL;
-   }
-
-   /* create the native surface */
-   switch (arg->type) {
-   case EGL_WINDOW_BIT:
-      nsurf = gdpy->native->create_window_surface(gdpy->native,
-            arg->u.win, gconf->native);
-      break;
-   case EGL_PIXMAP_BIT:
-      nsurf = gdpy->native->create_pixmap_surface(gdpy->native,
-            arg->u.pix, gconf->native);
-      break;
-   case EGL_PBUFFER_BIT:
-      nsurf = gdpy->native->create_pbuffer_surface(gdpy->native,
-            gconf->native, gsurf->base.Width, gsurf->base.Height);
-      break;
-#ifdef EGL_MESA_screen_surface
-   case EGL_SCREEN_BIT_MESA:
-      /* prefer back buffer (move to _eglInitSurface?) */
-      gsurf->base.RenderBuffer = EGL_BACK_BUFFER;
-      nsurf = gdpy->native->modeset->create_scanout_surface(gdpy->native,
-            gconf->native, gsurf->base.Width, gsurf->base.Height);
-      break;
-#endif
-   default:
-      nsurf = NULL;
-      break;
-   }
-
-   if (!nsurf) {
-      free(gsurf);
-      return NULL;
-   }
-   /* initialize the geometry */
-   if (!nsurf->validate(nsurf, 0x0, &gsurf->sequence_number, NULL,
-            &gsurf->base.Width, &gsurf->base.Height)) {
-      nsurf->destroy(nsurf);
-      free(gsurf);
-      return NULL;
-   }
-
-   gsurf->stvis = gconf->stvis;
-   if (gsurf->base.RenderBuffer == EGL_SINGLE_BUFFER)
-      gsurf->stvis.render_buffer = ST_ATTACHMENT_FRONT_LEFT;
-
-   gsurf->stfbi = egl_g3d_create_st_framebuffer(&gsurf->base);
-   if (!gsurf->stfbi) {
-      gsurf->native->destroy(gsurf->native);
-      free(gsurf);
-      return NULL;
-   }
-
-   nsurf->user_data = &gsurf->base;
-   gsurf->native = nsurf;
-
-   return &gsurf->base;
-}
-
-static _EGLSurface *
-egl_g3d_create_window_surface(_EGLDriver *drv, _EGLDisplay *dpy,
-                              _EGLConfig *conf, EGLNativeWindowType win,
-                              const EGLint *attribs)
-{
-   struct egl_g3d_create_surface_arg arg;
-
-   memset(&arg, 0, sizeof(arg));
-   arg.type = EGL_WINDOW_BIT;
-   arg.u.win = win;
-
-   return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
-}
-
-static _EGLSurface *
-egl_g3d_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *dpy,
-                              _EGLConfig *conf, EGLNativePixmapType pix,
-                              const EGLint *attribs)
-{
-   struct egl_g3d_create_surface_arg arg;
-
-   memset(&arg, 0, sizeof(arg));
-   arg.type = EGL_PIXMAP_BIT;
-   arg.u.pix = pix;
-
-   return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
-}
-
-static _EGLSurface *
-egl_g3d_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy,
-                               _EGLConfig *conf, const EGLint *attribs)
-{
-   struct egl_g3d_create_surface_arg arg;
-
-   memset(&arg, 0, sizeof(arg));
-   arg.type = EGL_PBUFFER_BIT;
-
-   return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
-}
-
-/**
- * Destroy a surface.
- */
-static void
-destroy_surface(_EGLDisplay *dpy, _EGLSurface *surf)
-{
-   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
-
-   /* FIXME a surface might live longer than its display */
-   if (!dpy->Initialized)
-      _eglLog(_EGL_FATAL, "destroy a surface with an unitialized display");
-
-   pipe_texture_reference(&gsurf->render_texture, NULL);
-   egl_g3d_destroy_st_framebuffer(gsurf->stfbi);
-   gsurf->native->destroy(gsurf->native);
-   free(gsurf);
-}
-
-static EGLBoolean
-egl_g3d_destroy_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
-{
-   if (!_eglIsSurfaceBound(surf))
-      destroy_surface(dpy, surf);
-   return EGL_TRUE;
-}
-
-static EGLBoolean
-egl_g3d_make_current(_EGLDriver *drv, _EGLDisplay *dpy,
-                     _EGLSurface *draw, _EGLSurface *read, _EGLContext *ctx)
-{
-   struct egl_g3d_context *gctx = egl_g3d_context(ctx);
-   struct egl_g3d_surface *gdraw = egl_g3d_surface(draw);
-   struct egl_g3d_surface *gread = egl_g3d_surface(read);
-   struct egl_g3d_context *old_gctx;
-   EGLBoolean ok = EGL_TRUE;
-
-   /* bind the new context and return the "orphaned" one */
-   if (!_eglBindContext(&ctx, &draw, &read))
-      return EGL_FALSE;
-   old_gctx = egl_g3d_context(ctx);
-
-   if (old_gctx) {
-      /* flush old context */
-      old_gctx->stctxi->flush(old_gctx->stctxi,
-            PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
-   }
-
-   if (gctx) {
-      ok = gctx->stapi->make_current(gctx->stapi, gctx->stctxi,
-            (gdraw) ? gdraw->stfbi : NULL, (gread) ? gread->stfbi : NULL);
-      if (ok) {
-         gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, gdraw->stfbi);
-         if (gread != gdraw) {
-            gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi,
-                  gread->stfbi);
-         }
-
-         if (gdraw->base.Type == EGL_WINDOW_BIT) {
-            gctx->base.WindowRenderBuffer =
-               (gdraw->stvis.render_buffer == ST_ATTACHMENT_FRONT_LEFT) ?
-               EGL_SINGLE_BUFFER : EGL_BACK_BUFFER;
-         }
-      }
-   }
-   else if (old_gctx) {
-      ok = old_gctx->stapi->make_current(old_gctx->stapi, NULL, NULL, NULL);
-      old_gctx->base.WindowRenderBuffer = EGL_NONE;
-   }
-
-   if (ctx && !_eglIsContextLinked(ctx))
-      destroy_context(dpy, ctx);
-   if (draw && !_eglIsSurfaceLinked(draw))
-      destroy_surface(dpy, draw);
-   if (read && read != draw && !_eglIsSurfaceLinked(read))
-      destroy_surface(dpy, read);
-
-   return ok;
-}
-
-static EGLBoolean
-egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
-{
-   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
-   _EGLContext *ctx = _eglGetCurrentContext();
-   struct egl_g3d_context *gctx = NULL;
-
-   /* no-op for pixmap or pbuffer surface */
-   if (gsurf->base.Type == EGL_PIXMAP_BIT ||
-       gsurf->base.Type == EGL_PBUFFER_BIT)
-      return EGL_TRUE;
-
-   /* or when the surface is single-buffered */
-   if (gsurf->stvis.render_buffer == ST_ATTACHMENT_FRONT_LEFT)
-      return EGL_TRUE;
-
-   if (ctx && ctx->DrawSurface == surf)
-      gctx = egl_g3d_context(ctx);
-
-   /* flush if the surface is current */
-   if (gctx) {
-      gctx->stctxi->flush(gctx->stctxi,
-            PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
-   }
-
-   return gsurf->native->swap_buffers(gsurf->native);
-}
-
-/**
- * Find a config that supports the pixmap.
- */
-_EGLConfig *
-egl_g3d_find_pixmap_config(_EGLDisplay *dpy, EGLNativePixmapType pix)
-{
-   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
-   struct egl_g3d_config *gconf;
-   EGLint i;
-
-   for (i = 0; i < dpy->NumConfigs; i++) {
-      gconf = egl_g3d_config(dpy->Configs[i]);
-      if (gdpy->native->is_pixmap_supported(gdpy->native, pix, gconf->native))
-         break;
-   }
-
-   return (i < dpy->NumConfigs) ? &gconf->base : NULL;
-}
-
-/**
- * Get the pipe surface of the given attachment of the native surface.
- */
-static struct pipe_surface *
-get_pipe_surface(struct native_display *ndpy, struct native_surface *nsurf,
-                 enum native_attachment natt)
-{
-   struct pipe_texture *textures[NUM_NATIVE_ATTACHMENTS];
-   struct pipe_surface *psurf;
-
-   textures[natt] = NULL;
-   nsurf->validate(nsurf, 1 << natt, NULL, textures, NULL, NULL);
-   if (!textures[natt])
-      return NULL;
-
-   psurf = ndpy->screen->get_tex_surface(ndpy->screen, textures[natt],
-         0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
-   pipe_texture_reference(&textures[natt], NULL);
-
-   return psurf;
-}
-
-static EGLBoolean
-egl_g3d_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
-                     EGLNativePixmapType target)
-{
-   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
-   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
-   _EGLContext *ctx = _eglGetCurrentContext();
-   struct egl_g3d_config *gconf;
-   struct native_surface *nsurf;
-   struct pipe_screen *screen = gdpy->native->screen;
-   struct pipe_surface *psurf;
-
-   if (!gsurf->render_texture)
-      return EGL_TRUE;
-
-   gconf = egl_g3d_config(egl_g3d_find_pixmap_config(dpy, target));
-   if (!gconf)
-      return _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCopyBuffers");
-
-   nsurf = gdpy->native->create_pixmap_surface(gdpy->native,
-         target, gconf->native);
-   if (!nsurf)
-      return _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCopyBuffers");
-
-   /* flush if the surface is current */
-   if (ctx && ctx->DrawSurface == &gsurf->base) {
-      struct egl_g3d_context *gctx = egl_g3d_context(ctx);
-      gctx->stctxi->flush(gctx->stctxi,
-            PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
-   }
-
-   /* create a pipe context to copy surfaces */
-   if (!gdpy->pipe) {
-      gdpy->pipe =
-         gdpy->native->screen->context_create(gdpy->native->screen, NULL);
-      if (!gdpy->pipe)
-         return EGL_FALSE;
-   }
-
-   psurf = get_pipe_surface(gdpy->native, nsurf, NATIVE_ATTACHMENT_FRONT_LEFT);
-   if (psurf) {
-      struct pipe_surface *psrc;
-
-      psrc = screen->get_tex_surface(screen, gsurf->render_texture,
-            0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ);
-      if (psrc) {
-         gdpy->pipe->surface_copy(gdpy->pipe, psurf, 0, 0,
-               psrc, 0, 0, psurf->width, psurf->height);
-         pipe_surface_reference(&psrc, NULL);
-
-         nsurf->flush_frontbuffer(nsurf);
-      }
-
-      pipe_surface_reference(&psurf, NULL);
-   }
-
-   nsurf->destroy(nsurf);
-
-   return EGL_TRUE;
-}
-
-static EGLBoolean
-egl_g3d_wait_client(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
-{
-   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
-   struct egl_g3d_context *gctx = egl_g3d_context(ctx);
-   struct pipe_screen *screen = gdpy->native->screen;
-   struct pipe_fence_handle *fence = NULL;
-
-   gctx->stctxi->flush(gctx->stctxi,
-         PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence);
-   screen->fence_finish(screen, fence, 0);
-   screen->fence_reference(screen, &fence, NULL);
-
-   return EGL_TRUE;
-}
-
-static EGLBoolean
-egl_g3d_wait_native(_EGLDriver *drv, _EGLDisplay *dpy, EGLint engine)
-{
-   _EGLContext *ctx = _eglGetCurrentContext();
-
-   if (engine != EGL_CORE_NATIVE_ENGINE)
-      return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
-
-   if (ctx && ctx->DrawSurface) {
-      struct egl_g3d_surface *gsurf = egl_g3d_surface(ctx->DrawSurface);
-      gsurf->native->wait(gsurf->native);
-   }
-
-   return EGL_TRUE;
-}
-
 static _EGLProc
 egl_g3d_get_proc_address(_EGLDriver *drv, const char *procname)
 {
@@ -907,165 +548,6 @@ egl_g3d_get_proc_address(_EGLDriver *drv, const char *procname)
    return (_EGLProc) NULL;
 }
 
-static EGLBoolean
-egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
-                       _EGLSurface *surf, EGLint buffer)
-{
-   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
-   _EGLContext *es1 = _eglGetAPIContext(EGL_OPENGL_ES_API);
-   struct egl_g3d_context *gctx;
-   enum pipe_format internal_format;
-   enum st_texture_type target;
-
-   if (!gsurf || gsurf->base.Type != EGL_PBUFFER_BIT)
-      return _eglError(EGL_BAD_SURFACE, "eglBindTexImage");
-   if (buffer != EGL_BACK_BUFFER)
-      return _eglError(EGL_BAD_PARAMETER, "eglBindTexImage");
-   if (gsurf->base.BoundToTexture)
-      return _eglError(EGL_BAD_ACCESS, "eglBindTexImage");
-
-   switch (gsurf->base.TextureFormat) {
-   case EGL_TEXTURE_RGB:
-      internal_format = PIPE_FORMAT_R8G8B8_UNORM;
-      break;
-   case EGL_TEXTURE_RGBA:
-      internal_format = PIPE_FORMAT_B8G8R8A8_UNORM;
-      break;
-   default:
-      return _eglError(EGL_BAD_MATCH, "eglBindTexImage");
-   }
-
-   switch (gsurf->base.TextureTarget) {
-   case EGL_TEXTURE_2D:
-      target = ST_TEXTURE_2D;
-      break;
-   default:
-      return _eglError(EGL_BAD_MATCH, "eglBindTexImage");
-   }
-
-   if (!es1)
-      return EGL_TRUE;
-   if (!gsurf->render_texture)
-      return EGL_FALSE;
-
-   /* flush properly if the surface is bound */
-   if (gsurf->base.CurrentContext) {
-      gctx = egl_g3d_context(gsurf->base.CurrentContext);
-      gctx->stctxi->flush(gctx->stctxi,
-            PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
-   }
-
-   gctx = egl_g3d_context(es1);
-   if (gctx->stctxi->teximage) {
-      if (!gctx->stctxi->teximage(gctx->stctxi, target,
-               gsurf->base.MipmapLevel, internal_format,
-               gsurf->render_texture, gsurf->base.MipmapTexture))
-         return EGL_FALSE;
-      gsurf->base.BoundToTexture = EGL_TRUE;
-   }
-
-   return EGL_TRUE;
-}
-
-static EGLBoolean
-egl_g3d_release_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
-                          _EGLSurface *surf, EGLint buffer)
-{
-   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
-
-   if (!gsurf || gsurf->base.Type != EGL_PBUFFER_BIT ||
-       !gsurf->base.BoundToTexture)
-      return _eglError(EGL_BAD_SURFACE, "eglReleaseTexImage");
-   if (buffer != EGL_BACK_BUFFER)
-      return _eglError(EGL_BAD_PARAMETER, "eglReleaseTexImage");
-
-   if (gsurf->render_texture) {
-      _EGLContext *ctx = _eglGetAPIContext(EGL_OPENGL_ES_API);
-      struct egl_g3d_context *gctx = egl_g3d_context(ctx);
-
-      /* what if the context the surface binds to is no longer current? */
-      if (gctx) {
-         gctx->stctxi->teximage(gctx->stctxi, ST_TEXTURE_2D,
-               gsurf->base.MipmapLevel, PIPE_FORMAT_NONE, NULL, FALSE);
-      }
-   }
-
-   gsurf->base.BoundToTexture = EGL_FALSE;
-
-   return EGL_TRUE;
-}
-
-#ifdef EGL_MESA_screen_surface
-
-static _EGLSurface *
-egl_g3d_create_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy,
-                              _EGLConfig *conf, const EGLint *attribs)
-{
-   struct egl_g3d_create_surface_arg arg;
-
-   memset(&arg, 0, sizeof(arg));
-   arg.type = EGL_SCREEN_BIT_MESA;
-
-   return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
-}
-
-static EGLBoolean
-egl_g3d_show_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy,
-                            _EGLScreen *scr, _EGLSurface *surf,
-                            _EGLMode *mode)
-{
-   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
-   struct egl_g3d_screen *gscr = egl_g3d_screen(scr);
-   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
-   struct native_surface *nsurf;
-   const struct native_mode *nmode;
-   EGLBoolean changed;
-
-   if (gsurf) {
-      EGLint idx;
-
-      if (!mode)
-         return _eglError(EGL_BAD_MATCH, "eglShowSurfaceMESA");
-      if (gsurf->base.Type != EGL_SCREEN_BIT_MESA)
-         return _eglError(EGL_BAD_SURFACE, "eglShowScreenSurfaceMESA");
-      if (gsurf->base.Width < mode->Width || gsurf->base.Height < mode->Height)
-         return _eglError(EGL_BAD_MATCH,
-               "eglShowSurfaceMESA(surface smaller than mode size)");
-
-      /* find the index of the mode */
-      for (idx = 0; idx < gscr->base.NumModes; idx++)
-         if (mode == &gscr->base.Modes[idx])
-            break;
-      if (idx >= gscr->base.NumModes) {
-         return _eglError(EGL_BAD_MODE_MESA,
-               "eglShowSurfaceMESA(unknown mode)");
-      }
-
-      nsurf = gsurf->native;
-      nmode = gscr->native_modes[idx];
-   }
-   else {
-      if (mode)
-         return _eglError(EGL_BAD_MATCH, "eglShowSurfaceMESA");
-
-      /* disable the screen */
-      nsurf = NULL;
-      nmode = NULL;
-   }
-
-   /* TODO surface panning by CRTC choosing */
-   changed = gdpy->native->modeset->program(gdpy->native, 0, nsurf,
-         gscr->base.OriginX, gscr->base.OriginY, &gscr->native, 1, nmode);
-   if (changed) {
-      gscr->base.CurrentSurface = &gsurf->base;
-      gscr->base.CurrentMode = mode;
-   }
-
-   return changed;
-}
-
-#endif /* EGL_MESA_screen_surface */
-
 static EGLint
 egl_g3d_probe(_EGLDriver *drv, _EGLDisplay *dpy)
 {
@@ -1107,7 +589,7 @@ egl_g3d_unload(_EGLDriver *drv)
    }
 
    egl_g3d_destroy_probe(drv, NULL);
-   free(gdrv);
+   FREE(gdrv);
 }
 
 _EGLDriver *
@@ -1116,41 +598,18 @@ _eglMain(const char *args)
    static char driver_name[64];
    struct egl_g3d_driver *gdrv;
 
-   snprintf(driver_name, sizeof(driver_name),
+   util_snprintf(driver_name, sizeof(driver_name),
          "Gallium/%s", native_get_name());
 
    gdrv = CALLOC_STRUCT(egl_g3d_driver);
    if (!gdrv)
       return NULL;
 
-   _eglInitDriverFallbacks(&gdrv->base);
-
+   egl_g3d_init_driver_api(&gdrv->base);
    gdrv->base.API.Initialize = egl_g3d_initialize;
    gdrv->base.API.Terminate = egl_g3d_terminate;
-   gdrv->base.API.CreateContext = egl_g3d_create_context;
-   gdrv->base.API.DestroyContext = egl_g3d_destroy_context;
-   gdrv->base.API.CreateWindowSurface = egl_g3d_create_window_surface;
-   gdrv->base.API.CreatePixmapSurface = egl_g3d_create_pixmap_surface;
-   gdrv->base.API.CreatePbufferSurface = egl_g3d_create_pbuffer_surface;
-   gdrv->base.API.DestroySurface = egl_g3d_destroy_surface;
-   gdrv->base.API.MakeCurrent = egl_g3d_make_current;
-   gdrv->base.API.SwapBuffers = egl_g3d_swap_buffers;
-   gdrv->base.API.CopyBuffers = egl_g3d_copy_buffers;
-   gdrv->base.API.WaitClient = egl_g3d_wait_client;
-   gdrv->base.API.WaitNative = egl_g3d_wait_native;
    gdrv->base.API.GetProcAddress = egl_g3d_get_proc_address;
 
-   gdrv->base.API.BindTexImage = egl_g3d_bind_tex_image;
-   gdrv->base.API.ReleaseTexImage = egl_g3d_release_tex_image;
-
-   gdrv->base.API.CreateImageKHR = egl_g3d_create_image;
-   gdrv->base.API.DestroyImageKHR = egl_g3d_destroy_image;
-
-#ifdef EGL_MESA_screen_surface
-   gdrv->base.API.CreateScreenSurfaceMESA = egl_g3d_create_screen_surface;
-   gdrv->base.API.ShowScreenSurfaceMESA = egl_g3d_show_screen_surface;
-#endif
-
    gdrv->base.Name = driver_name;
    gdrv->base.Probe = egl_g3d_probe;
    gdrv->base.Unload = egl_g3d_unload;
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d.h b/src/gallium/state_trackers/egl/common/egl_g3d.h
index 2788f1bf4ac..5a3c80b9689 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d.h
+++ b/src/gallium/state_trackers/egl/common/egl_g3d.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 _EGL_G3D_H_
@@ -70,8 +71,10 @@ struct egl_g3d_surface {
    struct st_visual stvis;
    struct st_framebuffer_iface *stfbi;
 
+   /* the native surface;  NULL for pbuffers */
    struct native_surface *native;
-   struct pipe_texture *render_texture;
+   struct pipe_resource *render_texture;
+
    unsigned int sequence_number;
 };
 
@@ -83,7 +86,7 @@ struct egl_g3d_config {
 
 struct egl_g3d_image {
    _EGLImage base;
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    unsigned face;
    unsigned level;
    unsigned zslice;
@@ -100,8 +103,4 @@ _EGL_DRIVER_STANDARD_TYPECASTS(egl_g3d)
 _EGL_DRIVER_TYPECAST(egl_g3d_screen, _EGLScreen, obj)
 _EGL_DRIVER_TYPECAST(egl_g3d_image, _EGLImage, obj)
 
-
-_EGLConfig *
-egl_g3d_find_pixmap_config(_EGLDisplay *dpy, EGLNativePixmapType pix);
-
 #endif /* _EGL_G3D_H_ */
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_api.c b/src/gallium/state_trackers/egl/common/egl_g3d_api.c
new file mode 100644
index 00000000000..478516453ce
--- /dev/null
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_api.c
@@ -0,0 +1,731 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.9
+ *
+ * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org>
+ *
+ * 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, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+#include "egldriver.h"
+#include "eglcurrent.h"
+#include "egllog.h"
+
+#include "pipe/p_screen.h"
+#include "util/u_memory.h"
+#include "util/u_inlines.h"
+
+#include "egl_g3d.h"
+#include "egl_g3d_api.h"
+#include "egl_g3d_image.h"
+#include "egl_g3d_st.h"
+#include "native.h"
+
+/**
+ * Return the state tracker for the given context.
+ */
+static struct st_api *
+egl_g3d_choose_st(_EGLDriver *drv, _EGLContext *ctx)
+{
+   struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
+   struct st_api *stapi;
+   EGLint idx = -1;
+
+   switch (ctx->ClientAPI) {
+   case EGL_OPENGL_ES_API:
+      switch (ctx->ClientVersion) {
+      case 1:
+         idx = ST_API_OPENGL_ES1;
+         break;
+      case 2:
+         idx = ST_API_OPENGL_ES2;
+         break;
+      default:
+         _eglLog(_EGL_WARNING, "unknown client version %d",
+               ctx->ClientVersion);
+         break;
+      }
+      break;
+   case EGL_OPENVG_API:
+      idx = ST_API_OPENVG;
+      break;
+   case EGL_OPENGL_API:
+      idx = ST_API_OPENGL;
+      break;
+   default:
+      _eglLog(_EGL_WARNING, "unknown client API 0x%04x", ctx->ClientAPI);
+      break;
+   }
+
+   stapi = (idx >= 0) ? gdrv->stapis[idx] : NULL;
+   return stapi;
+}
+
+static _EGLContext *
+egl_g3d_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
+                       _EGLContext *share, const EGLint *attribs)
+{
+   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
+   struct egl_g3d_context *gshare = egl_g3d_context(share);
+   struct egl_g3d_config *gconf = egl_g3d_config(conf);
+   struct egl_g3d_context *gctx;
+
+   gctx = CALLOC_STRUCT(egl_g3d_context);
+   if (!gctx) {
+      _eglError(EGL_BAD_ALLOC, "eglCreateContext");
+      return NULL;
+   }
+
+   if (!_eglInitContext(&gctx->base, dpy, conf, attribs)) {
+      FREE(gctx);
+      return NULL;
+   }
+
+   gctx->stapi = egl_g3d_choose_st(drv, &gctx->base);
+   if (!gctx->stapi) {
+      FREE(gctx);
+      return NULL;
+   }
+
+   gctx->stctxi = gctx->stapi->create_context(gctx->stapi, gdpy->smapi,
+         &gconf->stvis, (gshare) ? gshare->stctxi : NULL);
+   if (!gctx->stctxi) {
+      FREE(gctx);
+      return NULL;
+   }
+
+   gctx->stctxi->st_manager_private = (void *) &gctx->base;
+
+   return &gctx->base;
+}
+
+/**
+ * Destroy a context.
+ */
+static void
+destroy_context(_EGLDisplay *dpy, _EGLContext *ctx)
+{
+   struct egl_g3d_context *gctx = egl_g3d_context(ctx);
+
+   /* FIXME a context might live longer than its display */
+   if (!dpy->Initialized)
+      _eglLog(_EGL_FATAL, "destroy a context with an unitialized display");
+
+   gctx->stctxi->destroy(gctx->stctxi);
+
+   FREE(gctx);
+}
+
+static EGLBoolean
+egl_g3d_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
+{
+   if (!_eglIsContextBound(ctx))
+      destroy_context(dpy, ctx);
+   return EGL_TRUE;
+}
+
+struct egl_g3d_create_surface_arg {
+   EGLint type;
+   union {
+      EGLNativeWindowType win;
+      EGLNativePixmapType pix;
+   } u;
+};
+
+static _EGLSurface *
+egl_g3d_create_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
+                       struct egl_g3d_create_surface_arg *arg,
+                       const EGLint *attribs)
+{
+   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
+   struct egl_g3d_config *gconf = egl_g3d_config(conf);
+   struct egl_g3d_surface *gsurf;
+   struct native_surface *nsurf;
+   const char *err;
+
+   switch (arg->type) {
+   case EGL_WINDOW_BIT:
+      err = "eglCreateWindowSurface";
+      break;
+   case EGL_PIXMAP_BIT:
+      err = "eglCreatePixmapSurface";
+      break;
+#ifdef EGL_MESA_screen_surface
+   case EGL_SCREEN_BIT_MESA:
+      err = "eglCreateScreenSurface";
+      break;
+#endif
+   default:
+      err = "eglCreateUnknownSurface";
+      break;
+   }
+
+   gsurf = CALLOC_STRUCT(egl_g3d_surface);
+   if (!gsurf) {
+      _eglError(EGL_BAD_ALLOC, err);
+      return NULL;
+   }
+
+   if (!_eglInitSurface(&gsurf->base, dpy, arg->type, conf, attribs)) {
+      FREE(gsurf);
+      return NULL;
+   }
+
+   /* create the native surface */
+   switch (arg->type) {
+   case EGL_WINDOW_BIT:
+      nsurf = gdpy->native->create_window_surface(gdpy->native,
+            arg->u.win, gconf->native);
+      break;
+   case EGL_PIXMAP_BIT:
+      nsurf = gdpy->native->create_pixmap_surface(gdpy->native,
+            arg->u.pix, gconf->native);
+      break;
+#ifdef EGL_MESA_screen_surface
+   case EGL_SCREEN_BIT_MESA:
+      /* prefer back buffer (move to _eglInitSurface?) */
+      gsurf->base.RenderBuffer = EGL_BACK_BUFFER;
+      nsurf = gdpy->native->modeset->create_scanout_surface(gdpy->native,
+            gconf->native, gsurf->base.Width, gsurf->base.Height);
+      break;
+#endif
+   default:
+      nsurf = NULL;
+      break;
+   }
+
+   if (!nsurf) {
+      FREE(gsurf);
+      return NULL;
+   }
+   /* initialize the geometry */
+   if (!nsurf->validate(nsurf, 0x0, &gsurf->sequence_number, NULL,
+            &gsurf->base.Width, &gsurf->base.Height)) {
+      nsurf->destroy(nsurf);
+      FREE(gsurf);
+      return NULL;
+   }
+
+   gsurf->stvis = gconf->stvis;
+   if (gsurf->base.RenderBuffer == EGL_SINGLE_BUFFER)
+      gsurf->stvis.render_buffer = ST_ATTACHMENT_FRONT_LEFT;
+
+   gsurf->stfbi = egl_g3d_create_st_framebuffer(&gsurf->base);
+   if (!gsurf->stfbi) {
+      nsurf->destroy(nsurf);
+      FREE(gsurf);
+      return NULL;
+   }
+
+   nsurf->user_data = &gsurf->base;
+   gsurf->native = nsurf;
+
+   return &gsurf->base;
+}
+
+static _EGLSurface *
+egl_g3d_create_window_surface(_EGLDriver *drv, _EGLDisplay *dpy,
+                              _EGLConfig *conf, EGLNativeWindowType win,
+                              const EGLint *attribs)
+{
+   struct egl_g3d_create_surface_arg arg;
+
+   memset(&arg, 0, sizeof(arg));
+   arg.type = EGL_WINDOW_BIT;
+   arg.u.win = win;
+
+   return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
+}
+
+static _EGLSurface *
+egl_g3d_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *dpy,
+                              _EGLConfig *conf, EGLNativePixmapType pix,
+                              const EGLint *attribs)
+{
+   struct egl_g3d_create_surface_arg arg;
+
+   memset(&arg, 0, sizeof(arg));
+   arg.type = EGL_PIXMAP_BIT;
+   arg.u.pix = pix;
+
+   return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
+}
+
+static _EGLSurface *
+egl_g3d_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy,
+                               _EGLConfig *conf, const EGLint *attribs)
+{
+   struct egl_g3d_config *gconf = egl_g3d_config(conf);
+   struct egl_g3d_surface *gsurf;
+
+   gsurf = CALLOC_STRUCT(egl_g3d_surface);
+   if (!gsurf) {
+      _eglError(EGL_BAD_ALLOC, "eglCreatePbufferSurface");
+      return NULL;
+   }
+
+   if (!_eglInitSurface(&gsurf->base, dpy, EGL_PBUFFER_BIT, conf, attribs)) {
+      FREE(gsurf);
+      return NULL;
+   }
+
+   gsurf->stvis = gconf->stvis;
+
+   gsurf->stfbi = egl_g3d_create_st_framebuffer(&gsurf->base);
+   if (!gsurf->stfbi) {
+      FREE(gsurf);
+      return NULL;
+   }
+
+   return &gsurf->base;
+}
+
+/**
+ * Destroy a surface.
+ */
+static void
+destroy_surface(_EGLDisplay *dpy, _EGLSurface *surf)
+{
+   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
+
+   /* FIXME a surface might live longer than its display */
+   if (!dpy->Initialized)
+      _eglLog(_EGL_FATAL, "destroy a surface with an unitialized display");
+
+   pipe_resource_reference(&gsurf->render_texture, NULL);
+   egl_g3d_destroy_st_framebuffer(gsurf->stfbi);
+   if (gsurf->native)
+      gsurf->native->destroy(gsurf->native);
+   FREE(gsurf);
+}
+
+static EGLBoolean
+egl_g3d_destroy_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
+{
+   if (!_eglIsSurfaceBound(surf))
+      destroy_surface(dpy, surf);
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+egl_g3d_make_current(_EGLDriver *drv, _EGLDisplay *dpy,
+                     _EGLSurface *draw, _EGLSurface *read, _EGLContext *ctx)
+{
+   struct egl_g3d_context *gctx = egl_g3d_context(ctx);
+   struct egl_g3d_surface *gdraw = egl_g3d_surface(draw);
+   struct egl_g3d_surface *gread = egl_g3d_surface(read);
+   struct egl_g3d_context *old_gctx;
+   EGLBoolean ok = EGL_TRUE;
+
+   /* bind the new context and return the "orphaned" one */
+   if (!_eglBindContext(&ctx, &draw, &read))
+      return EGL_FALSE;
+   old_gctx = egl_g3d_context(ctx);
+
+   if (old_gctx) {
+      /* flush old context */
+      old_gctx->stctxi->flush(old_gctx->stctxi,
+            PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
+   }
+
+   if (gctx) {
+      ok = gctx->stapi->make_current(gctx->stapi, gctx->stctxi,
+            (gdraw) ? gdraw->stfbi : NULL, (gread) ? gread->stfbi : NULL);
+      if (ok) {
+         gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, gdraw->stfbi);
+         if (gread != gdraw) {
+            gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi,
+                  gread->stfbi);
+         }
+
+         if (gdraw->base.Type == EGL_WINDOW_BIT) {
+            gctx->base.WindowRenderBuffer =
+               (gdraw->stvis.render_buffer == ST_ATTACHMENT_FRONT_LEFT) ?
+               EGL_SINGLE_BUFFER : EGL_BACK_BUFFER;
+         }
+      }
+   }
+   else if (old_gctx) {
+      ok = old_gctx->stapi->make_current(old_gctx->stapi, NULL, NULL, NULL);
+      old_gctx->base.WindowRenderBuffer = EGL_NONE;
+   }
+
+   if (ctx && !_eglIsContextLinked(ctx))
+      destroy_context(dpy, ctx);
+   if (draw && !_eglIsSurfaceLinked(draw))
+      destroy_surface(dpy, draw);
+   if (read && read != draw && !_eglIsSurfaceLinked(read))
+      destroy_surface(dpy, read);
+
+   return ok;
+}
+
+static EGLBoolean
+egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
+{
+   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
+   _EGLContext *ctx = _eglGetCurrentContext();
+   struct egl_g3d_context *gctx = NULL;
+
+   /* no-op for pixmap or pbuffer surface */
+   if (gsurf->base.Type == EGL_PIXMAP_BIT ||
+       gsurf->base.Type == EGL_PBUFFER_BIT)
+      return EGL_TRUE;
+
+   /* or when the surface is single-buffered */
+   if (gsurf->stvis.render_buffer == ST_ATTACHMENT_FRONT_LEFT)
+      return EGL_TRUE;
+
+   if (ctx && ctx->DrawSurface == surf)
+      gctx = egl_g3d_context(ctx);
+
+   /* flush if the surface is current */
+   if (gctx) {
+      gctx->stctxi->flush(gctx->stctxi,
+            PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
+   }
+
+   return gsurf->native->swap_buffers(gsurf->native);
+}
+
+/**
+ * Get the pipe surface of the given attachment of the native surface.
+ */
+static struct pipe_surface *
+get_pipe_surface(struct native_display *ndpy, struct native_surface *nsurf,
+                 enum native_attachment natt,
+		 unsigned bind)
+{
+   struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
+   struct pipe_surface *psurf;
+
+   textures[natt] = NULL;
+   nsurf->validate(nsurf, 1 << natt, NULL, textures, NULL, NULL);
+   if (!textures[natt])
+      return NULL;
+
+   psurf = ndpy->screen->get_tex_surface(ndpy->screen, textures[natt],
+         0, 0, 0, bind);
+   pipe_resource_reference(&textures[natt], NULL);
+
+   return psurf;
+}
+
+static EGLBoolean
+egl_g3d_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
+                     EGLNativePixmapType target)
+{
+   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
+   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
+   _EGLContext *ctx = _eglGetCurrentContext();
+   struct egl_g3d_config *gconf;
+   struct native_surface *nsurf;
+   struct pipe_screen *screen = gdpy->native->screen;
+   struct pipe_surface *psurf;
+
+   if (!gsurf->render_texture)
+      return EGL_TRUE;
+
+   gconf = egl_g3d_config(egl_g3d_find_pixmap_config(dpy, target));
+   if (!gconf)
+      return _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCopyBuffers");
+
+   nsurf = gdpy->native->create_pixmap_surface(gdpy->native,
+         target, gconf->native);
+   if (!nsurf)
+      return _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCopyBuffers");
+
+   /* flush if the surface is current */
+   if (ctx && ctx->DrawSurface == &gsurf->base) {
+      struct egl_g3d_context *gctx = egl_g3d_context(ctx);
+      gctx->stctxi->flush(gctx->stctxi,
+            PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
+   }
+
+   /* create a pipe context to copy surfaces */
+   if (!gdpy->pipe) {
+      gdpy->pipe =
+         gdpy->native->screen->context_create(gdpy->native->screen, NULL);
+      if (!gdpy->pipe)
+         return EGL_FALSE;
+   }
+
+   psurf = get_pipe_surface(gdpy->native, nsurf, NATIVE_ATTACHMENT_FRONT_LEFT,
+			    PIPE_BIND_BLIT_DESTINATION);
+   if (psurf) {
+      struct pipe_surface *psrc;
+
+      psrc = screen->get_tex_surface(screen, gsurf->render_texture,
+            0, 0, 0, PIPE_BIND_BLIT_SOURCE);
+      if (psrc) {
+         gdpy->pipe->surface_copy(gdpy->pipe, psurf, 0, 0,
+               psrc, 0, 0, psurf->width, psurf->height);
+         pipe_surface_reference(&psrc, NULL);
+
+         nsurf->flush_frontbuffer(nsurf);
+      }
+
+      pipe_surface_reference(&psurf, NULL);
+   }
+
+   nsurf->destroy(nsurf);
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+egl_g3d_wait_client(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
+{
+   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
+   struct egl_g3d_context *gctx = egl_g3d_context(ctx);
+   struct pipe_screen *screen = gdpy->native->screen;
+   struct pipe_fence_handle *fence = NULL;
+
+   gctx->stctxi->flush(gctx->stctxi,
+         PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence);
+   screen->fence_finish(screen, fence, 0);
+   screen->fence_reference(screen, &fence, NULL);
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+egl_g3d_wait_native(_EGLDriver *drv, _EGLDisplay *dpy, EGLint engine)
+{
+   _EGLContext *ctx = _eglGetCurrentContext();
+
+   if (engine != EGL_CORE_NATIVE_ENGINE)
+      return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
+
+   if (ctx && ctx->DrawSurface) {
+      struct egl_g3d_surface *gsurf = egl_g3d_surface(ctx->DrawSurface);
+
+      if (gsurf->native)
+         gsurf->native->wait(gsurf->native);
+   }
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
+                       _EGLSurface *surf, EGLint buffer)
+{
+   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
+   _EGLContext *es1 = _eglGetAPIContext(EGL_OPENGL_ES_API);
+   struct egl_g3d_context *gctx;
+   enum pipe_format internal_format;
+   enum st_texture_type target;
+
+   if (!gsurf || gsurf->base.Type != EGL_PBUFFER_BIT)
+      return _eglError(EGL_BAD_SURFACE, "eglBindTexImage");
+   if (buffer != EGL_BACK_BUFFER)
+      return _eglError(EGL_BAD_PARAMETER, "eglBindTexImage");
+   if (gsurf->base.BoundToTexture)
+      return _eglError(EGL_BAD_ACCESS, "eglBindTexImage");
+
+   switch (gsurf->base.TextureFormat) {
+   case EGL_TEXTURE_RGB:
+      internal_format = PIPE_FORMAT_R8G8B8_UNORM;
+      break;
+   case EGL_TEXTURE_RGBA:
+      internal_format = PIPE_FORMAT_B8G8R8A8_UNORM;
+      break;
+   default:
+      return _eglError(EGL_BAD_MATCH, "eglBindTexImage");
+   }
+
+   switch (gsurf->base.TextureTarget) {
+   case EGL_TEXTURE_2D:
+      target = ST_TEXTURE_2D;
+      break;
+   default:
+      return _eglError(EGL_BAD_MATCH, "eglBindTexImage");
+   }
+
+   if (!es1)
+      return EGL_TRUE;
+   if (!gsurf->render_texture)
+      return EGL_FALSE;
+
+   /* flush properly if the surface is bound */
+   if (gsurf->base.CurrentContext) {
+      gctx = egl_g3d_context(gsurf->base.CurrentContext);
+      gctx->stctxi->flush(gctx->stctxi,
+            PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
+   }
+
+   gctx = egl_g3d_context(es1);
+   if (gctx->stctxi->teximage) {
+      if (!gctx->stctxi->teximage(gctx->stctxi, target,
+               gsurf->base.MipmapLevel, internal_format,
+               gsurf->render_texture, gsurf->base.MipmapTexture))
+         return EGL_FALSE;
+      gsurf->base.BoundToTexture = EGL_TRUE;
+   }
+
+   return EGL_TRUE;
+}
+
+static EGLBoolean
+egl_g3d_release_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
+                          _EGLSurface *surf, EGLint buffer)
+{
+   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
+
+   if (!gsurf || gsurf->base.Type != EGL_PBUFFER_BIT ||
+       !gsurf->base.BoundToTexture)
+      return _eglError(EGL_BAD_SURFACE, "eglReleaseTexImage");
+   if (buffer != EGL_BACK_BUFFER)
+      return _eglError(EGL_BAD_PARAMETER, "eglReleaseTexImage");
+
+   if (gsurf->render_texture) {
+      _EGLContext *ctx = _eglGetAPIContext(EGL_OPENGL_ES_API);
+      struct egl_g3d_context *gctx = egl_g3d_context(ctx);
+
+      /* what if the context the surface binds to is no longer current? */
+      if (gctx) {
+         gctx->stctxi->teximage(gctx->stctxi, ST_TEXTURE_2D,
+               gsurf->base.MipmapLevel, PIPE_FORMAT_NONE, NULL, FALSE);
+      }
+   }
+
+   gsurf->base.BoundToTexture = EGL_FALSE;
+
+   return EGL_TRUE;
+}
+
+#ifdef EGL_MESA_screen_surface
+
+static _EGLSurface *
+egl_g3d_create_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy,
+                              _EGLConfig *conf, const EGLint *attribs)
+{
+   struct egl_g3d_create_surface_arg arg;
+
+   memset(&arg, 0, sizeof(arg));
+   arg.type = EGL_SCREEN_BIT_MESA;
+
+   return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
+}
+
+static EGLBoolean
+egl_g3d_show_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy,
+                            _EGLScreen *scr, _EGLSurface *surf,
+                            _EGLMode *mode)
+{
+   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
+   struct egl_g3d_screen *gscr = egl_g3d_screen(scr);
+   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
+   struct native_surface *nsurf;
+   const struct native_mode *nmode;
+   EGLBoolean changed;
+
+   if (gsurf) {
+      EGLint idx;
+
+      if (!mode)
+         return _eglError(EGL_BAD_MATCH, "eglShowSurfaceMESA");
+      if (gsurf->base.Type != EGL_SCREEN_BIT_MESA)
+         return _eglError(EGL_BAD_SURFACE, "eglShowScreenSurfaceMESA");
+      if (gsurf->base.Width < mode->Width || gsurf->base.Height < mode->Height)
+         return _eglError(EGL_BAD_MATCH,
+               "eglShowSurfaceMESA(surface smaller than mode size)");
+
+      /* find the index of the mode */
+      for (idx = 0; idx < gscr->base.NumModes; idx++)
+         if (mode == &gscr->base.Modes[idx])
+            break;
+      if (idx >= gscr->base.NumModes) {
+         return _eglError(EGL_BAD_MODE_MESA,
+               "eglShowSurfaceMESA(unknown mode)");
+      }
+
+      nsurf = gsurf->native;
+      nmode = gscr->native_modes[idx];
+   }
+   else {
+      if (mode)
+         return _eglError(EGL_BAD_MATCH, "eglShowSurfaceMESA");
+
+      /* disable the screen */
+      nsurf = NULL;
+      nmode = NULL;
+   }
+
+   /* TODO surface panning by CRTC choosing */
+   changed = gdpy->native->modeset->program(gdpy->native, 0, nsurf,
+         gscr->base.OriginX, gscr->base.OriginY, &gscr->native, 1, nmode);
+   if (changed) {
+      gscr->base.CurrentSurface = &gsurf->base;
+      gscr->base.CurrentMode = mode;
+   }
+
+   return changed;
+}
+
+#endif /* EGL_MESA_screen_surface */
+
+/**
+ * Find a config that supports the pixmap.
+ */
+_EGLConfig *
+egl_g3d_find_pixmap_config(_EGLDisplay *dpy, EGLNativePixmapType pix)
+{
+   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
+   struct egl_g3d_config *gconf;
+   EGLint i;
+
+   for (i = 0; i < dpy->NumConfigs; i++) {
+      gconf = egl_g3d_config(dpy->Configs[i]);
+      if (gdpy->native->is_pixmap_supported(gdpy->native, pix, gconf->native))
+         break;
+   }
+
+   return (i < dpy->NumConfigs) ? &gconf->base : NULL;
+}
+
+void
+egl_g3d_init_driver_api(_EGLDriver *drv)
+{
+   _eglInitDriverFallbacks(drv);
+
+   drv->API.CreateContext = egl_g3d_create_context;
+   drv->API.DestroyContext = egl_g3d_destroy_context;
+   drv->API.CreateWindowSurface = egl_g3d_create_window_surface;
+   drv->API.CreatePixmapSurface = egl_g3d_create_pixmap_surface;
+   drv->API.CreatePbufferSurface = egl_g3d_create_pbuffer_surface;
+   drv->API.DestroySurface = egl_g3d_destroy_surface;
+   drv->API.MakeCurrent = egl_g3d_make_current;
+   drv->API.SwapBuffers = egl_g3d_swap_buffers;
+   drv->API.CopyBuffers = egl_g3d_copy_buffers;
+   drv->API.WaitClient = egl_g3d_wait_client;
+   drv->API.WaitNative = egl_g3d_wait_native;
+
+   drv->API.BindTexImage = egl_g3d_bind_tex_image;
+   drv->API.ReleaseTexImage = egl_g3d_release_tex_image;
+
+   drv->API.CreateImageKHR = egl_g3d_create_image;
+   drv->API.DestroyImageKHR = egl_g3d_destroy_image;
+
+#ifdef EGL_MESA_screen_surface
+   drv->API.CreateScreenSurfaceMESA = egl_g3d_create_screen_surface;
+   drv->API.ShowScreenSurfaceMESA = egl_g3d_show_screen_surface;
+#endif
+}
diff --git a/src/gallium/drivers/i915/i915_buffer.h b/src/gallium/state_trackers/egl/common/egl_g3d_api.h
index 80fda7c62fd..d5196c12fe9 100644
--- a/src/gallium/drivers/i915/i915_buffer.h
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_api.h
@@ -1,6 +1,8 @@
-/**************************************************************************
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.9
  *
- * Copyright © 2009 Jakob Bornecrantz
+ * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -9,23 +11,27 @@
  * 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 above copyright notice and this permission notice 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 NONINFRINGEMENT. IN NO EVENT SHALL
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS 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 _EGL_G3D_API_H_
+#define _EGL_G3D_API_H_
+
+#include "egl_g3d.h"
 
-#ifndef I915_BUFFER_H
-#define I915_BUFFER_H
+void
+egl_g3d_init_driver_api(_EGLDriver *drv);
 
-void i915_init_screen_buffer_functions(struct i915_screen *screen);
+_EGLConfig *
+egl_g3d_find_pixmap_config(_EGLDisplay *dpy, EGLNativePixmapType pix);
 
-#endif
+#endif /* _EGL_G3D_API_H_ */
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_image.c b/src/gallium/state_trackers/egl/common/egl_g3d_image.c
index d701f9c9a88..b1fe30a776c 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d_image.c
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_image.c
@@ -14,39 +14,39 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
  */
 
-#include <assert.h>
 #include "pipe/p_screen.h"
 #include "util/u_memory.h"
 #include "util/u_rect.h"
 #include "util/u_inlines.h"
 #include "eglcurrent.h"
-#include "egllog.h"
 
 #include "native.h"
 #include "egl_g3d.h"
+#include "egl_g3d_api.h"
 #include "egl_g3d_image.h"
 
 /**
  * Reference and return the front left buffer of the native pixmap.
  */
-static struct pipe_texture *
+static struct pipe_resource *
 egl_g3d_reference_native_pixmap(_EGLDisplay *dpy, EGLNativePixmapType pix)
 {
    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
    struct egl_g3d_config *gconf;
    struct native_surface *nsurf;
-   struct pipe_texture *textures[NUM_NATIVE_ATTACHMENTS];
+   struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
    enum native_attachment natt;
 
    gconf = egl_g3d_config(egl_g3d_find_pixmap_config(dpy, pix));
@@ -72,7 +72,7 @@ egl_g3d_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx,
                      EGLenum target, EGLClientBuffer buffer,
                      const EGLint *attribs)
 {
-   struct pipe_texture *ptex;
+   struct pipe_resource *ptex;
    struct egl_g3d_image *gimg;
    unsigned face = 0, level = 0, zslice = 0;
 
@@ -83,7 +83,7 @@ egl_g3d_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx,
    }
 
    if (!_eglInitImage(&gimg->base, dpy, attribs)) {
-      free(gimg);
+      FREE(gimg);
       return NULL;
    }
 
@@ -98,20 +98,20 @@ egl_g3d_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx,
    }
 
    if (!ptex) {
-      free(gimg);
+      FREE(gimg);
       return NULL;
    }
 
    if (level > ptex->last_level) {
       _eglError(EGL_BAD_MATCH, "eglCreateEGLImageKHR");
-      pipe_texture_reference(&gimg->texture, NULL);
-      free(gimg);
+      pipe_resource_reference(&gimg->texture, NULL);
+      FREE(gimg);
       return NULL;
    }
    if (zslice > ptex->depth0) {
       _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
-      pipe_texture_reference(&gimg->texture, NULL);
-      free(gimg);
+      pipe_resource_reference(&gimg->texture, NULL);
+      FREE(gimg);
       return NULL;
    }
 
@@ -129,8 +129,8 @@ egl_g3d_destroy_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img)
 {
    struct egl_g3d_image *gimg = egl_g3d_image(img);
 
-   pipe_texture_reference(&gimg->texture, NULL);
-   free(gimg);
+   pipe_resource_reference(&gimg->texture, NULL);
+   FREE(gimg);
 
    return EGL_TRUE;
 }
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_image.h b/src/gallium/state_trackers/egl/common/egl_g3d_image.h
index c199c466456..adda9333715 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d_image.h
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_image.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_st.c b/src/gallium/state_trackers/egl/common/egl_g3d_st.c
index 6488965e5b0..57a479f6bca 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d_st.c
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_st.c
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
@@ -85,6 +86,37 @@ egl_g3d_create_st_api(enum st_api_type api)
    return mod->create_api();
 }
 
+static boolean
+egl_g3d_st_manager_get_egl_image(struct st_manager *smapi,
+                                 struct st_egl_image *stimg)
+{
+   struct egl_g3d_st_manager *gsmapi = egl_g3d_st_manager(smapi);
+   EGLImageKHR handle = (EGLImageKHR) stimg->egl_image;
+   _EGLImage *img;
+   struct egl_g3d_image *gimg;
+
+   /* this is called from state trackers */
+   _eglLockMutex(&gsmapi->display->Mutex);
+
+   img = _eglLookupImage(handle, gsmapi->display);
+   if (!img) {
+      _eglUnlockMutex(&gsmapi->display->Mutex);
+      return FALSE;
+   }
+
+   gimg = egl_g3d_image(img);
+
+   stimg->texture = NULL;
+   pipe_resource_reference(&stimg->texture, gimg->texture);
+   stimg->face = gimg->face;
+   stimg->level = gimg->level;
+   stimg->zslice = gimg->zslice;
+
+   _eglUnlockMutex(&gsmapi->display->Mutex);
+
+   return TRUE;
+}
+
 struct st_manager *
 egl_g3d_create_st_manager(_EGLDisplay *dpy)
 {
@@ -96,6 +128,7 @@ egl_g3d_create_st_manager(_EGLDisplay *dpy)
       gsmapi->display = dpy;
 
       gsmapi->base.screen = gdpy->native->screen;
+      gsmapi->base.get_egl_image = egl_g3d_st_manager_get_egl_image;
    }
 
    return &gsmapi->base;;
@@ -105,7 +138,54 @@ void
 egl_g3d_destroy_st_manager(struct st_manager *smapi)
 {
    struct egl_g3d_st_manager *gsmapi = egl_g3d_st_manager(smapi);
-   free(gsmapi);
+   FREE(gsmapi);
+}
+
+static boolean
+egl_g3d_st_framebuffer_flush_front_pbuffer(struct st_framebuffer_iface *stfbi,
+                                           enum st_attachment_type statt)
+{
+   return TRUE;
+}
+
+static boolean 
+egl_g3d_st_framebuffer_validate_pbuffer(struct st_framebuffer_iface *stfbi,
+                                        const enum st_attachment_type *statts,
+                                        unsigned count,
+                                        struct pipe_resource **out)
+{
+   _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private;
+   struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
+   struct pipe_resource templ;
+   unsigned i;
+
+   for (i = 0; i < count; i++) {
+      out[i] = NULL;
+
+      if (gsurf->stvis.render_buffer != statts[i])
+         continue;
+
+      if (!gsurf->render_texture) {
+         struct egl_g3d_display *gdpy =
+            egl_g3d_display(gsurf->base.Resource.Display);
+         struct pipe_screen *screen = gdpy->native->screen;
+
+         memset(&templ, 0, sizeof(templ));
+         templ.target = PIPE_TEXTURE_2D;
+         templ.last_level = 0;
+         templ.width0 = gsurf->base.Width;
+         templ.height0 = gsurf->base.Height;
+         templ.depth0 = 1;
+         templ.format = gsurf->stvis.color_format;
+         templ.bind = PIPE_BIND_RENDER_TARGET;
+
+         gsurf->render_texture = screen->resource_create(screen, &templ);
+      }
+
+      pipe_resource_reference(&out[i], gsurf->render_texture);
+   }
+
+   return TRUE;
 }
 
 static boolean
@@ -122,11 +202,11 @@ static boolean
 egl_g3d_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
                                 const enum st_attachment_type *statts,
                                 unsigned count,
-                                struct pipe_texture **out)
+                                struct pipe_resource **out)
 {
    _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private;
    struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
-   struct pipe_texture *textures[NUM_NATIVE_ATTACHMENTS];
+   struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
    uint attachment_mask = 0;
    unsigned i;
 
@@ -161,7 +241,7 @@ egl_g3d_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
       return FALSE;
 
    for (i = 0; i < count; i++) {
-      struct pipe_texture *tex;
+      struct pipe_resource *tex;
       int natt;
 
       switch (statts[i]) {
@@ -186,7 +266,7 @@ egl_g3d_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
          tex = textures[natt];
 
          if (statts[i] == stfbi->visual->render_buffer)
-            pipe_texture_reference(&gsurf->render_texture, tex);
+            pipe_resource_reference(&gsurf->render_texture, tex);
 
          if (attachment_mask & (1 << natt)) {
             /* transfer the ownership to the caller */
@@ -195,7 +275,7 @@ egl_g3d_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
          }
          else {
             /* the attachment is listed more than once */
-            pipe_texture_reference(&out[i], tex);
+            pipe_resource_reference(&out[i], tex);
          }
       }
    }
@@ -214,8 +294,14 @@ egl_g3d_create_st_framebuffer(_EGLSurface *surf)
       return NULL;
 
    stfbi->visual = &gsurf->stvis;
-   stfbi->flush_front = egl_g3d_st_framebuffer_flush_front;
-   stfbi->validate = egl_g3d_st_framebuffer_validate;
+   if (gsurf->base.Type != EGL_PBUFFER_BIT) {
+      stfbi->flush_front = egl_g3d_st_framebuffer_flush_front;
+      stfbi->validate = egl_g3d_st_framebuffer_validate;
+   }
+   else {
+      stfbi->flush_front = egl_g3d_st_framebuffer_flush_front_pbuffer;
+      stfbi->validate = egl_g3d_st_framebuffer_validate_pbuffer;
+   }
    stfbi->st_manager_private = (void *) &gsurf->base;
 
    return stfbi;
@@ -224,5 +310,5 @@ egl_g3d_create_st_framebuffer(_EGLSurface *surf)
 void
 egl_g3d_destroy_st_framebuffer(struct st_framebuffer_iface *stfbi)
 {
-   free(stfbi);
+   FREE(stfbi);
 }
diff --git a/src/gallium/state_trackers/egl/common/egl_g3d_st.h b/src/gallium/state_trackers/egl/common/egl_g3d_st.h
index ea8b4068cd8..c82681a22d8 100644
--- a/src/gallium/state_trackers/egl/common/egl_g3d_st.h
+++ b/src/gallium/state_trackers/egl/common/egl_g3d_st.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
diff --git a/src/gallium/state_trackers/egl/common/native.h b/src/gallium/state_trackers/egl/common/native.h
index 93c81b26e10..3f60348c489 100644
--- a/src/gallium/state_trackers/egl/common/native.h
+++ b/src/gallium/state_trackers/egl/common/native.h
@@ -14,26 +14,26 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 _NATIVE_H_
 #define _NATIVE_H_
 
 #include "EGL/egl.h"  /* for EGL native types */
-#include "GL/gl.h" /* for GL types needed by __GLcontextModes */
-#include "GL/internal/glcore.h"  /* for __GLcontextModes */
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_screen.h"
 #include "pipe/p_context.h"
 #include "pipe/p_state.h"
 
+#include "native_probe.h"
 #include "native_modeset.h"
 
 /**
@@ -57,27 +57,6 @@ enum native_param_type {
    NATIVE_PARAM_USE_NATIVE_BUFFER
 };
 
-/**
- * Enumerations for probe results.
- */
-enum native_probe_result {
-   NATIVE_PROBE_UNKNOWN,
-   NATIVE_PROBE_FALLBACK,
-   NATIVE_PROBE_SUPPORTED,
-   NATIVE_PROBE_EXACT,
-};
-
-/**
- * A probe object for display probe.
- */
-struct native_probe {
-   int magic;
-   EGLNativeDisplayType display;
-   void *data;
-
-   void (*destroy)(struct native_probe *nprobe);
-};
-
 struct native_surface {
    /**
     * Available for caller's use.
@@ -112,7 +91,7 @@ struct native_surface {
     * behavior might change in the future.
     */
    boolean (*validate)(struct native_surface *nsurf, uint attachment_mask,
-                       unsigned int *seq_num, struct pipe_texture **textures,
+                       unsigned int *seq_num, struct pipe_resource **textures,
                        int *width, int *height);
 
    /**
@@ -121,15 +100,26 @@ struct native_surface {
    void (*wait)(struct native_surface *nsurf);
 };
 
+/**
+ * Describe a native display config.
+ */
 struct native_config {
-   /* __GLcontextModes should go away some day */
-   __GLcontextModes mode;
+   /* available buffers and their format */
+   uint buffer_mask;
    enum pipe_format color_format;
-   enum pipe_format depth_format;
-   enum pipe_format stencil_format;
 
-   /* treat it as an additional flag to mode.drawableType */
+   /* supported surface types */
+   boolean window_bit;
+   boolean pixmap_bit;
    boolean scanout_bit;
+
+   int native_visual_id;
+   int native_visual_type;
+   int level;
+   int samples;
+   boolean slow_config;
+   boolean transparent_rgb;
+   int transparent_rgb_values[3];
 };
 
 /**
@@ -160,18 +150,14 @@ struct native_display {
 
    /**
     * Get the supported configs.  The configs are owned by the display, but
-    * the returned array should be free()ed.
-    *
-    * The configs will be converted to EGL config by
-    * _eglConfigFromContextModesRec and validated by _eglValidateConfig.
-    * Those failing to pass the test will be skipped.
+    * the returned array should be FREE()ed.
     */
    const struct native_config **(*get_configs)(struct native_display *ndpy,
                                                int *num_configs);
 
    /**
     * Test if a pixmap is supported by the given config.  Required unless no
-    * config has GLX_PIXMAP_BIT set.
+    * config has pixmap_bit set.
     *
     * This function is usually called to find a config that supports a given
     * pixmap.  Thus, it is usually called with the same pixmap in a row.
@@ -182,29 +168,19 @@ struct native_display {
 
 
    /**
-    * Create a window surface.  Required unless no config has GLX_WINDOW_BIT
-    * set.
+    * Create a window surface.  Required unless no config has window_bit set.
     */
    struct native_surface *(*create_window_surface)(struct native_display *ndpy,
                                                    EGLNativeWindowType win,
                                                    const struct native_config *nconf);
 
    /**
-    * Create a pixmap surface.  Required unless no config has GLX_PIXMAP_BIT
-    * set.
+    * Create a pixmap surface.  Required unless no config has pixmap_bit set.
     */
    struct native_surface *(*create_pixmap_surface)(struct native_display *ndpy,
                                                    EGLNativePixmapType pix,
                                                    const struct native_config *nconf);
 
-   /**
-    * Create a pbuffer surface.  Required unless no config has GLX_PBUFFER_BIT
-    * set.
-    */
-   struct native_surface *(*create_pbuffer_surface)(struct native_display *ndpy,
-                                                    const struct native_config *nconf,
-                                                    uint width, uint height);
-
    const struct native_display_modeset *modeset;
 };
 
@@ -231,22 +207,6 @@ native_attachment_mask_test(uint mask, enum native_attachment att)
    return !!(mask & (1 << att));
 }
 
-/**
- * Return a probe object for the given display.
- *
- * Note that the returned object may be cached and used by different native
- * display modules.  It allows fast probing when multiple modules probe the
- * same display.
- */
-struct native_probe *
-native_create_probe(EGLNativeDisplayType dpy);
-
-/**
- * Probe the probe object.
- */
-enum native_probe_result
-native_get_probe_result(struct native_probe *nprobe);
-
 const char *
 native_get_name(void);
 
diff --git a/src/gallium/state_trackers/egl/common/native_modeset.h b/src/gallium/state_trackers/egl/common/native_modeset.h
index 71dc3ec860e..dee757b3a88 100644
--- a/src/gallium/state_trackers/egl/common/native_modeset.h
+++ b/src/gallium/state_trackers/egl/common/native_modeset.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 _NATIVE_MODESET_H_
@@ -63,8 +64,8 @@ struct native_display_modeset {
                                            int *num_modes);
 
    /**
-    * Create a scan-out surface.  Required unless no config has
-    * GLX_SCREEN_BIT_MESA set.
+    * Create a scan-out surface.  Required unless no config has scanout_bit
+    * set.
     */
    struct native_surface *(*create_scanout_surface)(struct native_display *ndpy,
                                                     const struct native_config *nconf,
diff --git a/src/gallium/state_trackers/egl/common/native_probe.h b/src/gallium/state_trackers/egl/common/native_probe.h
new file mode 100644
index 00000000000..aeed9f85dd5
--- /dev/null
+++ b/src/gallium/state_trackers/egl/common/native_probe.h
@@ -0,0 +1,68 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.8
+ *
+ * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org>
+ *
+ * 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, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 _NATIVE_PROBE_H_
+#define _NATIVE_PROBE_H_
+
+#include "EGL/egl.h"  /* for EGL native types */
+
+/**
+ * Enumerations for probe results.
+ */
+enum native_probe_result {
+   NATIVE_PROBE_UNKNOWN,
+   NATIVE_PROBE_FALLBACK,
+   NATIVE_PROBE_SUPPORTED,
+   NATIVE_PROBE_EXACT,
+};
+
+/**
+ * A probe object for display probe.
+ */
+struct native_probe {
+   int magic;
+   EGLNativeDisplayType display;
+   void *data;
+
+   void (*destroy)(struct native_probe *nprobe);
+};
+
+/**
+ * Return a probe object for the given display.
+ *
+ * Note that the returned object may be cached and used by different native
+ * display modules.  It allows fast probing when multiple modules probe the
+ * same display.
+ */
+struct native_probe *
+native_create_probe(EGLNativeDisplayType dpy);
+
+/**
+ * Probe the probe object.
+ */
+enum native_probe_result
+native_get_probe_result(struct native_probe *nprobe);
+
+#endif /* _NATIVE_PROBE_H_ */
diff --git a/src/gallium/state_trackers/egl/kms/native_kms.c b/src/gallium/state_trackers/egl/kms/native_kms.c
index 31747744907..860657349bc 100644
--- a/src/gallium/state_trackers/egl/kms/native_kms.c
+++ b/src/gallium/state_trackers/egl/kms/native_kms.c
@@ -14,35 +14,34 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
-#include <stdio.h>
-#include <string.h>
-
 #include "pipe/p_screen.h"
 #include "pipe/p_context.h"
 #include "util/u_debug.h"
 #include "util/u_memory.h"
 #include "util/u_inlines.h"
+#include "util/u_string.h"
 #include "egllog.h"
 
 #include "native_kms.h"
 
 static boolean
 kms_surface_validate(struct native_surface *nsurf, uint attachment_mask,
-                     unsigned int *seq_num, struct pipe_texture **textures,
+                     unsigned int *seq_num, struct pipe_resource **textures,
                      int *width, int *height)
 {
    struct kms_surface *ksurf = kms_surface(nsurf);
    struct kms_display *kdpy = ksurf->kdpy;
    struct pipe_screen *screen = kdpy->base.screen;
-   struct pipe_texture templ, *ptex;
+   struct pipe_resource templ, *ptex;
    int att;
 
    if (attachment_mask) {
@@ -53,9 +52,7 @@ kms_surface_validate(struct native_surface *nsurf, uint attachment_mask,
       templ.height0 = ksurf->height;
       templ.depth0 = 1;
       templ.format = ksurf->color_format;
-      templ.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
-      if (ksurf->type == KMS_SURFACE_TYPE_SCANOUT)
-         templ.tex_usage |= PIPE_TEXTURE_USAGE_SCANOUT;
+      templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SCANOUT;
    }
 
    /* create textures */
@@ -66,13 +63,13 @@ kms_surface_validate(struct native_surface *nsurf, uint attachment_mask,
 
       ptex = ksurf->textures[att];
       if (!ptex) {
-         ptex = screen->texture_create(screen, &templ);
+         ptex = screen->resource_create(screen, &templ);
          ksurf->textures[att] = ptex;
       }
 
       if (textures) {
          textures[att] = NULL;
-         pipe_texture_reference(&textures[att], ptex);
+         pipe_resource_reference(&textures[att], ptex);
       }
    }
 
@@ -118,7 +115,7 @@ kms_surface_init_framebuffers(struct native_surface *nsurf, boolean need_back)
          if (!ksurf->textures[natt])
             return FALSE;
 
-         pipe_texture_reference(&fb->texture, ksurf->textures[natt]);
+         pipe_resource_reference(&fb->texture, ksurf->textures[natt]);
       }
 
       /* already initialized */
@@ -131,7 +128,7 @@ kms_surface_init_framebuffers(struct native_surface *nsurf, boolean need_back)
       memset(&whandle, 0, sizeof(whandle));
       whandle.type = DRM_API_HANDLE_TYPE_KMS;
 
-      if (!kdpy->base.screen->texture_get_handle(kdpy->base.screen,
+      if (!kdpy->base.screen->resource_get_handle(kdpy->base.screen,
                fb->texture, &whandle))
          return FALSE;
 
@@ -155,10 +152,6 @@ kms_surface_flush_frontbuffer(struct native_surface *nsurf)
    struct kms_surface *ksurf = kms_surface(nsurf);
    struct kms_display *kdpy = ksurf->kdpy;
 
-   /* pbuffer is private */
-   if (ksurf->type == KMS_SURFACE_TYPE_PBUFFER)
-      return TRUE;
-
    if (ksurf->front_fb.is_passive)
       drmModeDirtyFB(kdpy->fd, ksurf->front_fb.buffer_id, NULL, 0);
 #endif
@@ -173,13 +166,9 @@ kms_surface_swap_buffers(struct native_surface *nsurf)
    struct kms_crtc *kcrtc = &ksurf->current_crtc;
    struct kms_display *kdpy = ksurf->kdpy;
    struct kms_framebuffer tmp_fb;
-   struct pipe_texture *tmp_texture;
+   struct pipe_resource *tmp_texture;
    int err;
 
-   /* pbuffer is private */
-   if (ksurf->type == KMS_SURFACE_TYPE_PBUFFER)
-      return TRUE;
-
    if (!ksurf->back_fb.buffer_id) {
       if (!kms_surface_init_framebuffers(&ksurf->base, TRUE))
          return FALSE;
@@ -228,23 +217,22 @@ kms_surface_destroy(struct native_surface *nsurf)
 
    if (ksurf->front_fb.buffer_id)
       drmModeRmFB(ksurf->kdpy->fd, ksurf->front_fb.buffer_id);
-   pipe_texture_reference(&ksurf->front_fb.texture, NULL);
+   pipe_resource_reference(&ksurf->front_fb.texture, NULL);
 
    if (ksurf->back_fb.buffer_id)
       drmModeRmFB(ksurf->kdpy->fd, ksurf->back_fb.buffer_id);
-   pipe_texture_reference(&ksurf->back_fb.texture, NULL);
+   pipe_resource_reference(&ksurf->back_fb.texture, NULL);
 
    for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++) {
-      struct pipe_texture *ptex = ksurf->textures[i];
-      pipe_texture_reference(&ptex, NULL);
+      struct pipe_resource *ptex = ksurf->textures[i];
+      pipe_resource_reference(&ptex, NULL);
    }
 
-   free(ksurf);
+   FREE(ksurf);
 }
 
 static struct kms_surface *
 kms_display_create_surface(struct native_display *ndpy,
-                           enum kms_surface_type type,
                            const struct native_config *nconf,
                            uint width, uint height)
 {
@@ -257,7 +245,6 @@ kms_display_create_surface(struct native_display *ndpy,
       return NULL;
 
    ksurf->kdpy = kdpy;
-   ksurf->type = type;
    ksurf->color_format = kconf->base.color_format;
    ksurf->width = width;
    ksurf->height = height;
@@ -475,7 +462,7 @@ kms_display_get_modes(struct native_display *ndpy,
    /* delete old data */
    if (kconn->connector) {
       drmModeFreeConnector(kconn->connector);
-      free(kconn->kms_modes);
+      FREE(kconn->kms_modes);
 
       kconn->connector = NULL;
       kconn->kms_modes = NULL;
@@ -488,7 +475,7 @@ kms_display_get_modes(struct native_display *ndpy,
       return NULL;
 
    count = kconn->connector->count_modes;
-   kconn->kms_modes = calloc(count, sizeof(*kconn->kms_modes));
+   kconn->kms_modes = CALLOC(count, sizeof(*kconn->kms_modes));
    if (!kconn->kms_modes) {
       drmModeFreeConnector(kconn->connector);
       kconn->connector = NULL;
@@ -511,7 +498,7 @@ kms_display_get_modes(struct native_display *ndpy,
          kmode->base.refresh_rate = (kmode->base.refresh_rate + 500) / 1000;
    }
 
-   nmodes_return = malloc(count * sizeof(*nmodes_return));
+   nmodes_return = MALLOC(count * sizeof(*nmodes_return));
    if (nmodes_return) {
       for (i = 0; i < count; i++)
          nmodes_return[i] = &kconn->kms_modes[i].base;
@@ -532,7 +519,7 @@ kms_display_get_connectors(struct native_display *ndpy, int *num_connectors,
 
    if (!kdpy->connectors) {
       kdpy->connectors =
-         calloc(kdpy->resources->count_connectors, sizeof(*kdpy->connectors));
+         CALLOC(kdpy->resources->count_connectors, sizeof(*kdpy->connectors));
       if (!kdpy->connectors)
          return NULL;
 
@@ -546,7 +533,7 @@ kms_display_get_connectors(struct native_display *ndpy, int *num_connectors,
       kdpy->num_connectors = kdpy->resources->count_connectors;
    }
 
-   connectors = malloc(kdpy->num_connectors * sizeof(*connectors));
+   connectors = MALLOC(kdpy->num_connectors * sizeof(*connectors));
    if (connectors) {
       for (i = 0; i < kdpy->num_connectors; i++)
          connectors[i] = &kdpy->connectors[i].base;
@@ -567,32 +554,18 @@ kms_display_create_scanout_surface(struct native_display *ndpy,
 {
    struct kms_surface *ksurf;
 
-   ksurf = kms_display_create_surface(ndpy,
-         KMS_SURFACE_TYPE_SCANOUT, nconf, width, height);
+   ksurf = kms_display_create_surface(ndpy, nconf, width, height);
    return &ksurf->base;
 }
 
-static struct native_surface *
-kms_display_create_pbuffer_surface(struct native_display *ndpy,
-                                   const struct native_config *nconf,
-                                   uint width, uint height)
-{
-   struct kms_surface *ksurf;
-
-   ksurf = kms_display_create_surface(ndpy,
-         KMS_SURFACE_TYPE_PBUFFER, nconf, width, height);
-   return &ksurf->base;
-}
-
-
 static boolean
 kms_display_is_format_supported(struct native_display *ndpy,
                                 enum pipe_format fmt, boolean is_color)
 {
    return ndpy->screen->is_format_supported(ndpy->screen,
          fmt, PIPE_TEXTURE_2D,
-         (is_color) ? PIPE_TEXTURE_USAGE_RENDER_TARGET :
-         PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+         (is_color) ? PIPE_BIND_RENDER_TARGET :
+         PIPE_BIND_DEPTH_STENCIL, 0);
 }
 
 static const struct native_config **
@@ -606,14 +579,15 @@ kms_display_get_configs(struct native_display *ndpy, int *num_configs)
       struct native_config *nconf;
       enum pipe_format format;
 
-      kdpy->config = calloc(1, sizeof(*kdpy->config));
+      kdpy->config = CALLOC(1, sizeof(*kdpy->config));
       if (!kdpy->config)
          return NULL;
 
       nconf = &kdpy->config->base;
 
-      /* always double-buffered */
-      nconf->mode.doubleBufferMode = TRUE;
+      nconf->buffer_mask =
+         (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
+         (1 << NATIVE_ATTACHMENT_BACK_LEFT);
 
       format = PIPE_FORMAT_B8G8R8A8_UNORM;
       if (!kms_display_is_format_supported(&kdpy->base, format, TRUE)) {
@@ -621,45 +595,18 @@ kms_display_get_configs(struct native_display *ndpy, int *num_configs)
          if (!kms_display_is_format_supported(&kdpy->base, format, TRUE))
             format = PIPE_FORMAT_NONE;
       }
-      if (format == PIPE_FORMAT_NONE)
+      if (format == PIPE_FORMAT_NONE) {
+         FREE(kdpy->config);
+         kdpy->config = NULL;
          return NULL;
+      }
 
       nconf->color_format = format;
-      nconf->mode.redBits = 8;
-      nconf->mode.greenBits = 8;
-      nconf->mode.blueBits = 8;
-      nconf->mode.alphaBits = 8;
-      nconf->mode.rgbBits = 32;
-
-      format = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
-      if (!kms_display_is_format_supported(&kdpy->base, format, FALSE)) {
-         format = PIPE_FORMAT_S8_USCALED_Z24_UNORM;
-         if (!kms_display_is_format_supported(&kdpy->base, format, FALSE))
-            format = PIPE_FORMAT_NONE;
-      }
-      if (format != PIPE_FORMAT_NONE) {
-         nconf->depth_format = format;
-         nconf->stencil_format = format;
-
-         nconf->mode.depthBits = 24;
-         nconf->mode.stencilBits = 8;
-         nconf->mode.haveDepthBuffer = TRUE;
-         nconf->mode.haveStencilBuffer = TRUE;
-      }
 
       nconf->scanout_bit = TRUE;
-      nconf->mode.drawableType = GLX_PBUFFER_BIT;
-      nconf->mode.swapMethod = GLX_SWAP_EXCHANGE_OML;
-
-      nconf->mode.visualID = 0;
-      nconf->mode.visualType = EGL_NONE;
-
-      nconf->mode.renderType = GLX_RGBA_BIT;
-      nconf->mode.rgbMode = TRUE;
-      nconf->mode.xRenderable = FALSE;
    }
 
-   configs = malloc(sizeof(*configs));
+   configs = MALLOC(sizeof(*configs));
    if (configs) {
       configs[0] = &kdpy->config->base;
       if (num_configs)
@@ -691,21 +638,21 @@ kms_display_destroy(struct native_display *ndpy)
    int i;
 
    if (kdpy->config)
-      free(kdpy->config);
+      FREE(kdpy->config);
 
    if (kdpy->connectors) {
       for (i = 0; i < kdpy->num_connectors; i++) {
          struct kms_connector *kconn = &kdpy->connectors[i];
          if (kconn->connector) {
             drmModeFreeConnector(kconn->connector);
-            free(kconn->kms_modes);
+            FREE(kconn->kms_modes);
          }
       }
-      free(kdpy->connectors);
+      FREE(kdpy->connectors);
    }
 
    if (kdpy->shown_surfaces)
-      free(kdpy->shown_surfaces);
+      FREE(kdpy->shown_surfaces);
 
    if (kdpy->saved_crtcs) {
       for (i = 0; i < kdpy->resources->count_crtcs; i++) {
@@ -721,7 +668,7 @@ kms_display_destroy(struct native_display *ndpy)
             drmModeFreeCrtc(kcrtc->crtc);
          }
       }
-      free(kdpy->saved_crtcs);
+      FREE(kdpy->saved_crtcs);
    }
 
    if (kdpy->resources)
@@ -735,7 +682,7 @@ kms_display_destroy(struct native_display *ndpy)
 
    if (kdpy->api)
       kdpy->api->destroy(kdpy->api);
-   free(kdpy);
+   FREE(kdpy);
 }
 
 /**
@@ -798,7 +745,7 @@ kms_create_display(EGLNativeDisplayType dpy,
    kdpy->api = api;
    if (!kdpy->api) {
       _eglLog(_EGL_WARNING, "failed to create DRM API");
-      free(kdpy);
+      FREE(kdpy);
       return NULL;
    }
 
@@ -816,14 +763,14 @@ kms_create_display(EGLNativeDisplayType dpy,
    }
 
    kdpy->saved_crtcs =
-      calloc(kdpy->resources->count_crtcs, sizeof(*kdpy->saved_crtcs));
+      CALLOC(kdpy->resources->count_crtcs, sizeof(*kdpy->saved_crtcs));
    if (!kdpy->saved_crtcs) {
       kms_display_destroy(&kdpy->base);
       return NULL;
    }
 
    kdpy->shown_surfaces =
-      calloc(kdpy->resources->count_crtcs, sizeof(*kdpy->shown_surfaces));
+      CALLOC(kdpy->resources->count_crtcs, sizeof(*kdpy->shown_surfaces));
    if (!kdpy->shown_surfaces) {
       kms_display_destroy(&kdpy->base);
       return NULL;
@@ -832,7 +779,6 @@ kms_create_display(EGLNativeDisplayType dpy,
    kdpy->base.destroy = kms_display_destroy;
    kdpy->base.get_param = kms_display_get_param;
    kdpy->base.get_configs = kms_display_get_configs;
-   kdpy->base.create_pbuffer_surface = kms_display_create_pbuffer_surface;
 
    kdpy->base.modeset = &kms_display_modeset;
 
@@ -863,9 +809,9 @@ native_get_name(void)
       drm_api = drm_api_create();
 
    if (drm_api)
-      snprintf(kms_name, sizeof(kms_name), "KMS/%s", drm_api->name);
+      util_snprintf(kms_name, sizeof(kms_name), "KMS/%s", drm_api->name);
    else
-      snprintf(kms_name, sizeof(kms_name), "KMS");
+      util_snprintf(kms_name, sizeof(kms_name), "KMS");
 
    return kms_name;
 }
diff --git a/src/gallium/state_trackers/egl/kms/native_kms.h b/src/gallium/state_trackers/egl/kms/native_kms.h
index f9cbcb158b5..3b08e930c52 100644
--- a/src/gallium/state_trackers/egl/kms/native_kms.h
+++ b/src/gallium/state_trackers/egl/kms/native_kms.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 _NATIVE_KMS_H_
@@ -35,11 +36,6 @@
 
 #include "common/native.h"
 
-enum kms_surface_type {
-   KMS_SURFACE_TYPE_PBUFFER,
-   KMS_SURFACE_TYPE_SCANOUT
-};
-
 struct kms_config;
 struct kms_connector;
 struct kms_mode;
@@ -69,7 +65,7 @@ struct kms_display {
 };
 
 struct kms_framebuffer {
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    boolean is_passive;
 
    uint32_t buffer_id;
@@ -77,12 +73,11 @@ struct kms_framebuffer {
 
 struct kms_surface {
    struct native_surface base;
-   enum kms_surface_type type;
    enum pipe_format color_format;
    struct kms_display *kdpy;
    int width, height;
 
-   struct pipe_texture *textures[NUM_NATIVE_ATTACHMENTS];
+   struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
    unsigned int sequence_number;
    struct kms_framebuffer front_fb, back_fb;
 
diff --git a/src/gallium/state_trackers/egl/x11/native_dri2.c b/src/gallium/state_trackers/egl/x11/native_dri2.c
index 8c0553ce0d5..20e1a0052ca 100644
--- a/src/gallium/state_trackers/egl/x11/native_dri2.c
+++ b/src/gallium/state_trackers/egl/x11/native_dri2.c
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 #include "util/u_memory.h"
@@ -40,7 +41,6 @@
 enum dri2_surface_type {
    DRI2_SURFACE_TYPE_WINDOW,
    DRI2_SURFACE_TYPE_PIXMAP,
-   DRI2_SURFACE_TYPE_PBUFFER
 };
 
 struct dri2_display {
@@ -72,7 +72,7 @@ struct dri2_surface {
    unsigned int server_stamp;
    unsigned int client_stamp;
    int width, height;
-   struct pipe_texture *textures[NUM_NATIVE_ATTACHMENTS];
+   struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
    uint valid_mask;
 
    boolean have_back, have_fake;
@@ -113,14 +113,14 @@ dri2_surface_process_drawable_buffers(struct native_surface *nsurf,
 {
    struct dri2_surface *dri2surf = dri2_surface(nsurf);
    struct dri2_display *dri2dpy = dri2surf->dri2dpy;
-   struct pipe_texture templ;
+   struct pipe_resource templ;
    struct winsys_handle whandle;
    uint valid_mask;
    int i;
 
    /* free the old textures */
    for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++)
-      pipe_texture_reference(&dri2surf->textures[i], NULL);
+      pipe_resource_reference(&dri2surf->textures[i], NULL);
    dri2surf->valid_mask = 0x0;
 
    dri2surf->have_back = FALSE;
@@ -136,7 +136,7 @@ dri2_surface_process_drawable_buffers(struct native_surface *nsurf,
    templ.height0 = dri2surf->height;
    templ.depth0 = 1;
    templ.format = dri2surf->color_format;
-   templ.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
+   templ.bind = PIPE_BIND_RENDER_TARGET;
 
    valid_mask = 0x0;
    for (i = 0; i < num_xbufs; i++) {
@@ -175,7 +175,7 @@ dri2_surface_process_drawable_buffers(struct native_surface *nsurf,
       memset(&whandle, 0, sizeof(whandle));
       whandle.stride = xbuf->pitch;
       whandle.handle = xbuf->name;
-      dri2surf->textures[natt] = dri2dpy->base.screen->texture_from_handle(
+      dri2surf->textures[natt] = dri2dpy->base.screen->resource_from_handle(
          dri2dpy->base.screen, &templ, &whandle);
       if (dri2surf->textures[natt])
          valid_mask |= 1 << natt;
@@ -192,9 +192,19 @@ dri2_surface_get_buffers(struct native_surface *nsurf, uint buffer_mask)
 {
    struct dri2_surface *dri2surf = dri2_surface(nsurf);
    struct dri2_display *dri2dpy = dri2surf->dri2dpy;
-   unsigned int dri2atts[NUM_NATIVE_ATTACHMENTS];
+   unsigned int dri2atts[NUM_NATIVE_ATTACHMENTS * 2];
    int num_ins, num_outs, att;
    struct x11_drawable_buffer *xbufs;
+   uint bpp = util_format_get_blocksizebits(dri2surf->color_format);
+   boolean with_format = FALSE; /* never ask for depth/stencil */
+
+   /* We must get the front on servers which doesn't support with format
+    * due to a silly bug in core dri2. You can't copy to/from a buffer
+    * that you haven't requested and you recive BadValue errors */
+   if (dri2surf->dri2dpy->dri_minor < 1) {
+      with_format = FALSE;
+      buffer_mask |= (1 << NATIVE_ATTACHMENT_FRONT_LEFT);
+   }
 
    /* prepare the attachments */
    num_ins = 0;
@@ -221,19 +231,22 @@ dri2_surface_get_buffers(struct native_surface *nsurf, uint buffer_mask)
             break;
          }
 
-         dri2atts[num_ins] = dri2att;
-         num_ins++;
+         dri2atts[num_ins++] = dri2att;
+         if (with_format)
+            dri2atts[num_ins++] = bpp;
       }
    }
+   if (with_format)
+      num_ins /= 2;
 
    xbufs = x11_drawable_get_buffers(dri2dpy->xscr, dri2surf->drawable,
                                     &dri2surf->width, &dri2surf->height,
-                                    dri2atts, FALSE, num_ins, &num_outs);
+                                    dri2atts, with_format, num_ins, &num_outs);
 
    /* we should be able to do better... */
    if (xbufs && dri2surf->last_num_xbufs == num_outs &&
        memcmp(dri2surf->last_xbufs, xbufs, sizeof(*xbufs) * num_outs) == 0) {
-      free(xbufs);
+      FREE(xbufs);
       dri2surf->client_stamp = dri2surf->server_stamp;
       return;
    }
@@ -244,7 +257,7 @@ dri2_surface_get_buffers(struct native_surface *nsurf, uint buffer_mask)
    dri2surf->client_stamp = dri2surf->server_stamp;
 
    if (dri2surf->last_xbufs)
-      free(dri2surf->last_xbufs);
+      FREE(dri2surf->last_xbufs);
    dri2surf->last_xbufs = xbufs;
    dri2surf->last_num_xbufs = num_outs;
 }
@@ -257,47 +270,8 @@ static boolean
 dri2_surface_update_buffers(struct native_surface *nsurf, uint buffer_mask)
 {
    struct dri2_surface *dri2surf = dri2_surface(nsurf);
-   struct dri2_display *dri2dpy = dri2surf->dri2dpy;
-
-   /* create textures for pbuffer */
-   if (dri2surf->type == DRI2_SURFACE_TYPE_PBUFFER) {
-      struct pipe_screen *screen = dri2dpy->base.screen;
-      struct pipe_texture templ;
-      uint new_valid = 0x0;
-      int att;
-
-      buffer_mask &= ~dri2surf->valid_mask;
-      if (!buffer_mask)
-         return TRUE;
-
-      memset(&templ, 0, sizeof(templ));
-      templ.target = PIPE_TEXTURE_2D;
-      templ.last_level = 0;
-      templ.width0 = dri2surf->width;
-      templ.height0 = dri2surf->height;
-      templ.depth0 = 1;
-      templ.format = dri2surf->color_format;
-      templ.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
-
-      for (att = 0; att < NUM_NATIVE_ATTACHMENTS; att++) {
-         if (native_attachment_mask_test(buffer_mask, att)) {
-            assert(!dri2surf->textures[att]);
 
-            dri2surf->textures[att] = screen->texture_create(screen, &templ);
-            if (!dri2surf->textures[att])
-               break;
-
-            new_valid |= 1 << att;
-            if (new_valid == buffer_mask)
-               break;
-         }
-      }
-      dri2surf->valid_mask |= new_valid;
-      /* no need to update the stamps */
-   }
-   else {
-      dri2_surface_get_buffers(&dri2surf->base, buffer_mask);
-   }
+   dri2_surface_get_buffers(&dri2surf->base, buffer_mask);
 
    return ((dri2surf->valid_mask & buffer_mask) == buffer_mask);
 }
@@ -318,10 +292,6 @@ dri2_surface_flush_frontbuffer(struct native_surface *nsurf)
    struct dri2_surface *dri2surf = dri2_surface(nsurf);
    struct dri2_display *dri2dpy = dri2surf->dri2dpy;
 
-   /* pbuffer is private */
-   if (dri2surf->type == DRI2_SURFACE_TYPE_PBUFFER)
-      return TRUE;
-
    /* copy to real front buffer */
    if (dri2surf->have_fake)
       x11_drawable_copy_buffers(dri2dpy->xscr, dri2surf->drawable,
@@ -344,10 +314,6 @@ dri2_surface_swap_buffers(struct native_surface *nsurf)
    struct dri2_surface *dri2surf = dri2_surface(nsurf);
    struct dri2_display *dri2dpy = dri2surf->dri2dpy;
 
-   /* pbuffer is private */
-   if (dri2surf->type == DRI2_SURFACE_TYPE_PBUFFER)
-      return TRUE;
-
    /* copy to front buffer */
    if (dri2surf->have_back)
       x11_drawable_copy_buffers(dri2dpy->xscr, dri2surf->drawable,
@@ -372,7 +338,7 @@ dri2_surface_swap_buffers(struct native_surface *nsurf)
 
 static boolean
 dri2_surface_validate(struct native_surface *nsurf, uint attachment_mask,
-                      unsigned int *seq_num, struct pipe_texture **textures,
+                      unsigned int *seq_num, struct pipe_resource **textures,
                       int *width, int *height)
 {
    struct dri2_surface *dri2surf = dri2_surface(nsurf);
@@ -390,10 +356,10 @@ dri2_surface_validate(struct native_surface *nsurf, uint attachment_mask,
       int att;
       for (att = 0; att < NUM_NATIVE_ATTACHMENTS; att++) {
          if (native_attachment_mask_test(attachment_mask, att)) {
-            struct pipe_texture *ptex = dri2surf->textures[att];
+            struct pipe_resource *ptex = dri2surf->textures[att];
 
             textures[att] = NULL;
-            pipe_texture_reference(&textures[att], ptex);
+            pipe_resource_reference(&textures[att], ptex);
          }
       }
    }
@@ -426,11 +392,11 @@ dri2_surface_destroy(struct native_surface *nsurf)
    int i;
 
    if (dri2surf->last_xbufs)
-      free(dri2surf->last_xbufs);
+      FREE(dri2surf->last_xbufs);
 
    for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++) {
-      struct pipe_texture *ptex = dri2surf->textures[i];
-      pipe_texture_reference(&ptex, NULL);
+      struct pipe_resource *ptex = dri2surf->textures[i];
+      pipe_resource_reference(&ptex, NULL);
    }
 
    if (dri2surf->drawable) {
@@ -440,7 +406,7 @@ dri2_surface_destroy(struct native_surface *nsurf)
       util_hash_table_remove(dri2surf->dri2dpy->surfaces,
             (void *) dri2surf->drawable);
    }
-   free(dri2surf);
+   FREE(dri2surf);
 }
 
 static struct dri2_surface *
@@ -504,22 +470,6 @@ dri2_display_create_pixmap_surface(struct native_display *ndpy,
    return (dri2surf) ? &dri2surf->base : NULL;
 }
 
-static struct native_surface *
-dri2_display_create_pbuffer_surface(struct native_display *ndpy,
-                                    const struct native_config *nconf,
-                                    uint width, uint height)
-{
-   struct dri2_surface *dri2surf;
-
-   dri2surf = dri2_display_create_surface(ndpy, DRI2_SURFACE_TYPE_PBUFFER,
-         (Drawable) None, nconf);
-   if (dri2surf) {
-      dri2surf->width = width;
-      dri2surf->height = height;
-   }
-   return (dri2surf) ? &dri2surf->base : NULL;
-}
-
 static int
 choose_color_format(const __GLcontextModes *mode, enum pipe_format formats[32])
 {
@@ -546,43 +496,13 @@ choose_color_format(const __GLcontextModes *mode, enum pipe_format formats[32])
    return count;
 }
 
-static int
-choose_depth_stencil_format(const __GLcontextModes *mode,
-                            enum pipe_format formats[32])
-{
-   int count = 0;
-
-   switch (mode->depthBits) {
-   case 32:
-      formats[count++] = PIPE_FORMAT_Z32_UNORM;
-      break;
-   case 24:
-      if (mode->stencilBits) {
-         formats[count++] = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
-         formats[count++] = PIPE_FORMAT_S8_USCALED_Z24_UNORM;
-      }
-      else {
-         formats[count++] = PIPE_FORMAT_Z24X8_UNORM;
-         formats[count++] = PIPE_FORMAT_X8Z24_UNORM;
-      }
-      break;
-   case 16:
-      formats[count++] = PIPE_FORMAT_Z16_UNORM;
-      break;
-   default:
-      break;
-   }
-
-   return count;
-}
-
 static boolean
 is_format_supported(struct pipe_screen *screen,
                     enum pipe_format fmt, boolean is_color)
 {
    return screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D,
-         (is_color) ? PIPE_TEXTURE_USAGE_RENDER_TARGET :
-         PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+         (is_color) ? PIPE_BIND_RENDER_TARGET :
+         PIPE_BIND_DEPTH_STENCIL, 0);
 }
 
 static boolean
@@ -600,30 +520,18 @@ dri2_display_convert_config(struct native_display *ndpy,
    if (!mode->doubleBufferMode)
       return FALSE;
 
-   nconf->mode = *mode;
-   nconf->mode.renderType = GLX_RGBA_BIT;
-   nconf->mode.rgbMode = TRUE;
-   /* pbuffer is allocated locally and is always supported */
-   nconf->mode.drawableType |= GLX_PBUFFER_BIT;
-   /* the swap method is always copy */
-   nconf->mode.swapMethod = GLX_SWAP_COPY_OML;
-
-   /* fix up */
-   nconf->mode.rgbBits =
-      nconf->mode.redBits + nconf->mode.greenBits +
-      nconf->mode.blueBits + nconf->mode.alphaBits;
-   if (!(nconf->mode.drawableType & GLX_WINDOW_BIT)) {
-      nconf->mode.visualID = 0;
-      nconf->mode.visualType = GLX_NONE;
-   }
-   if (!(nconf->mode.drawableType & GLX_PBUFFER_BIT)) {
-      nconf->mode.bindToTextureRgb = FALSE;
-      nconf->mode.bindToTextureRgba = FALSE;
-   }
+   /* only interested in native renderable configs */
+   if (!mode->xRenderable || !mode->drawableType)
+      return FALSE;
 
-   nconf->color_format = PIPE_FORMAT_NONE;
-   nconf->depth_format = PIPE_FORMAT_NONE;
-   nconf->stencil_format = PIPE_FORMAT_NONE;
+   nconf->buffer_mask = 1 << NATIVE_ATTACHMENT_FRONT_LEFT;
+   if (mode->doubleBufferMode)
+      nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_BACK_LEFT;
+   if (mode->stereoMode) {
+      nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_FRONT_RIGHT;
+      if (mode->doubleBufferMode)
+         nconf->buffer_mask |= 1 << NATIVE_ATTACHMENT_BACK_RIGHT;
+   }
 
    /* choose color format */
    num_formats = choose_color_format(mode, formats);
@@ -636,18 +544,24 @@ dri2_display_convert_config(struct native_display *ndpy,
    if (nconf->color_format == PIPE_FORMAT_NONE)
       return FALSE;
 
-   /* choose depth/stencil format */
-   num_formats = choose_depth_stencil_format(mode, formats);
-   for (i = 0; i < num_formats; i++) {
-      if (is_format_supported(ndpy->screen, formats[i], FALSE)) {
-         nconf->depth_format = formats[i];
-         nconf->stencil_format = formats[i];
-         break;
-      }
+   if (mode->drawableType & GLX_WINDOW_BIT)
+      nconf->window_bit = TRUE;
+   if (mode->drawableType & GLX_PIXMAP_BIT)
+      nconf->pixmap_bit = TRUE;
+
+   nconf->native_visual_id = mode->visualID;
+   nconf->native_visual_type = mode->visualType;
+   nconf->level = mode->level;
+   nconf->samples = mode->samples;
+
+   nconf->slow_config = (mode->visualRating == GLX_SLOW_CONFIG);
+
+   if (mode->transparentPixel == GLX_TRANSPARENT_RGB) {
+      nconf->transparent_rgb = TRUE;
+      nconf->transparent_rgb_values[0] = mode->transparentRed;
+      nconf->transparent_rgb_values[1] = mode->transparentGreen;
+      nconf->transparent_rgb_values[2] = mode->transparentBlue;
    }
-   if ((nconf->mode.depthBits && nconf->depth_format == PIPE_FORMAT_NONE) ||
-       (nconf->mode.stencilBits && nconf->stencil_format == PIPE_FORMAT_NONE))
-      return FALSE;
 
    return TRUE;
 }
@@ -669,7 +583,7 @@ dri2_display_get_configs(struct native_display *ndpy, int *num_configs)
          return NULL;
       num_modes = x11_context_modes_count(modes);
 
-      dri2dpy->configs = calloc(num_modes, sizeof(*dri2dpy->configs));
+      dri2dpy->configs = CALLOC(num_modes, sizeof(*dri2dpy->configs));
       if (!dri2dpy->configs)
          return NULL;
 
@@ -684,7 +598,7 @@ dri2_display_get_configs(struct native_display *ndpy, int *num_configs)
       dri2dpy->num_configs = count;
    }
 
-   configs = malloc(dri2dpy->num_configs * sizeof(*configs));
+   configs = MALLOC(dri2dpy->num_configs * sizeof(*configs));
    if (configs) {
       for (i = 0; i < dri2dpy->num_configs; i++)
          configs[i] = (const struct native_config *) &dri2dpy->configs[i];
@@ -735,7 +649,7 @@ dri2_display_destroy(struct native_display *ndpy)
    struct dri2_display *dri2dpy = dri2_display(ndpy);
 
    if (dri2dpy->configs)
-      free(dri2dpy->configs);
+      FREE(dri2dpy->configs);
 
    if (dri2dpy->base.screen)
       dri2dpy->base.screen->destroy(dri2dpy->base.screen);
@@ -749,7 +663,7 @@ dri2_display_destroy(struct native_display *ndpy)
       XCloseDisplay(dri2dpy->dpy);
    if (dri2dpy->api && dri2dpy->api->destroy)
       dri2dpy->api->destroy(dri2dpy->api);
-   free(dri2dpy);
+   FREE(dri2dpy);
 }
 
 static void
@@ -877,7 +791,6 @@ x11_create_dri2_display(EGLNativeDisplayType dpy,
    dri2dpy->base.is_pixmap_supported = dri2_display_is_pixmap_supported;
    dri2dpy->base.create_window_surface = dri2_display_create_window_surface;
    dri2dpy->base.create_pixmap_surface = dri2_display_create_pixmap_surface;
-   dri2dpy->base.create_pbuffer_surface = dri2_display_create_pbuffer_surface;
 
    return &dri2dpy->base;
 }
diff --git a/src/gallium/state_trackers/egl/x11/native_x11.c b/src/gallium/state_trackers/egl/x11/native_x11.c
index c6eb17ab1ac..b6d51bbf9fb 100644
--- a/src/gallium/state_trackers/egl/x11/native_x11.c
+++ b/src/gallium/state_trackers/egl/x11/native_x11.c
@@ -14,18 +14,19 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
-#include <stdio.h>
 #include <string.h>
 #include "util/u_debug.h"
 #include "util/u_memory.h"
+#include "util/u_string.h"
 #include "state_tracker/drm_api.h"
 #include "egllog.h"
 
@@ -40,8 +41,8 @@ static void
 x11_probe_destroy(struct native_probe *nprobe)
 {
    if (nprobe->data)
-      free(nprobe->data);
-   free(nprobe);
+      FREE(nprobe->data);
+   FREE(nprobe);
 }
 
 struct native_probe *
@@ -61,7 +62,7 @@ native_create_probe(EGLNativeDisplayType dpy)
    if (!xdpy) {
       xdpy = XOpenDisplay(NULL);
       if (!xdpy) {
-         free(nprobe);
+         FREE(nprobe);
          return NULL;
       }
    }
@@ -118,9 +119,9 @@ native_get_name(void)
       api = drm_api_create();
 
    if (api)
-      snprintf(x11_name, sizeof(x11_name), "X11/%s", api->name);
+      util_snprintf(x11_name, sizeof(x11_name), "X11/%s", api->name);
    else
-      snprintf(x11_name, sizeof(x11_name), "X11");
+      util_snprintf(x11_name, sizeof(x11_name), "X11");
 
    return x11_name;
 }
diff --git a/src/gallium/state_trackers/egl/x11/native_x11.h b/src/gallium/state_trackers/egl/x11/native_x11.h
index 1566524926a..1678403b459 100644
--- a/src/gallium/state_trackers/egl/x11/native_x11.h
+++ b/src/gallium/state_trackers/egl/x11/native_x11.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 _NATIVE_X11_H_
diff --git a/src/gallium/state_trackers/egl/x11/native_ximage.c b/src/gallium/state_trackers/egl/x11/native_ximage.c
index d69011ac5ee..22fcdcfa6d9 100644
--- a/src/gallium/state_trackers/egl/x11/native_ximage.c
+++ b/src/gallium/state_trackers/egl/x11/native_ximage.c
@@ -14,18 +14,15 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
-#include <assert.h>
-#include <sys/ipc.h>
-#include <sys/types.h>
-#include <sys/shm.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include "util/u_memory.h"
@@ -47,7 +44,6 @@
 enum ximage_surface_type {
    XIMAGE_SURFACE_TYPE_WINDOW,
    XIMAGE_SURFACE_TYPE_PIXMAP,
-   XIMAGE_SURFACE_TYPE_PBUFFER
 };
 
 struct ximage_display {
@@ -65,7 +61,7 @@ struct ximage_display {
 };
 
 struct ximage_buffer {
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct xlib_drawable xdraw;
 };
 
@@ -116,7 +112,7 @@ ximage_surface_free_buffer(struct native_surface *nsurf,
    struct ximage_surface *xsurf = ximage_surface(nsurf);
    struct ximage_buffer *xbuf = &xsurf->buffers[which];
 
-   pipe_texture_reference(&xbuf->texture, NULL);
+   pipe_resource_reference(&xbuf->texture, NULL);
 }
 
 static boolean
@@ -126,7 +122,7 @@ ximage_surface_alloc_buffer(struct native_surface *nsurf,
    struct ximage_surface *xsurf = ximage_surface(nsurf);
    struct ximage_buffer *xbuf = &xsurf->buffers[which];
    struct pipe_screen *screen = xsurf->xdpy->base.screen;
-   struct pipe_texture templ;
+   struct pipe_resource templ;
 
    /* free old data */
    if (xbuf->texture)
@@ -138,23 +134,21 @@ ximage_surface_alloc_buffer(struct native_surface *nsurf,
    templ.width0 = xsurf->width;
    templ.height0 = xsurf->height;
    templ.depth0 = 1;
-   templ.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
-
-   if (xsurf->type != XIMAGE_SURFACE_TYPE_PBUFFER) {
-      switch (which) {
-      case NATIVE_ATTACHMENT_FRONT_LEFT:
-      case NATIVE_ATTACHMENT_FRONT_RIGHT:
-         templ.tex_usage |= PIPE_TEXTURE_USAGE_SCANOUT;
-         break;
-      case NATIVE_ATTACHMENT_BACK_LEFT:
-      case NATIVE_ATTACHMENT_BACK_RIGHT:
-         templ.tex_usage |= PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
-         break;
-      default:
-         break;
-      }
+   templ.bind = PIPE_BIND_RENDER_TARGET;
+
+   switch (which) {
+   case NATIVE_ATTACHMENT_FRONT_LEFT:
+   case NATIVE_ATTACHMENT_FRONT_RIGHT:
+      templ.bind |= PIPE_BIND_SCANOUT;
+      break;
+   case NATIVE_ATTACHMENT_BACK_LEFT:
+   case NATIVE_ATTACHMENT_BACK_RIGHT:
+      templ.bind |= PIPE_BIND_DISPLAY_TARGET;
+      break;
+   default:
+      break;
    }
-   xbuf->texture = screen->texture_create(screen, &templ);
+   xbuf->texture = screen->resource_create(screen, &templ);
    if (xbuf->texture) {
       xbuf->xdraw.visual = xsurf->visual.visual;
       xbuf->xdraw.depth = xsurf->visual.depth;
@@ -182,10 +176,6 @@ ximage_surface_update_geometry(struct native_surface *nsurf)
    unsigned int w, h, border, depth;
    boolean updated = FALSE;
 
-   /* pbuffer has fixed geometry */
-   if (xsurf->type == XIMAGE_SURFACE_TYPE_PBUFFER)
-      return FALSE;
-
    ok = XGetGeometry(xsurf->xdpy->dpy, xsurf->drawable,
          &root, &x, &y, &w, &h, &border, &depth);
    if (ok && (xsurf->width != w || xsurf->height != h)) {
@@ -263,9 +253,6 @@ ximage_surface_draw_buffer(struct native_surface *nsurf,
    struct pipe_screen *screen = xsurf->xdpy->base.screen;
    struct pipe_surface *psurf;
 
-   if (xsurf->type == XIMAGE_SURFACE_TYPE_PBUFFER)
-      return TRUE;
-
    assert(xsurf->drawable && xbuf->texture);
 
    psurf = xsurf->draw_surface;
@@ -273,7 +260,7 @@ ximage_surface_draw_buffer(struct native_surface *nsurf,
       pipe_surface_reference(&xsurf->draw_surface, NULL);
 
       psurf = screen->get_tex_surface(screen,
-            xbuf->texture, 0, 0, 0, PIPE_BUFFER_USAGE_CPU_READ);
+            xbuf->texture, 0, 0, 0, PIPE_BIND_DISPLAY_TARGET);
       if (!psurf)
          return FALSE;
 
@@ -329,7 +316,7 @@ ximage_surface_swap_buffers(struct native_surface *nsurf)
 
 static boolean
 ximage_surface_validate(struct native_surface *nsurf, uint attachment_mask,
-                        unsigned int *seq_num, struct pipe_texture **textures,
+                        unsigned int *seq_num, struct pipe_resource **textures,
                         int *width, int *height)
 {
    struct ximage_surface *xsurf = ximage_surface(nsurf);
@@ -350,7 +337,7 @@ ximage_surface_validate(struct native_surface *nsurf, uint attachment_mask,
             struct ximage_buffer *xbuf = &xsurf->buffers[att];
 
             textures[att] = NULL;
-            pipe_texture_reference(&textures[att], xbuf->texture);
+            pipe_resource_reference(&textures[att], xbuf->texture);
          }
       }
    }
@@ -382,7 +369,7 @@ ximage_surface_destroy(struct native_surface *nsurf)
    for (i = 0; i < NUM_NATIVE_ATTACHMENTS; i++)
       ximage_surface_free_buffer(&xsurf->base, i);
 
-   free(xsurf);
+   FREE(xsurf);
 }
 
 static struct ximage_surface *
@@ -404,12 +391,10 @@ ximage_display_create_surface(struct native_display *ndpy,
    xsurf->color_format = xconf->base.color_format;
    xsurf->drawable = drawable;
 
-   if (xsurf->type != XIMAGE_SURFACE_TYPE_PBUFFER) {
-      xsurf->drawable = drawable;
-      xsurf->visual = *xconf->visual;
-      /* initialize the geometry */
-      ximage_surface_update_buffers(&xsurf->base, 0x0);
-   }
+   xsurf->drawable = drawable;
+   xsurf->visual = *xconf->visual;
+   /* initialize the geometry */
+   ximage_surface_update_buffers(&xsurf->base, 0x0);
 
    xsurf->base.destroy = ximage_surface_destroy;
    xsurf->base.swap_buffers = ximage_surface_swap_buffers;
@@ -444,22 +429,6 @@ ximage_display_create_pixmap_surface(struct native_display *ndpy,
    return (xsurf) ? &xsurf->base : NULL;
 }
 
-static struct native_surface *
-ximage_display_create_pbuffer_surface(struct native_display *ndpy,
-                                      const struct native_config *nconf,
-                                      uint width, uint height)
-{
-   struct ximage_surface *xsurf;
-
-   xsurf = ximage_display_create_surface(ndpy, XIMAGE_SURFACE_TYPE_PBUFFER,
-         (Drawable) None, nconf);
-   if (xsurf) {
-      xsurf->width = width;
-      xsurf->height = height;
-   }
-   return (xsurf) ? &xsurf->base : NULL;
-}
-
 static enum pipe_format
 choose_format(const XVisualInfo *vinfo)
 {
@@ -493,7 +462,7 @@ ximage_display_get_configs(struct native_display *ndpy, int *num_configs)
    /* first time */
    if (!xdpy->configs) {
       const XVisualInfo *visuals;
-      int num_visuals, count, j;
+      int num_visuals, count;
 
       visuals = x11_screen_get_visuals(xdpy->xscr, &num_visuals);
       if (!visuals)
@@ -503,57 +472,42 @@ ximage_display_get_configs(struct native_display *ndpy, int *num_configs)
        * Create two configs for each visual.
        * One with depth/stencil buffer; one without
        */
-      xdpy->configs = calloc(num_visuals * 2, sizeof(*xdpy->configs));
+      xdpy->configs = CALLOC(num_visuals * 2, sizeof(*xdpy->configs));
       if (!xdpy->configs)
          return NULL;
 
       count = 0;
       for (i = 0; i < num_visuals; i++) {
-         for (j = 0; j < 2; j++) {
-            struct ximage_config *xconf = &xdpy->configs[count];
-            __GLcontextModes *mode = &xconf->base.mode;
-
-            xconf->visual = &visuals[i];
-            xconf->base.color_format = choose_format(xconf->visual);
-            if (xconf->base.color_format == PIPE_FORMAT_NONE)
-               continue;
-
-            x11_screen_convert_visual(xdpy->xscr, xconf->visual, mode);
-            /* support double buffer mode */
-            mode->doubleBufferMode = TRUE;
-
-            xconf->base.depth_format = PIPE_FORMAT_NONE;
-            xconf->base.stencil_format = PIPE_FORMAT_NONE;
-            /* create the second config with depth/stencil buffer */
-            if (j == 1) {
-               xconf->base.depth_format = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
-               xconf->base.stencil_format = PIPE_FORMAT_Z24_UNORM_S8_USCALED;
-               mode->depthBits = 24;
-               mode->stencilBits = 8;
-               mode->haveDepthBuffer = TRUE;
-               mode->haveStencilBuffer = TRUE;
-            }
-
-            mode->maxPbufferWidth = 4096;
-            mode->maxPbufferHeight = 4096;
-            mode->maxPbufferPixels = 4096 * 4096;
-            mode->drawableType =
-               GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
-            mode->swapMethod = GLX_SWAP_EXCHANGE_OML;
-
-            if (mode->alphaBits)
-               mode->bindToTextureRgba = TRUE;
-            else
-               mode->bindToTextureRgb = TRUE;
-
-            count++;
-         }
+         struct ximage_config *xconf = &xdpy->configs[count];
+
+         xconf->visual = &visuals[i];
+         xconf->base.color_format = choose_format(xconf->visual);
+         if (xconf->base.color_format == PIPE_FORMAT_NONE)
+            continue;
+
+         xconf->base.buffer_mask =
+            (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
+            (1 << NATIVE_ATTACHMENT_BACK_LEFT);
+
+         xconf->base.window_bit = TRUE;
+         xconf->base.pixmap_bit = TRUE;
+
+         xconf->base.native_visual_id = xconf->visual->visualid;
+#if defined(__cplusplus) || defined(c_plusplus)
+         xconf->base.native_visual_type = xconf->visual->c_class;
+#else
+         xconf->base.native_visual_type = xconf->visual->class;
+#endif
+
+         xconf->base.slow_config = TRUE;
+
+         count++;
       }
 
       xdpy->num_configs = count;
    }
 
-   configs = malloc(xdpy->num_configs * sizeof(*configs));
+   configs = MALLOC(xdpy->num_configs * sizeof(*configs));
    if (configs) {
       for (i = 0; i < xdpy->num_configs; i++)
          configs[i] = (const struct native_config *) &xdpy->configs[i];
@@ -616,14 +570,14 @@ ximage_display_destroy(struct native_display *ndpy)
    struct ximage_display *xdpy = ximage_display(ndpy);
 
    if (xdpy->configs)
-      free(xdpy->configs);
+      FREE(xdpy->configs);
 
    xdpy->base.screen->destroy(xdpy->base.screen);
 
    x11_screen_destroy(xdpy->xscr);
    if (xdpy->own_dpy)
       XCloseDisplay(xdpy->dpy);
-   free(xdpy);
+   FREE(xdpy);
 }
 
 
@@ -694,7 +648,7 @@ x11_create_ximage_display(EGLNativeDisplayType dpy,
    if (!xdpy->dpy) {
       xdpy->dpy = XOpenDisplay(NULL);
       if (!xdpy->dpy) {
-         free(xdpy);
+         FREE(xdpy);
          return NULL;
       }
       xdpy->own_dpy = TRUE;
@@ -705,7 +659,7 @@ x11_create_ximage_display(EGLNativeDisplayType dpy,
    xdpy->xscr_number = DefaultScreen(xdpy->dpy);
    xdpy->xscr = x11_screen_create(xdpy->dpy, xdpy->xscr_number);
    if (!xdpy->xscr) {
-      free(xdpy);
+      FREE(xdpy);
       return NULL;
    }
 
@@ -718,7 +672,6 @@ x11_create_ximage_display(EGLNativeDisplayType dpy,
    xdpy->base.is_pixmap_supported = ximage_display_is_pixmap_supported;
    xdpy->base.create_window_surface = ximage_display_create_window_surface;
    xdpy->base.create_pixmap_surface = ximage_display_create_pixmap_surface;
-   xdpy->base.create_pbuffer_surface = ximage_display_create_pbuffer_surface;
 
    return &xdpy->base;
 }
diff --git a/src/gallium/state_trackers/egl/x11/x11_screen.c b/src/gallium/state_trackers/egl/x11/x11_screen.c
index f4096114844..6bdff26ec08 100644
--- a/src/gallium/state_trackers/egl/x11/x11_screen.c
+++ b/src/gallium/state_trackers/egl/x11/x11_screen.c
@@ -14,24 +14,24 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <xf86drm.h>
 #include <X11/Xlibint.h>
 #include <X11/extensions/XShm.h>
+
 #include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_format.h"
-#include "xf86drm.h"
 #include "egllog.h"
 
 #include "x11_screen.h"
@@ -109,7 +109,7 @@ x11_screen_destroy(struct x11_screen *xscr)
 
    if (xscr->visuals)
       XFree(xscr->visuals);
-   free(xscr);
+   FREE(xscr);
 }
 
 static boolean
@@ -176,63 +176,6 @@ x11_screen_get_visuals(struct x11_screen *xscr, int *num_visuals)
    return xscr->visuals;
 }
 
-void
-x11_screen_convert_visual(struct x11_screen *xscr, const XVisualInfo *visual,
-                          __GLcontextModes *mode)
-{
-   int r, g, b, a;
-   int visual_type;
-
-   r = util_bitcount(visual->red_mask);
-   g = util_bitcount(visual->green_mask);
-   b = util_bitcount(visual->blue_mask);
-   a = visual->depth - (r + g + b);
-#if defined(__cplusplus) || defined(c_plusplus)
-   visual_type = visual->c_class;
-#else
-   visual_type = visual->class;
-#endif
-
-   /* convert to GLX visual type */
-   switch (visual_type) {
-   case TrueColor:
-      visual_type = GLX_TRUE_COLOR;
-      break;
-   case DirectColor:
-      visual_type = GLX_DIRECT_COLOR;
-      break;
-   case PseudoColor:
-      visual_type = GLX_PSEUDO_COLOR;
-      break;
-   case StaticColor:
-      visual_type = GLX_STATIC_COLOR;
-      break;
-   case GrayScale:
-      visual_type = GLX_GRAY_SCALE;
-      break;
-   case StaticGray:
-      visual_type = GLX_STATIC_GRAY;
-      break;
-   default:
-      visual_type = GLX_NONE;
-      break;
-   }
-
-   mode->rgbBits = r + g + b + a;
-   mode->redBits = r;
-   mode->greenBits = g;
-   mode->blueBits = b;
-   mode->alphaBits = a;
-   mode->visualID = visual->visualid;
-   mode->visualType = visual_type;
-
-   /* sane defaults */
-   mode->renderType = GLX_RGBA_BIT;
-   mode->rgbMode = TRUE;
-   mode->visualRating = GLX_SLOW_CONFIG;
-   mode->xRenderable = TRUE;
-}
-
 /**
  * Return the GLX fbconfigs.
  */
@@ -435,7 +378,7 @@ x11_context_modes_create(unsigned count)
 
    next = &base;
    for (i = 0; i < count; i++) {
-      *next = (__GLcontextModes *) calloc(1, size);
+      *next = (__GLcontextModes *) CALLOC(1, size);
       if (*next == NULL) {
          x11_context_modes_destroy(base);
          base = NULL;
@@ -455,7 +398,7 @@ x11_context_modes_destroy(__GLcontextModes *modes)
 {
    while (modes != NULL) {
       __GLcontextModes *next = modes->next;
-      free(modes);
+      FREE(modes);
       modes = next;
    }
 }
diff --git a/src/gallium/state_trackers/egl/x11/x11_screen.h b/src/gallium/state_trackers/egl/x11/x11_screen.h
index 37e8d5a40e6..a3c5ee1491e 100644
--- a/src/gallium/state_trackers/egl/x11/x11_screen.h
+++ b/src/gallium/state_trackers/egl/x11/x11_screen.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 _X11_SCREEN_H_
@@ -28,6 +29,8 @@
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/dri2tokens.h>
+#include "GL/gl.h" /* for GL types needed by __GLcontextModes */
+#include "GL/internal/glcore.h"  /* for __GLcontextModes */
 #include "pipe/p_compiler.h"
 #include "common/native.h"
 
@@ -64,10 +67,6 @@ x11_screen_support(struct x11_screen *xscr, enum x11_screen_extension ext);
 const XVisualInfo *
 x11_screen_get_visuals(struct x11_screen *xscr, int *num_visuals);
 
-void
-x11_screen_convert_visual(struct x11_screen *xscr, const XVisualInfo *visual,
-                          __GLcontextModes *mode);
-
 const __GLcontextModes *
 x11_screen_get_glx_configs(struct x11_screen *xscr);
 
diff --git a/src/gallium/state_trackers/es/Makefile b/src/gallium/state_trackers/es/Makefile
index 089d4411675..7370634ea24 100644
--- a/src/gallium/state_trackers/es/Makefile
+++ b/src/gallium/state_trackers/es/Makefile
@@ -22,6 +22,8 @@ GLES_2_LIB = GLESv2
 GLES_2_LIB_NAME = lib$(GLES_2_LIB).so
 
 
+# These two objects indirectly reference all public functions thanks to the use
+# of _glapi_get_proc_address.
 ES1_OBJECTS = st_es1.o
 ES2_OBJECTS = st_es2.o
 
@@ -56,9 +58,7 @@ $(TOP)/$(LIB_DIR)/$(GLES_1_LIB_NAME): $(ES1_OBJECTS) $(ES1_LIBS) $(GALLIUM_AUXIL
 		-minor $(GLES_1_VERSION_MINOR) \
 		-patch $(GLES_1_VERSION_PATCH) \
 		-install $(TOP)/$(LIB_DIR) $(MKLIB_OPTIONS) \
-		$(ES1_OBJECTS) \
-		-Wl,--whole-archive $(ES1_LIBS) -Wl,--no-whole-archive \
-		$(GALLIUM_AUXILIARIES) $(SYS_LIBS)
+		$(ES1_OBJECTS) $(ES1_LIBS) $(GALLIUM_AUXILIARIES) $(SYS_LIBS)
 
 $(TOP)/$(LIB_DIR)/$(GLES_2_LIB_NAME): $(ES2_OBJECTS) $(ES1_LIBS) $(GALLIUM_AUXILIARIES)
 	$(MKLIB) -o $(GLES_2_LIB) -linker '$(CC)' -ldflags '$(LDFLAGS)' \
@@ -66,9 +66,7 @@ $(TOP)/$(LIB_DIR)/$(GLES_2_LIB_NAME): $(ES2_OBJECTS) $(ES1_LIBS) $(GALLIUM_AUXIL
 		-minor $(GLES_2_VERSION_MINOR) \
 		-patch $(GLES_2_VERSION_PATCH) \
 		-install $(TOP)/$(LIB_DIR) $(MKLIB_OPTIONS) \
-		$(ES2_OBJECTS) \
-		-Wl,--whole-archive $(ES2_LIBS) -Wl,--no-whole-archive \
-		$(GALLIUM_AUXILIARIES) $(SYS_LIBS)
+		$(ES2_OBJECTS) $(ES2_LIBS) $(GALLIUM_AUXILIARIES) $(SYS_LIBS)
 
 install: default
 	$(INSTALL) -d $(DESTDIR)$(INSTALL_DIR)/include/GLES
diff --git a/src/gallium/state_trackers/glx/xlib/xm_api.c b/src/gallium/state_trackers/glx/xlib/xm_api.c
index c394430b94f..f3b0617f76b 100644
--- a/src/gallium/state_trackers/glx/xlib/xm_api.c
+++ b/src/gallium/state_trackers/glx/xlib/xm_api.c
@@ -339,7 +339,7 @@ static enum pipe_format
 choose_depth_stencil_format(XMesaDisplay xmdpy, int depth, int stencil)
 {
    const enum pipe_texture_target target = PIPE_TEXTURE_2D;
-   const unsigned tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
+   const unsigned tex_usage = PIPE_BIND_DEPTH_STENCIL;
    const unsigned geom_flags = (PIPE_TEXTURE_GEOM_NON_SQUARE |
                                 PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO);
    enum pipe_format formats[8], fmt;
diff --git a/src/gallium/state_trackers/glx/xlib/xm_st.c b/src/gallium/state_trackers/glx/xlib/xm_st.c
index b6ed7e8e1e8..27b6da94bce 100644
--- a/src/gallium/state_trackers/glx/xlib/xm_st.c
+++ b/src/gallium/state_trackers/glx/xlib/xm_st.c
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
@@ -39,7 +40,7 @@ struct xmesa_st_framebuffer {
    struct st_visual stvis;
 
    unsigned texture_width, texture_height, texture_mask;
-   struct pipe_texture *textures[ST_ATTACHMENT_COUNT];
+   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
 
    struct pipe_surface *display_surface;
 };
@@ -58,7 +59,7 @@ xmesa_st_framebuffer_display(struct st_framebuffer_iface *stfbi,
                              enum st_attachment_type statt)
 {
    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
-   struct pipe_texture *ptex = xstfb->textures[statt];
+   struct pipe_resource *ptex = xstfb->textures[statt];
    struct pipe_surface *psurf;
 
    if (!ptex)
@@ -70,7 +71,7 @@ xmesa_st_framebuffer_display(struct st_framebuffer_iface *stfbi,
       pipe_surface_reference(&xstfb->display_surface, NULL);
 
       psurf = xstfb->screen->get_tex_surface(xstfb->screen,
-            ptex, 0, 0, 0, PIPE_BUFFER_USAGE_CPU_READ);
+            ptex, 0, 0, 0, PIPE_BIND_DISPLAY_TARGET);
       if (!psurf)
          return FALSE;
 
@@ -93,8 +94,8 @@ xmesa_st_framebuffer_copy_textures(struct st_framebuffer_iface *stfbi,
                                    unsigned width, unsigned height)
 {
    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
-   struct pipe_texture *src_ptex = xstfb->textures[src_statt];
-   struct pipe_texture *dst_ptex = xstfb->textures[dst_statt];
+   struct pipe_resource *src_ptex = xstfb->textures[src_statt];
+   struct pipe_resource *dst_ptex = xstfb->textures[dst_statt];
    struct pipe_surface *src, *dst;
    struct pipe_context *pipe;
 
@@ -110,9 +111,9 @@ xmesa_st_framebuffer_copy_textures(struct st_framebuffer_iface *stfbi,
    }
 
    src = xstfb->screen->get_tex_surface(xstfb->screen,
-         src_ptex, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ);
+         src_ptex, 0, 0, 0, PIPE_BIND_BLIT_SOURCE);
    dst = xstfb->screen->get_tex_surface(xstfb->screen,
-         dst_ptex, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
+         dst_ptex, 0, 0, 0, PIPE_BIND_BLIT_DESTINATION);
 
    if (src && dst)
       pipe->surface_copy(pipe, dst, x, y, src, x, y, width, height);
@@ -130,13 +131,13 @@ xmesa_st_framebuffer_validate_textures(struct st_framebuffer_iface *stfbi,
                                        unsigned mask)
 {
    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
-   struct pipe_texture templ;
+   struct pipe_resource templ;
    unsigned i;
 
    /* remove outdated textures */
    if (xstfb->texture_width != width || xstfb->texture_height != height) {
       for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
-         pipe_texture_reference(&xstfb->textures[i], NULL);
+         pipe_resource_reference(&xstfb->textures[i], NULL);
    }
 
    memset(&templ, 0, sizeof(templ));
@@ -148,7 +149,7 @@ xmesa_st_framebuffer_validate_textures(struct st_framebuffer_iface *stfbi,
 
    for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
       enum pipe_format format;
-      unsigned tex_usage;
+      unsigned bind;
 
       /* the texture already exists or not requested */
       if (xstfb->textures[i] || !(mask & (1 << i))) {
@@ -164,12 +165,12 @@ xmesa_st_framebuffer_validate_textures(struct st_framebuffer_iface *stfbi,
       case ST_ATTACHMENT_FRONT_RIGHT:
       case ST_ATTACHMENT_BACK_RIGHT:
          format = xstfb->stvis.color_format;
-         tex_usage = PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                     PIPE_TEXTURE_USAGE_RENDER_TARGET;
+         bind = PIPE_BIND_DISPLAY_TARGET |
+                     PIPE_BIND_RENDER_TARGET;
          break;
       case ST_ATTACHMENT_DEPTH_STENCIL:
          format = xstfb->stvis.depth_stencil_format;
-         tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
+         bind = PIPE_BIND_DEPTH_STENCIL;
          break;
       default:
          format = PIPE_FORMAT_NONE;
@@ -178,10 +179,10 @@ xmesa_st_framebuffer_validate_textures(struct st_framebuffer_iface *stfbi,
 
       if (format != PIPE_FORMAT_NONE) {
          templ.format = format;
-         templ.tex_usage = tex_usage;
+         templ.bind = bind;
 
          xstfb->textures[i] =
-            xstfb->screen->texture_create(xstfb->screen, &templ);
+            xstfb->screen->resource_create(xstfb->screen, &templ);
       }
    }
 
@@ -194,7 +195,7 @@ static boolean
 xmesa_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
                               const enum st_attachment_type *statts,
                               unsigned count,
-                              struct pipe_texture **out)
+                              struct pipe_resource **out)
 {
    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
    unsigned statt_mask, new_mask, i;
@@ -231,7 +232,7 @@ xmesa_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
 
    for (i = 0; i < count; i++) {
       out[i] = NULL;
-      pipe_texture_reference(&out[i], xstfb->textures[statts[i]]);
+      pipe_resource_reference(&out[i], xstfb->textures[statts[i]]);
    }
 
    return TRUE;
@@ -291,7 +292,7 @@ xmesa_destroy_st_framebuffer(struct st_framebuffer_iface *stfbi)
    pipe_surface_reference(&xstfb->display_surface, NULL);
 
    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
-      pipe_texture_reference(&xstfb->textures[i], NULL);
+      pipe_resource_reference(&xstfb->textures[i], NULL);
 
    FREE(xstfb);
    FREE(stfbi);
@@ -305,7 +306,7 @@ xmesa_swap_st_framebuffer(struct st_framebuffer_iface *stfbi)
 
    ret = xmesa_st_framebuffer_display(stfbi, ST_ATTACHMENT_BACK_LEFT);
    if (ret) {
-      struct pipe_texture **front, **back, *tmp;
+      struct pipe_resource **front, **back, *tmp;
 
       front = &xstfb->textures[ST_ATTACHMENT_FRONT_LEFT];
       back = &xstfb->textures[ST_ATTACHMENT_BACK_LEFT];
diff --git a/src/gallium/state_trackers/glx/xlib/xm_st.h b/src/gallium/state_trackers/glx/xlib/xm_st.h
index 396495c1893..862597617e3 100644
--- a/src/gallium/state_trackers/glx/xlib/xm_st.h
+++ b/src/gallium/state_trackers/glx/xlib/xm_st.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
diff --git a/src/gallium/state_trackers/python/SConscript b/src/gallium/state_trackers/python/SConscript
index 781f54bf2b9..aadeaa0a359 100644
--- a/src/gallium/state_trackers/python/SConscript
+++ b/src/gallium/state_trackers/python/SConscript
@@ -44,11 +44,10 @@ if 'python' in env['statetrackers']:
         gallium,
     ])
 
-    if 'llvmpipe' in env['drivers']:
+    if env['llvm']:
         env.Append(CPPDEFINES = ['HAVE_LLVMPIPE'])
-        env.Tool('llvm')
         env.Prepend(LIBS = [llvmpipe])
-    if 'softpipe' in env['drivers']:
+    if True:
         env.Append(CPPDEFINES = ['HAVE_SOFTPIPE'])
         env.Prepend(LIBS = [softpipe])
 
diff --git a/src/gallium/state_trackers/python/gallium.i b/src/gallium/state_trackers/python/gallium.i
index aeed1cd118c..c6084f78aee 100644
--- a/src/gallium/state_trackers/python/gallium.i
+++ b/src/gallium/state_trackers/python/gallium.i
@@ -72,9 +72,8 @@
 
 %rename(Device) st_device;
 %rename(Context) st_context;
-%rename(Texture) pipe_texture;
+%rename(Resource) pipe_resource;
 %rename(Surface) st_surface;
-%rename(Buffer) pipe_buffer;
 
 %rename(BlendColor) pipe_blend_color;
 %rename(Blend) pipe_blend_state;
diff --git a/src/gallium/state_trackers/python/p_context.i b/src/gallium/state_trackers/python/p_context.i
index 02ce5647eb6..13c8d1a95e9 100644
--- a/src/gallium/state_trackers/python/p_context.i
+++ b/src/gallium/state_trackers/python/p_context.i
@@ -127,6 +127,45 @@ struct st_context {
       $self->gs = gs;
    }
 
+   struct pipe_sampler_view *
+   create_sampler_view(struct pipe_resource *texture,
+                       enum pipe_format format = PIPE_FORMAT_NONE,
+                       unsigned first_level = 0,
+                       unsigned last_level = ~0,
+                       unsigned swizzle_r = 0,
+                       unsigned swizzle_g = 1,
+                       unsigned swizzle_b = 2,
+                       unsigned swizzle_a = 3)
+   {
+      struct pipe_context *pipe = $self->pipe;
+      struct pipe_sampler_view templat;
+
+      memset(&templat, 0, sizeof templat);
+      if (format == PIPE_FORMAT_NONE) {
+         templat.format = texture->format;
+      } else {
+         templat.format = format;
+      }
+      templat.last_level = MIN2(last_level, texture->last_level);
+      templat.first_level = first_level;
+      templat.last_level = last_level;
+      templat.swizzle_r = swizzle_r;
+      templat.swizzle_g = swizzle_g;
+      templat.swizzle_b = swizzle_b;
+      templat.swizzle_a = swizzle_a;
+
+      return pipe->create_sampler_view(pipe, texture, &templat);
+   }
+
+   void
+   sampler_view_destroy(struct pipe_context *ctx,
+                        struct pipe_sampler_view *view)
+   {
+      struct pipe_context *pipe = $self->pipe;
+
+      pipe->sampler_view_destroy(pipe, view);
+   }
+
    /*
     * Parameter-like state (or properties)
     */
@@ -144,7 +183,7 @@ struct st_context {
    }
 
    void set_constant_buffer(unsigned shader, unsigned index,
-                            struct pipe_buffer *buffer ) 
+                            struct pipe_resource *buffer ) 
    {
       $self->pipe->set_constant_buffer($self->pipe, shader, index, buffer);
    }
@@ -167,8 +206,28 @@ struct st_context {
       cso_set_viewport($self->cso, state);
    }
 
+   void set_fragment_sampler_view(unsigned index,
+                                  struct pipe_sampler_view *view)
+   {
+      pipe_sampler_view_reference(&$self->fragment_sampler_views[index], view);
+
+      $self->pipe->set_fragment_sampler_views($self->pipe,
+                                              PIPE_MAX_SAMPLERS,
+                                              $self->fragment_sampler_views);
+   }
+
+   void set_vertex_sampler_view(unsigned index,
+                                struct pipe_sampler_view *view)
+   {
+      pipe_sampler_view_reference(&$self->vertex_sampler_views[index], view);
+
+      $self->pipe->set_vertex_sampler_views($self->pipe,
+                                            PIPE_MAX_VERTEX_SAMPLERS,
+                                            $self->vertex_sampler_views);
+   }
+
    void set_fragment_sampler_texture(unsigned index,
-                                     struct pipe_texture *texture) {
+                                     struct pipe_resource *texture) {
       struct pipe_sampler_view templ;
 
       if(!texture)
@@ -186,7 +245,7 @@ struct st_context {
    }
 
    void set_vertex_sampler_texture(unsigned index,
-                                   struct pipe_texture *texture) {
+                                   struct pipe_resource *texture) {
       struct pipe_sampler_view templ;
 
       if(!texture)
@@ -208,7 +267,7 @@ struct st_context {
                           unsigned stride, 
                           unsigned max_index,
                           unsigned buffer_offset,
-                          struct pipe_buffer *buffer)
+                          struct pipe_resource *buffer)
    {
       unsigned i;
       struct pipe_vertex_buffer state;
@@ -252,7 +311,7 @@ struct st_context {
       $self->pipe->draw_arrays($self->pipe, mode, start, count);
    }
 
-   void draw_elements( struct pipe_buffer *indexBuffer,
+   void draw_elements( struct pipe_resource *indexBuffer,
                        unsigned indexSize,
                        unsigned mode, unsigned start, unsigned count) 
    {
@@ -262,7 +321,7 @@ struct st_context {
                                  mode, start, count);
    }
 
-   void draw_range_elements( struct pipe_buffer *indexBuffer,
+   void draw_range_elements( struct pipe_resource *indexBuffer,
                              unsigned indexSize, unsigned minIndex, unsigned maxIndex,
                              unsigned mode, unsigned start, unsigned count)
    {
@@ -279,7 +338,8 @@ struct st_context {
    {
       struct pipe_context *pipe = $self->pipe;
       struct pipe_screen *screen = pipe->screen;
-      struct pipe_buffer *vbuf;
+      struct pipe_resource *vbuf;
+      struct pipe_transfer *transfer;
       struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
       struct pipe_vertex_buffer vbuffer;
       float *map;
@@ -289,17 +349,16 @@ struct st_context {
       size = num_verts * num_attribs * 4 * sizeof(float);
 
       vbuf = pipe_buffer_create(screen,
-                                32,
-                                PIPE_BUFFER_USAGE_VERTEX, 
+                                PIPE_BIND_VERTEX_BUFFER, 
                                 size);
       if(!vbuf)
          goto error1;
-      
-      map = pipe_buffer_map(screen, vbuf, PIPE_BUFFER_USAGE_CPU_WRITE);
+
+      map = pipe_buffer_map(pipe, vbuf, PIPE_TRANSFER_WRITE, &transfer);
       if (!map)
          goto error2;
       memcpy(map, vertices, size);
-      pipe_buffer_unmap(screen, vbuf);
+      pipe_buffer_unmap(pipe, vbuf, transfer);
 
       cso_save_vertex_elements($self->cso);
 
@@ -326,7 +385,7 @@ struct st_context {
       cso_restore_vertex_elements($self->cso);
 
 error2:
-      pipe_buffer_reference(&vbuf, NULL);
+      pipe_resource_reference(&vbuf, NULL);
 error1:
       ;
    }
@@ -362,11 +421,11 @@ error1:
       struct pipe_surface *_dst = NULL;
       struct pipe_surface *_src = NULL;
       
-      _dst = st_pipe_surface(dst, PIPE_BUFFER_USAGE_GPU_WRITE);
+      _dst = st_pipe_surface(dst, PIPE_BIND_BLIT_DESTINATION);
       if(!_dst)
          SWIG_exception(SWIG_ValueError, "couldn't acquire destination surface for writing");
 
-      _src = st_pipe_surface(src, PIPE_BUFFER_USAGE_GPU_READ);
+      _src = st_pipe_surface(src, PIPE_BIND_BLIT_SOURCE);
       if(!_src)
          SWIG_exception(SWIG_ValueError, "couldn't acquire source surface for reading");
       
@@ -384,7 +443,7 @@ error1:
    {
       struct pipe_surface *_dst = NULL;
       
-      _dst = st_pipe_surface(dst, PIPE_BUFFER_USAGE_GPU_WRITE);
+      _dst = st_pipe_surface(dst, PIPE_BIND_BLIT_DESTINATION);
       if(!_dst)
          SWIG_exception(SWIG_ValueError, "couldn't acquire destination surface for writing");
 
@@ -400,7 +459,7 @@ error1:
                     unsigned x, unsigned y, unsigned w, unsigned h,
                     char **STRING, int *LENGTH)
    {
-      struct pipe_texture *texture = surface->texture;
+      struct pipe_resource *texture = surface->texture;
       struct pipe_context *pipe = $self->pipe;
       struct pipe_transfer *transfer;
       unsigned stride;
@@ -411,16 +470,16 @@ error1:
       if(!*STRING)
          return;
 
-      transfer = pipe->get_tex_transfer(pipe,
-                                          surface->texture,
-                                          surface->face,
-                                          surface->level,
-                                          surface->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y, w, h);
+      transfer = pipe_get_transfer(pipe,
+                                   surface->texture,
+                                   surface->face,
+                                   surface->level,
+                                   surface->zslice,
+                                   PIPE_TRANSFER_READ,
+                                   x, y, w, h);
       if(transfer) {
          pipe_get_tile_raw(pipe, transfer, 0, 0, w, h, *STRING, stride);
-         pipe->tex_transfer_destroy(pipe, transfer);
+         pipe->transfer_destroy(pipe, transfer);
       }
    }
 
@@ -430,7 +489,7 @@ error1:
                      unsigned x, unsigned y, unsigned w, unsigned h,
                      const char *STRING, unsigned LENGTH, unsigned stride = 0)
    {
-      struct pipe_texture *texture = surface->texture;
+      struct pipe_resource *texture = surface->texture;
       struct pipe_context *pipe = $self->pipe;
       struct pipe_transfer *transfer;
 
@@ -440,18 +499,18 @@ error1:
       if(LENGTH < util_format_get_nblocksy(texture->format, h) * stride)
          SWIG_exception(SWIG_ValueError, "offset must be smaller than buffer size");
 
-      transfer = pipe->get_tex_transfer(pipe,
-                                          surface->texture,
-                                          surface->face,
-                                          surface->level,
-                                          surface->zslice,
-                                          PIPE_TRANSFER_WRITE,
-                                          x, y, w, h);
+      transfer = pipe_get_transfer(pipe,
+                                   surface->texture,
+                                   surface->face,
+                                   surface->level,
+                                   surface->zslice,
+                                   PIPE_TRANSFER_WRITE,
+                                   x, y, w, h);
       if(!transfer)
          SWIG_exception(SWIG_MemoryError, "couldn't initiate transfer");
 
       pipe_put_tile_raw(pipe, transfer, 0, 0, w, h, STRING, stride);
-      pipe->tex_transfer_destroy(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
 
    fail:
       return;
@@ -464,16 +523,16 @@ error1:
    {
       struct pipe_context *pipe = $self->pipe;
       struct pipe_transfer *transfer;
-      transfer = pipe->get_tex_transfer(pipe,
-                                          surface->texture,
-                                          surface->face,
-                                          surface->level,
-                                          surface->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y, w, h);
+      transfer = pipe_get_transfer(pipe,
+                                   surface->texture,
+                                   surface->face,
+                                   surface->level,
+                                   surface->zslice,
+                                   PIPE_TRANSFER_READ,
+                                   x, y, w, h);
       if(transfer) {
          pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
-         pipe->tex_transfer_destroy(pipe, transfer);
+         pipe->transfer_destroy(pipe, transfer);
       }
    }
 
@@ -484,16 +543,16 @@ error1:
    {
       struct pipe_context *pipe = $self->pipe;
       struct pipe_transfer *transfer;
-      transfer = pipe->get_tex_transfer(pipe,
-                                          surface->texture,
-                                          surface->face,
-                                          surface->level,
-                                          surface->zslice,
-                                          PIPE_TRANSFER_WRITE,
-                                          x, y, w, h);
+      transfer = pipe_get_transfer(pipe,
+                                   surface->texture,
+                                   surface->face,
+                                   surface->level,
+                                   surface->zslice,
+                                   PIPE_TRANSFER_WRITE,
+                                   x, y, w, h);
       if(transfer) {
          pipe_put_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
-         pipe->tex_transfer_destroy(pipe, transfer);
+         pipe->transfer_destroy(pipe, transfer);
       }
    }
 
@@ -526,14 +585,13 @@ error1:
 
       rgba8 = (unsigned char *) *STRING;
 
-      transfer = pipe->get_tex_transfer(pipe,
-                                          surface->texture,
-                                          surface->face,
-                                          surface->level,
-                                          surface->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y,
-                                          w, h);
+      transfer = pipe_get_transfer(pipe,
+                                   surface->texture,
+                                   surface->face,
+                                   surface->level,
+                                   surface->zslice,
+                                   PIPE_TRANSFER_READ,
+                                   x, y, w, h);
       if(transfer) {
          pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba);
          for(j = 0; j < h; ++j) {
@@ -541,7 +599,7 @@ error1:
                for(k = 0; k <4; ++k)
                   rgba8[j*w*4 + i*4 + k] = float_to_ubyte(rgba[j*w*4 + i*4 + k]);
          }
-         pipe->tex_transfer_destroy(pipe, transfer);
+         pipe->transfer_destroy(pipe, transfer);
       }
 
       free(rgba);
@@ -554,16 +612,16 @@ error1:
    {
       struct pipe_context *pipe = $self->pipe;
       struct pipe_transfer *transfer;
-      transfer = pipe->get_tex_transfer(pipe,
-                                          surface->texture,
-                                          surface->face,
-                                          surface->level,
-                                          surface->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y, w, h);
+      transfer = pipe_get_transfer(pipe,
+                                   surface->texture,
+                                   surface->face,
+                                   surface->level,
+                                   surface->zslice,
+                                   PIPE_TRANSFER_READ,
+                                   x, y, w, h);
       if(transfer) {
          pipe_get_tile_z(pipe, transfer, 0, 0, w, h, z);
-         pipe->tex_transfer_destroy(pipe, transfer);
+         pipe->transfer_destroy(pipe, transfer);
       }
    }
 
@@ -574,16 +632,16 @@ error1:
    {
       struct pipe_context *pipe = $self->pipe;
       struct pipe_transfer *transfer;
-      transfer = pipe->get_tex_transfer(pipe,
-                                          surface->texture,
-                                          surface->face,
-                                          surface->level,
-                                          surface->zslice,
-                                          PIPE_TRANSFER_WRITE,
-                                          x, y, w, h);
+      transfer = pipe_get_transfer(pipe,
+                                   surface->texture,
+                                   surface->face,
+                                   surface->level,
+                                   surface->zslice,
+                                   PIPE_TRANSFER_WRITE,
+                                   x, y, w, h);
       if(transfer) {
          pipe_put_tile_z(pipe, transfer, 0, 0, w, h, z);
-         pipe->tex_transfer_destroy(pipe, transfer);
+         pipe->transfer_destroy(pipe, transfer);
       }
    }
 
@@ -611,20 +669,20 @@ error1:
       if(!rgba2)
          return ~0;
 
-      transfer = pipe->get_tex_transfer(pipe,
-                                          surface->texture,
-                                          surface->face,
-                                          surface->level,
-                                          surface->zslice,
-                                          PIPE_TRANSFER_READ,
-                                          x, y, w, h);
+      transfer = pipe_get_transfer(pipe,
+                                   surface->texture,
+                                   surface->face,
+                                   surface->level,
+                                   surface->zslice,
+                                   PIPE_TRANSFER_READ,
+                                   x, y, w, h);
       if(!transfer) {
          FREE(rgba2);
          return ~0;
       }
 
       pipe_get_tile_rgba(pipe, transfer, 0, 0, w, h, rgba2);
-      pipe->tex_transfer_destroy(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
 
       p1 = rgba;
       p2 = rgba2;
@@ -644,4 +702,54 @@ error1:
       return n;
    }
 
+   %cstring_input_binary(const char *STRING, unsigned LENGTH);
+   void
+   transfer_inline_write(struct pipe_resource *resource,
+                         struct pipe_subresource *sr,
+                         unsigned usage,
+                         const struct pipe_box *box,
+                         const char *STRING, unsigned LENGTH,
+                         unsigned stride,
+                         unsigned slice_stride)
+   {
+      struct pipe_context *pipe = $self->pipe;
+
+      pipe->transfer_inline_write(pipe, resource, *sr, usage, box, STRING, stride, slice_stride);
+   }
+
+   %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
+   void buffer_read(struct pipe_resource *buffer,
+                    char **STRING, int *LENGTH)
+   {
+      struct pipe_context *pipe = $self->pipe;
+
+      assert(buffer->target == PIPE_BUFFER);
+
+      *LENGTH = buffer->width0;
+      *STRING = (char *) malloc(buffer->width0);
+      if(!*STRING)
+         return;
+
+      pipe_buffer_read(pipe, buffer, 0, buffer->width0, *STRING);
+   }
+
+   void buffer_write(struct pipe_resource *buffer,
+                     const char *STRING, unsigned LENGTH, unsigned offset = 0)
+   {
+      struct pipe_context *pipe = $self->pipe;
+
+      assert(buffer->target == PIPE_BUFFER);
+
+      if(offset > buffer->width0)
+         SWIG_exception(SWIG_ValueError, "offset must be smaller than buffer size");
+
+      if(offset + LENGTH > buffer->width0)
+         SWIG_exception(SWIG_ValueError, "data length must fit inside the buffer");
+
+      pipe_buffer_write(pipe, buffer, offset, LENGTH, STRING);
+
+fail:
+      return;
+   }
+
 };
diff --git a/src/gallium/state_trackers/python/p_device.i b/src/gallium/state_trackers/python/p_device.i
index 0eba488a078..959c13f54d9 100644
--- a/src/gallium/state_trackers/python/p_device.i
+++ b/src/gallium/state_trackers/python/p_device.i
@@ -81,20 +81,20 @@ struct st_device {
    /**
     * Check if the given pipe_format is supported as a texture or
     * drawing surface.
-    * \param type  one of PIPE_TEXTURE, PIPE_SURFACE
+    * \param bind bitmask of PIPE_BIND flags
     */
    int is_format_supported( enum pipe_format format, 
                             enum pipe_texture_target target,
-                            unsigned tex_usage, 
+                            unsigned bind, 
                             unsigned geom_flags ) {
       /* We can't really display surfaces with the python statetracker so mask
        * out that usage */
-      tex_usage &= ~PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
+      bind &= ~PIPE_BIND_DISPLAY_TARGET;
 
       return $self->screen->is_format_supported( $self->screen, 
                                                  format, 
                                                  target, 
-                                                 tex_usage, 
+                                                 bind, 
                                                  geom_flags );
    }
 
@@ -103,21 +103,21 @@ struct st_device {
       return st_context_create($self);
    }
 
-   struct pipe_texture * 
-   texture_create(
+   struct pipe_resource * 
+   resource_create(
          enum pipe_format format,
          unsigned width,
          unsigned height,
          unsigned depth = 1,
          unsigned last_level = 0,
          enum pipe_texture_target target = PIPE_TEXTURE_2D,
-         unsigned tex_usage = 0
+         unsigned bind = 0
       ) {
-      struct pipe_texture templat;
+      struct pipe_resource templat;
 
       /* We can't really display surfaces with the python statetracker so mask
        * out that usage */
-      tex_usage &= ~PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
+      bind &= ~PIPE_BIND_DISPLAY_TARGET;
 
       memset(&templat, 0, sizeof(templat));
       templat.format = format;
@@ -126,14 +126,13 @@ struct st_device {
       templat.depth0 = depth;
       templat.last_level = last_level;
       templat.target = target;
-      templat.tex_usage = tex_usage;
+      templat.bind = bind;
 
-      return $self->screen->texture_create($self->screen, &templat);
-   }
-   
-   struct pipe_buffer *
-   buffer_create(unsigned size, unsigned alignment = 0, unsigned usage = 0) {
-      return pipe_buffer_create($self->screen, alignment, usage, size);
+      return $self->screen->resource_create($self->screen, &templat);
    }
 
+   struct pipe_resource *
+   buffer_create(unsigned size, unsigned bind = 0) {
+      return pipe_buffer_create($self->screen, bind, size);
+   }
 };
diff --git a/src/gallium/state_trackers/python/p_state.i b/src/gallium/state_trackers/python/p_state.i
index eda77b56f8e..c1e6ea1b43c 100644
--- a/src/gallium/state_trackers/python/p_state.i
+++ b/src/gallium/state_trackers/python/p_state.i
@@ -114,7 +114,7 @@
          SWIG_exception(SWIG_ValueError, "index out of bounds");
       
       if(surface) {
-         _surface = st_pipe_surface(surface, PIPE_BUFFER_USAGE_GPU_WRITE);
+         _surface = st_pipe_surface(surface, PIPE_BIND_RENDER_TARGET);
          if(!_surface)
             SWIG_exception(SWIG_ValueError, "couldn't acquire surface for writing");
       }
@@ -131,7 +131,7 @@
       struct pipe_surface *_surface = NULL;
 
       if(surface) {
-         _surface = st_pipe_surface(surface, PIPE_BUFFER_USAGE_GPU_WRITE);
+         _surface = st_pipe_surface(surface, PIPE_BIND_DEPTH_STENCIL);
          if(!_surface)
             SWIG_exception(SWIG_ValueError, "couldn't acquire surface for writing");
       }
diff --git a/src/gallium/state_trackers/python/p_texture.i b/src/gallium/state_trackers/python/p_texture.i
index 923a6285289..ae506944c45 100644
--- a/src/gallium/state_trackers/python/p_texture.i
+++ b/src/gallium/state_trackers/python/p_texture.i
@@ -33,97 +33,105 @@
  */
 
 
-%nodefaultctor pipe_texture;
+%nodefaultctor pipe_resource;
 %nodefaultctor st_surface;
-%nodefaultctor pipe_buffer;
 
-%nodefaultdtor pipe_texture;
+%nodefaultdtor pipe_resource;
 %nodefaultdtor st_surface;
-%nodefaultdtor pipe_buffer;
 
-%ignore pipe_texture::screen;
+%ignore pipe_resource::screen;
 
 %immutable st_surface::texture;
 %immutable st_surface::face;
 %immutable st_surface::level;
 %immutable st_surface::zslice;
 
-%newobject pipe_texture::get_surface;
+%newobject pipe_resource::get_surface;
 
+/* Avoid naming conflict with p_inlines.h's pipe_buffer_read/write */ 
+%rename(read) read_; 
+%rename(write) write_; 
 
-%extend pipe_texture {
-   
-   ~pipe_texture() {
-      struct pipe_texture *ptr = $self;
-      pipe_texture_reference(&ptr, NULL);
+%extend pipe_resource {
+
+   ~pipe_resource() {
+      struct pipe_resource *ptr = $self;
+      pipe_resource_reference(&ptr, NULL);
    }
-   
+
    unsigned get_width(unsigned level=0) {
       return u_minify($self->width0, level);
    }
-   
+
    unsigned get_height(unsigned level=0) {
       return u_minify($self->height0, level);
    }
-   
+
    unsigned get_depth(unsigned level=0) {
       return u_minify($self->depth0, level);
    }
-  
+
    /** Get a surface which is a "view" into a texture */
    struct st_surface *
    get_surface(unsigned face=0, unsigned level=0, unsigned zslice=0)
    {
       struct st_surface *surface;
-      
+
       if(face >= ($self->target == PIPE_TEXTURE_CUBE ? 6U : 1U))
          SWIG_exception(SWIG_ValueError, "face out of bounds");
       if(level > $self->last_level)
          SWIG_exception(SWIG_ValueError, "level out of bounds");
       if(zslice >= u_minify($self->depth0, level))
          SWIG_exception(SWIG_ValueError, "zslice out of bounds");
-      
+
       surface = CALLOC_STRUCT(st_surface);
       if(!surface)
          return NULL;
-      
-      pipe_texture_reference(&surface->texture, $self);
+
+      pipe_resource_reference(&surface->texture, $self);
       surface->face = face;
       surface->level = level;
       surface->zslice = zslice;
-      
+
       return surface;
 
    fail:
       return NULL;
    }
-   
+
+   unsigned __len__(void) 
+   {
+      assert($self->target == PIPE_BUFFER);
+      assert(p_atomic_read(&$self->reference.count) > 0);
+      return $self->width0;
+   }
+
 };
 
 struct st_surface
 {
    %immutable;
-   
-   struct pipe_texture *texture;
+
+   struct pipe_resource *texture;
    unsigned face;
    unsigned level;
    unsigned zslice;
-   
+
 };
 
 %extend st_surface {
-   
+
    %immutable;
-   
+
    unsigned format;
    unsigned width;
    unsigned height;
-   
+
    ~st_surface() {
-      pipe_texture_reference(&$self->texture, NULL);
+      pipe_resource_reference(&$self->texture, NULL);
       FREE($self);
    }
-   
+
 
 };
 
@@ -146,55 +154,3 @@ struct st_surface
       return u_minify(surface->texture->height0, surface->level);
    }
 %}
-
-/* Avoid naming conflict with p_inlines.h's pipe_buffer_read/write */ 
-%rename(read) read_; 
-%rename(write) write_; 
-
-%extend pipe_buffer {
-   
-   ~pipe_buffer() {
-      struct pipe_buffer *ptr = $self;
-      pipe_buffer_reference(&ptr, NULL);
-   }
-   
-   unsigned __len__(void) 
-   {
-      assert(p_atomic_read(&$self->reference.count) > 0);
-      return $self->size;
-   }
-   
-   %cstring_output_allocate_size(char **STRING, int *LENGTH, free(*$1));
-   void read_(char **STRING, int *LENGTH)
-   {
-      struct pipe_screen *screen = $self->screen;
-      
-      assert(p_atomic_read(&$self->reference.count) > 0);
-      
-      *LENGTH = $self->size;
-      *STRING = (char *) malloc($self->size);
-      if(!*STRING)
-         return;
-      
-      pipe_buffer_read(screen, $self, 0, $self->size, *STRING);
-   }
-   
-   %cstring_input_binary(const char *STRING, unsigned LENGTH);
-   void write_(const char *STRING, unsigned LENGTH, unsigned offset = 0) 
-   {
-      struct pipe_screen *screen = $self->screen;
-      
-      assert(p_atomic_read(&$self->reference.count) > 0);
-      
-      if(offset > $self->size)
-         SWIG_exception(SWIG_ValueError, "offset must be smaller than buffer size");
-
-      if(offset + LENGTH > $self->size)
-         SWIG_exception(SWIG_ValueError, "data length must fit inside the buffer");
-
-      pipe_buffer_write(screen, $self, offset, LENGTH, STRING);
-
-fail:
-      return;
-   }
-};
diff --git a/src/gallium/state_trackers/python/st_device.c b/src/gallium/state_trackers/python/st_device.c
index 4f227a092c5..135acad45e1 100644
--- a/src/gallium/state_trackers/python/st_device.c
+++ b/src/gallium/state_trackers/python/st_device.c
@@ -129,7 +129,7 @@ st_context_destroy(struct st_context *st_ctx)
          pipe_sampler_view_reference(&st_ctx->fragment_sampler_views[i], NULL);
       for(i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; ++i)
          pipe_sampler_view_reference(&st_ctx->vertex_sampler_views[i], NULL);
-      pipe_texture_reference(&st_ctx->default_texture, NULL);
+      pipe_resource_reference(&st_ctx->default_texture, NULL);
 
       FREE(st_ctx);
       
@@ -231,8 +231,7 @@ st_context_create(struct st_device *st_dev)
    {
       struct pipe_context *pipe = st_ctx->pipe;
       struct pipe_screen *screen = st_dev->screen;
-      struct pipe_texture templat;
-      struct pipe_transfer *transfer;
+      struct pipe_resource templat;
       struct pipe_sampler_view view_templ;
       struct pipe_sampler_view *view;
       unsigned i;
@@ -245,24 +244,21 @@ st_context_create(struct st_device *st_dev)
       templat.depth0 = 1;
       templat.last_level = 0;
    
-      st_ctx->default_texture = screen->texture_create( screen, &templat );
+      st_ctx->default_texture = screen->resource_create( screen, &templat );
       if(st_ctx->default_texture) {
-         transfer = pipe->get_tex_transfer(pipe,
-                                       st_ctx->default_texture,
-                                       0, 0, 0,
-                                       PIPE_TRANSFER_WRITE,
-                                       0, 0,
-                                       st_ctx->default_texture->width0,
-                                       st_ctx->default_texture->height0);
-         if (transfer) {
-            uint32_t *map;
-            map = (uint32_t *) pipe->transfer_map(pipe, transfer);
-            if(map) {
-               *map = 0x00000000;
-               pipe->transfer_unmap(pipe, transfer);
-            }
-            pipe->tex_transfer_destroy(pipe, transfer);
-         }
+	 struct pipe_box box;
+	 uint32_t zero = 0;
+	 
+	 u_box_origin_2d( 1, 1, &box );
+
+	 pipe->transfer_inline_write(pipe,
+				     st_ctx->default_texture,
+				     u_subresource(0,0),
+				     PIPE_TRANSFER_WRITE,
+				     &box,
+				     &zero,
+				     sizeof zero,
+				     0);
       }
 
       u_sampler_view_default_template(&view_templ,
diff --git a/src/gallium/state_trackers/python/st_device.h b/src/gallium/state_trackers/python/st_device.h
index dcd0dc6e273..2dca7a1974e 100644
--- a/src/gallium/state_trackers/python/st_device.h
+++ b/src/gallium/state_trackers/python/st_device.h
@@ -40,7 +40,7 @@ struct st_winsys;
 
 struct st_surface
 {
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    unsigned face;
    unsigned level;
    unsigned zslice;
@@ -59,7 +59,7 @@ struct st_context
    void *fs;
    void *gs;
 
-   struct pipe_texture *default_texture;
+   struct pipe_resource *default_texture;
    struct pipe_sampler_view *fragment_sampler_views[PIPE_MAX_SAMPLERS];
    struct pipe_sampler_view *vertex_sampler_views[PIPE_MAX_VERTEX_SAMPLERS];
    
@@ -85,7 +85,7 @@ struct st_device
 static INLINE struct pipe_surface *
 st_pipe_surface(struct st_surface *surface, unsigned usage) 
 {
-   struct pipe_texture *texture = surface->texture;
+   struct pipe_resource *texture = surface->texture;
    struct pipe_screen *screen = texture->screen;
    return screen->get_tex_surface(screen, texture, surface->face, surface->level, surface->zslice, usage);
 }
diff --git a/src/gallium/state_trackers/python/st_sample.c b/src/gallium/state_trackers/python/st_sample.c
index 218a77fb0a1..25bfbf1ab73 100644
--- a/src/gallium/state_trackers/python/st_sample.c
+++ b/src/gallium/state_trackers/python/st_sample.c
@@ -546,22 +546,22 @@ st_sample_surface(struct pipe_context *pipe,
                   float *rgba,
                   boolean norm)
 {
-   struct pipe_texture *texture = surface->texture;
+   struct pipe_resource *texture = surface->texture;
    unsigned width = u_minify(texture->width0, surface->level);
    unsigned height = u_minify(texture->height0, surface->level);
    uint rgba_stride = width * 4;
    struct pipe_transfer *transfer;
    void *raw;
 
-   transfer = pipe->get_tex_transfer(pipe,
-                                     surface->texture,
-                                     surface->face,
-                                     surface->level,
-                                     surface->zslice,
-                                     PIPE_TRANSFER_WRITE,
-                                     0, 0,
-                                     width,
-                                     height);
+   transfer = pipe_get_transfer(pipe,
+                                surface->texture,
+                                surface->face,
+                                surface->level,
+                                surface->zslice,
+                                PIPE_TRANSFER_WRITE,
+                                0, 0,
+                                width,
+                                height);
    if (!transfer)
       return;
 
@@ -590,6 +590,6 @@ st_sample_surface(struct pipe_context *pipe,
 
       pipe->transfer_unmap(pipe, transfer);
    }
-   
-   pipe->tex_transfer_destroy(pipe, transfer);
+
+   pipe->transfer_destroy(pipe, transfer);
 }
diff --git a/src/gallium/state_trackers/vega/Makefile b/src/gallium/state_trackers/vega/Makefile
index 7c315de8271..b871990cd9a 100644
--- a/src/gallium/state_trackers/vega/Makefile
+++ b/src/gallium/state_trackers/vega/Makefile
@@ -27,7 +27,6 @@ VG_SOURCES = \
            vg_context.c \
            vg_manager.c \
            vg_state.c   \
-           vg_tracker.c \
            vg_translate.c \
            polygon.c    \
            bezier.c     \
@@ -43,7 +42,8 @@ VG_SOURCES = \
 
 VG_OBJECTS = $(VG_SOURCES:.c=.o)
 
-VG_LIBS = $(GALLIUM_AUXILIARIES) -lm
+VG_LIBS = $(GALLIUM_AUXILIARIES)
+VG_LIB_DEPS = $(EXTRA_LIB_PATH) -lm
 
 ### Include directories
 
@@ -65,7 +65,7 @@ $(TOP)/$(LIB_DIR)/$(VG_LIB_NAME): $(VG_OBJECTS) $(VG_LIBS)
 		-minor $(VG_MINOR) \
 		-patch $(VG_TINY) \
 		-install $(TOP)/$(LIB_DIR) \
-		$(VG_OBJECTS) $(VG_LIBS)
+		$(VG_OBJECTS) $(VG_LIBS) $(VG_LIB_DEPS)
 
 ######################################################################
 # Generic stuff
diff --git a/src/gallium/state_trackers/vega/api_filters.c b/src/gallium/state_trackers/vega/api_filters.c
index a643f38624f..b1c08af9382 100644
--- a/src/gallium/state_trackers/vega/api_filters.c
+++ b/src/gallium/state_trackers/vega/api_filters.c
@@ -57,14 +57,14 @@ struct filter_info {
    struct pipe_sampler_view *extra_texture_view;
 };
 
-static INLINE struct pipe_texture *create_texture_1d(struct vg_context *ctx,
+static INLINE struct pipe_resource *create_texture_1d(struct vg_context *ctx,
                                                      const VGuint *color_data,
                                                      const VGint color_data_len)
 {
    struct pipe_context *pipe = ctx->pipe;
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_texture *tex = 0;
-   struct pipe_texture templ;
+   struct pipe_resource *tex = 0;
+   struct pipe_resource templ;
 
    memset(&templ, 0, sizeof(templ));
    templ.target = PIPE_TEXTURE_1D;
@@ -73,20 +73,20 @@ static INLINE struct pipe_texture *create_texture_1d(struct vg_context *ctx,
    templ.width0 = color_data_len;
    templ.height0 = 1;
    templ.depth0 = 1;
-   templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
+   templ.bind = PIPE_BIND_SAMPLER_VIEW;
 
-   tex = screen->texture_create(screen, &templ);
+   tex = screen->resource_create(screen, &templ);
 
    { /* upload color_data */
       struct pipe_transfer *transfer =
-         pipe->get_tex_transfer(pipe, tex,
+         pipe_get_transfer(pipe, tex,
 				0, 0, 0,
 				PIPE_TRANSFER_READ_WRITE ,
 				0, 0, tex->width0, tex->height0);
       void *map = pipe->transfer_map(pipe, transfer);
       memcpy(map, color_data, sizeof(VGint)*color_data_len);
       pipe->transfer_unmap(pipe, transfer);
-      pipe->tex_transfer_destroy(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
    }
 
    return tex;
@@ -97,7 +97,7 @@ static INLINE struct pipe_sampler_view *create_texture_1d_view(struct vg_context
                                                                const VGint color_data_len)
 {
    struct pipe_context *pipe = ctx->pipe;
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct pipe_sampler_view view_templ;
    struct pipe_sampler_view *view;
 
@@ -109,7 +109,7 @@ static INLINE struct pipe_sampler_view *create_texture_1d_view(struct vg_context
    u_sampler_view_default_template(&view_templ, texture, texture->format);
    view = pipe->create_sampler_view(pipe, texture, &view_templ);
    /* want the texture to go away if the view is freed */
-   pipe_texture_reference(&texture, NULL);
+   pipe_resource_reference(&texture, NULL);
 
    return view;
 }
@@ -121,7 +121,7 @@ static INLINE struct pipe_surface * setup_framebuffer(struct vg_image *dst)
    struct pipe_framebuffer_state fb;
    struct pipe_surface *dst_surf = pipe->screen->get_tex_surface(
       pipe->screen, dst->sampler_view->texture, 0, 0, 0,
-      PIPE_BUFFER_USAGE_GPU_WRITE);
+      PIPE_BIND_RENDER_TARGET);
 
    /* drawing dest */
    memset(&fb, 0, sizeof(fb));
@@ -170,14 +170,14 @@ static void setup_constant_buffer(struct vg_context *ctx, const void *buffer,
                                   VGint param_bytes)
 {
    struct pipe_context *pipe = ctx->pipe;
-   struct pipe_buffer **cbuf = &ctx->filter.buffer;
+   struct pipe_resource **cbuf = &ctx->filter.buffer;
 
    /* We always need to get a new buffer, to keep the drivers simple and
     * avoid gratuitous rendering synchronization. */
-   pipe_buffer_reference(cbuf, NULL);
+   pipe_resource_reference(cbuf, NULL);
 
-   *cbuf = pipe_buffer_create(pipe->screen, 16,
-                              PIPE_BUFFER_USAGE_CONSTANT,
+   *cbuf = pipe_buffer_create(pipe->screen, 
+                              PIPE_BIND_CONSTANT_BUFFER,
                               param_bytes);
 
    if (*cbuf) {
diff --git a/src/gallium/state_trackers/vega/api_images.c b/src/gallium/state_trackers/vega/api_images.c
index fec473d9d23..6c7fd3b346c 100644
--- a/src/gallium/state_trackers/vega/api_images.c
+++ b/src/gallium/state_trackers/vega/api_images.c
@@ -441,9 +441,9 @@ void vgReadPixels(void * data, VGint dataStride,
    {
       struct pipe_transfer *transfer;
 
-      transfer = pipe->get_tex_transfer(pipe, strb->texture,  0, 0, 0,
-                                          PIPE_TRANSFER_READ,
-                                          0, 0, width, height);
+      transfer = pipe_get_transfer(pipe, strb->texture,  0, 0, 0,
+				   PIPE_TRANSFER_READ,
+				   0, 0, width, height);
 
       /* Do a row at a time to flip image data vertically */
       for (i = 0; i < height; i++) {
@@ -457,7 +457,7 @@ void vgReadPixels(void * data, VGint dataStride,
          dst += dataStride;
       }
 
-      pipe->tex_transfer_destroy(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
    }
 }
 
diff --git a/src/gallium/state_trackers/vega/api_masks.c b/src/gallium/state_trackers/vega/api_masks.c
index 2f2d925252d..7c28ea5c872 100644
--- a/src/gallium/state_trackers/vega/api_masks.c
+++ b/src/gallium/state_trackers/vega/api_masks.c
@@ -51,7 +51,7 @@ draw_clear_quad(struct vg_context *st,
                 const VGfloat color[4])
 {
    struct pipe_context *pipe = st->pipe;
-   struct pipe_buffer *buf;
+   struct pipe_resource *buf;
    VGuint i;
 
    /* positions */
@@ -81,7 +81,8 @@ draw_clear_quad(struct vg_context *st,
    /* put vertex data into vbuf */
    buf =  pipe_user_buffer_create(pipe->screen,
                                   st->clear.vertices,
-                                  sizeof(st->clear.vertices));
+                                  sizeof(st->clear.vertices),
+				  PIPE_BIND_VERTEX_BUFFER);
 
 
    /* draw */
@@ -93,7 +94,7 @@ draw_clear_quad(struct vg_context *st,
                               4,  /* verts */
                               2); /* attribs/vert */
 
-      pipe_buffer_reference(&buf, NULL);
+      pipe_resource_reference(&buf, NULL);
    }
 }
 
diff --git a/src/gallium/state_trackers/vega/image.c b/src/gallium/state_trackers/vega/image.c
index c3268a84a60..9c323b1809c 100644
--- a/src/gallium/state_trackers/vega/image.c
+++ b/src/gallium/state_trackers/vega/image.c
@@ -81,7 +81,7 @@ static INLINE void vg_sync_size(VGfloat *src_loc, VGfloat *dst_loc)
 
 
 static void vg_copy_texture(struct vg_context *ctx,
-                            struct pipe_texture *dst, VGint dx, VGint dy,
+                            struct pipe_resource *dst, VGint dx, VGint dy,
                             struct pipe_sampler_view *src, VGint sx, VGint sy,
                             VGint width, VGint height)
 {
@@ -217,9 +217,9 @@ void vg_copy_surface(struct vg_context *ctx,
 
 }
 
-static struct pipe_texture *image_texture(struct vg_image *img)
+static struct pipe_resource *image_texture(struct vg_image *img)
 {
-   struct pipe_texture *tex = img->sampler_view->texture;
+   struct pipe_resource *tex = img->sampler_view->texture;
    return tex;
 }
 
@@ -251,7 +251,7 @@ struct vg_image * image_create(VGImageFormat format,
    struct pipe_context *pipe = ctx->pipe;
    struct vg_image *image = CALLOC_STRUCT(vg_image);
    enum pipe_format pformat = vg_format_to_pipe(format);
-   struct pipe_texture pt, *newtex;
+   struct pipe_resource pt, *newtex;
    struct pipe_sampler_view view_templ;
    struct pipe_sampler_view *view;
    struct pipe_screen *screen = ctx->pipe->screen;
@@ -270,7 +270,7 @@ struct vg_image * image_create(VGImageFormat format,
    image->sampler.normalized_coords = 1;
 
    assert(screen->is_format_supported(screen, pformat, PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_SAMPLER, 0));
+                                      PIPE_BIND_SAMPLER_VIEW, 0));
 
    memset(&pt, 0, sizeof(pt));
    pt.target = PIPE_TEXTURE_2D;
@@ -279,16 +279,16 @@ struct vg_image * image_create(VGImageFormat format,
    pt.width0 = width;
    pt.height0 = height;
    pt.depth0 = 1;
-   pt.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
+   pt.bind = PIPE_BIND_SAMPLER_VIEW;
 
-   newtex = screen->texture_create(screen, &pt);
+   newtex = screen->resource_create(screen, &pt);
 
    debug_assert(newtex);
 
    u_sampler_view_default_template(&view_templ, newtex, newtex->format);
    view = pipe->create_sampler_view(pipe, newtex, &view_templ);
    /* want the texture to go away if the view is freed */
-   pipe_texture_reference(&newtex, NULL);
+   pipe_resource_reference(&newtex, NULL);
 
    image->sampler_view = view;
 
@@ -388,7 +388,7 @@ void image_sub_data(struct vg_image *image,
    VGint i;
    struct vg_context *ctx = vg_current_context();
    struct pipe_context *pipe = ctx->pipe;
-   struct pipe_texture *texture = image_texture(image);
+   struct pipe_resource *texture = image_texture(image);
    VGint xoffset = 0, yoffset = 0;
 
    if (x < 0) {
@@ -421,7 +421,7 @@ void image_sub_data(struct vg_image *image,
    }
 
    { /* upload color_data */
-      struct pipe_transfer *transfer = pipe->get_tex_transfer(
+      struct pipe_transfer *transfer = pipe_get_transfer(
          pipe, texture, 0, 0, 0,
          PIPE_TRANSFER_WRITE, 0, 0, texture->width0, texture->height0);
       src += (dataStride * yoffset);
@@ -431,7 +431,7 @@ void image_sub_data(struct vg_image *image,
          y += yStep;
          src += dataStride;
       }
-      pipe->tex_transfer_destroy(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
    }
 }
 
@@ -452,7 +452,7 @@ void image_get_sub_data(struct vg_image * image,
 
    {
       struct pipe_transfer *transfer =
-         pipe->get_tex_transfer(pipe,
+         pipe_get_transfer(pipe,
                                   image->sampler_view->texture,  0, 0, 0,
                                   PIPE_TRANSFER_READ,
                                   0, 0,
@@ -469,7 +469,7 @@ void image_get_sub_data(struct vg_image * image,
          dst += dataStride;
       }
 
-      pipe->tex_transfer_destroy(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
    }
 }
 
@@ -576,7 +576,7 @@ void image_set_pixels(VGint dx, VGint dy,
    pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
 
    surf = screen->get_tex_surface(screen, image_texture(src),  0, 0, 0,
-                                  PIPE_BUFFER_USAGE_GPU_READ);
+                                  PIPE_BIND_BLIT_SOURCE);
 
    vg_copy_surface(ctx, strb->surface, dx, dy,
                    surf, sx+src->x, sy+src->y, width, height);
@@ -601,8 +601,8 @@ void image_get_pixels(struct vg_image *dst, VGint dx, VGint dy,
    pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
 
    surf = screen->get_tex_surface(screen, image_texture(dst),  0, 0, 0,
-                                  PIPE_BUFFER_USAGE_GPU_WRITE |
-                                  PIPE_BUFFER_USAGE_GPU_READ);
+                                  PIPE_BIND_BLIT_SOURCE);
+
    vg_copy_surface(ctx, surf, dst->x + dx, dst->y + dy,
                    strb->surface, sx, sy, width, height);
 
diff --git a/src/gallium/state_trackers/vega/image.h b/src/gallium/state_trackers/vega/image.h
index 805b35fab9f..a990c9c5873 100644
--- a/src/gallium/state_trackers/vega/image.h
+++ b/src/gallium/state_trackers/vega/image.h
@@ -30,7 +30,7 @@
 #include "vg_context.h"
 #include "pipe/p_state.h"
 
-struct pipe_texture;
+struct pipe_resource;
 struct array;
 struct vg_context;
 struct pipe_surface;
diff --git a/src/gallium/state_trackers/vega/mask.c b/src/gallium/state_trackers/vega/mask.c
index 316ea7a9c95..6d627b0e8da 100644
--- a/src/gallium/state_trackers/vega/mask.c
+++ b/src/gallium/state_trackers/vega/mask.c
@@ -143,7 +143,7 @@ static void read_alpha_mask(void * data, VGint dataStride,
       struct pipe_surface *surf;
 
       surf = screen->get_tex_surface(screen, strb->texture,  0, 0, 0,
-                                     PIPE_BUFFER_USAGE_CPU_READ);
+                                     PIPE_BIND_TRANSFER_READ);
 
       /* Do a row at a time to flip image data vertically */
       for (i = 0; i < height; i++) {
@@ -217,7 +217,7 @@ static void setup_mask_framebuffer(struct pipe_surface *surf,
 static void setup_mask_operation(VGMaskOperation operation)
 {
    struct vg_context *ctx = vg_current_context();
-   struct pipe_buffer **cbuf = &ctx->mask.cbuf;
+   struct pipe_resource **cbuf = &ctx->mask.cbuf;
    const VGint param_bytes = 4 * sizeof(VGfloat);
    const VGfloat ones[4] = {1.f, 1.f, 1.f, 1.f};
    void *shader = 0;
@@ -225,10 +225,10 @@ static void setup_mask_operation(VGMaskOperation operation)
    /* We always need to get a new buffer, to keep the drivers simple and
     * avoid gratuitous rendering synchronization.
     */
-   pipe_buffer_reference(cbuf, NULL);
+   pipe_resource_reference(cbuf, NULL);
 
-   *cbuf = pipe_buffer_create(ctx->pipe->screen, 1,
-                              PIPE_BUFFER_USAGE_CONSTANT,
+   *cbuf = pipe_buffer_create(ctx->pipe->screen, 
+                              PIPE_BIND_CONSTANT_BUFFER,
                               param_bytes);
    if (*cbuf) {
       st_no_flush_pipe_buffer_write(ctx, *cbuf,
@@ -318,16 +318,16 @@ static void setup_mask_samplers(struct pipe_sampler_view *umask)
 static void setup_mask_fill(const VGfloat color[4])
 {
    struct vg_context *ctx = vg_current_context();
-   struct pipe_buffer **cbuf = &ctx->mask.cbuf;
+   struct pipe_resource **cbuf = &ctx->mask.cbuf;
    const VGint param_bytes = 4 * sizeof(VGfloat);
 
    /* We always need to get a new buffer, to keep the drivers simple and
     * avoid gratuitous rendering synchronization.
     */
-   pipe_buffer_reference(cbuf, NULL);
+   pipe_resource_reference(cbuf, NULL);
 
-   *cbuf = pipe_buffer_create(ctx->pipe->screen, 1,
-                              PIPE_BUFFER_USAGE_CONSTANT,
+   *cbuf = pipe_buffer_create(ctx->pipe->screen,
+                              PIPE_BIND_CONSTANT_BUFFER,
                               param_bytes);
    if (*cbuf) {
       st_no_flush_pipe_buffer_write(ctx, *cbuf, 0, param_bytes, color);
@@ -415,9 +415,9 @@ static void mask_using_texture(struct pipe_sampler_view *sampler_view,
                                VGint width, VGint height)
 {
    struct vg_context *ctx = vg_current_context();
-   struct pipe_texture *texture = sampler_view->texture;
+   struct pipe_resource *texture = sampler_view->texture;
    struct pipe_surface *surface =
-      alpha_mask_surface(ctx, PIPE_BUFFER_USAGE_GPU_WRITE);
+      alpha_mask_surface(ctx, PIPE_BIND_RENDER_TARGET);
    VGint offsets[4], loc[4];
 
    if (!surface)
@@ -482,12 +482,12 @@ struct vg_mask_layer * mask_layer_create(VGint width, VGint height)
    mask->height = height;
 
    {
-      struct pipe_texture pt;
+      struct pipe_resource pt;
       struct pipe_context *pipe = ctx->pipe;
       struct pipe_screen *screen = ctx->pipe->screen;
       struct pipe_sampler_view view_templ;
       struct pipe_sampler_view *view = NULL;
-      struct pipe_texture *texture;
+      struct pipe_resource *texture;
 
       memset(&pt, 0, sizeof(pt));
       pt.target = PIPE_TEXTURE_2D;
@@ -496,16 +496,16 @@ struct vg_mask_layer * mask_layer_create(VGint width, VGint height)
       pt.width0 = width;
       pt.height0 = height;
       pt.depth0 = 1;
-      pt.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
+      pt.bind = PIPE_BIND_SAMPLER_VIEW;
       pt.compressed = 0;
 
-      texture = screen->texture_create(screen, &pt);
+      texture = screen->resource_create(screen, &pt);
 
       if (texture) {
          u_sampler_view_default_template(&view_templ, texture, texture->format);
          view = pipe->create_sampler_view(pipe, texture, &view_templ);
       }
-      pipe_texture_reference(&texture, NULL);
+      pipe_resource_reference(&texture, NULL);
       mask->sampler_view = view;
    }
 
@@ -519,7 +519,7 @@ void mask_layer_destroy(struct vg_mask_layer *layer)
    struct vg_context *ctx = vg_current_context();
 
    vg_context_remove_object(ctx, VG_OBJECT_MASK, layer);
-   pipe_texture_release(&layer->texture);
+   pipe_resource_release(&layer->texture);
    free(layer);
 }
 
@@ -537,7 +537,7 @@ void mask_layer_fill(struct vg_mask_layer *layer,
    surface = ctx->pipe->screen->get_tex_surface(
       ctx->pipe->screen, layer->sampler_view->texture,
       0, 0, 0,
-      PIPE_BUFFER_USAGE_GPU_WRITE);
+      PIPE_BIND_RENDER_TARGET);
 
    surface_fill(surface,
                 layer->width, layer->height,
@@ -573,7 +573,7 @@ static void mask_layer_render_to(struct vg_mask_layer *layer,
    struct pipe_surface *surface;
 
    surface = screen->get_tex_surface(screen, layer->sampler_view->texture,  0, 0, 0,
-                                     PIPE_BUFFER_USAGE_GPU_WRITE);
+                                     PIPE_BIND_RENDER_TARGET);
 
    cso_save_framebuffer(ctx->cso_context);
    cso_save_fragment_shader(ctx->cso_context);
@@ -664,7 +664,7 @@ void mask_fill(VGint x, VGint y, VGint width, VGint height,
    struct vg_context *ctx = vg_current_context();
    VGfloat alpha_color[4] = {.0f, .0f, .0f, value};
    struct pipe_surface *surf = alpha_mask_surface(
-      ctx, PIPE_BUFFER_USAGE_GPU_WRITE);
+      ctx, PIPE_BIND_RENDER_TARGET);
 
 #if DEBUG_MASKS
    debug_printf("mask_fill(%d, %d, %d, %d) with  rgba(%f, %f, %f, %f)\n",
diff --git a/src/gallium/state_trackers/vega/mask.h b/src/gallium/state_trackers/vega/mask.h
index 4feacbefda8..c626402c864 100644
--- a/src/gallium/state_trackers/vega/mask.h
+++ b/src/gallium/state_trackers/vega/mask.h
@@ -31,7 +31,7 @@
 
 struct path;
 struct vg_image;
-struct pipe_texture;
+struct pipe_resource;
 
 struct vg_mask_layer *mask_layer_create(VGint width, VGint height);
 void mask_layer_destroy(struct vg_mask_layer *layer);
diff --git a/src/gallium/state_trackers/vega/paint.c b/src/gallium/state_trackers/vega/paint.c
index 508e1863a57..05540e82752 100644
--- a/src/gallium/state_trackers/vega/paint.c
+++ b/src/gallium/state_trackers/vega/paint.c
@@ -79,7 +79,7 @@ struct vg_paint {
    } pattern;
 
    /* XXX next 3 all unneded? */
-   struct pipe_buffer *cbuf;
+   struct pipe_resource *cbuf;
    struct pipe_shader_state fs_state;
    void *fs;
 };
@@ -143,12 +143,12 @@ static INLINE void create_gradient_data(const VGfloat *ramp_stops,
    data[size-1] = last_color;
 }
 
-static INLINE struct pipe_texture *create_gradient_texture(struct vg_paint *p)
+static INLINE struct pipe_resource *create_gradient_texture(struct vg_paint *p)
 {
    struct pipe_context *pipe = p->base.ctx->pipe;
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_texture *tex = 0;
-   struct pipe_texture templ;
+   struct pipe_resource *tex = 0;
+   struct pipe_resource templ;
 
    memset(&templ, 0, sizeof(templ));
    templ.target = PIPE_TEXTURE_1D;
@@ -157,18 +157,18 @@ static INLINE struct pipe_texture *create_gradient_texture(struct vg_paint *p)
    templ.width0 = 1024;
    templ.height0 = 1;
    templ.depth0 = 1;
-   templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
+   templ.bind = PIPE_BIND_SAMPLER_VIEW;
 
-   tex = screen->texture_create(screen, &templ);
+   tex = screen->resource_create(screen, &templ);
 
    { /* upload color_data */
       struct pipe_transfer *transfer =
-         st_no_flush_get_tex_transfer(p->base.ctx, tex, 0, 0, 0,
+         st_no_flush_get_transfer(p->base.ctx, tex, 0, 0, 0,
                                       PIPE_TRANSFER_WRITE, 0, 0, 1024, 1);
       void *map = pipe->transfer_map(pipe, transfer);
       memcpy(map, p->gradient.color_data, sizeof(VGint)*1024);
       pipe->transfer_unmap(pipe, transfer);
-      pipe->tex_transfer_destroy(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
    }
 
    return tex;
@@ -177,7 +177,7 @@ static INLINE struct pipe_texture *create_gradient_texture(struct vg_paint *p)
 static INLINE struct pipe_sampler_view *create_gradient_sampler_view(struct vg_paint *p)
 {
    struct pipe_context *pipe = p->base.ctx->pipe;
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct pipe_sampler_view view_templ;
    struct pipe_sampler_view *view;
 
@@ -189,7 +189,7 @@ static INLINE struct pipe_sampler_view *create_gradient_sampler_view(struct vg_p
    u_sampler_view_default_template(&view_templ, texture, texture->format);
    view = pipe->create_sampler_view(pipe, texture, &view_templ);
    /* want the texture to go away if the view is freed */
-   pipe_texture_reference(&texture, NULL);
+   pipe_resource_reference(&texture, NULL);
 
    return view;
 }
diff --git a/src/gallium/state_trackers/vega/paint.h b/src/gallium/state_trackers/vega/paint.h
index 9ea67c4b1e6..012cd3e5618 100644
--- a/src/gallium/state_trackers/vega/paint.h
+++ b/src/gallium/state_trackers/vega/paint.h
@@ -35,7 +35,7 @@
 struct vg_paint;
 struct vg_image;
 struct pipe_sampler_state;
-struct pipe_texture;
+struct pipe_resource;
 
 struct vg_paint *paint_create(struct vg_context *ctx);
 void paint_destroy(struct vg_paint *paint);
diff --git a/src/gallium/state_trackers/vega/polygon.c b/src/gallium/state_trackers/vega/polygon.c
index eef2c1eb876..d2b7e489124 100644
--- a/src/gallium/state_trackers/vega/polygon.c
+++ b/src/gallium/state_trackers/vega/polygon.c
@@ -58,7 +58,7 @@ struct polygon
    VGint    num_verts;
 
    VGboolean dirty;
-   struct pipe_buffer *vbuf;
+   struct pipe_resource *vbuf;
    struct pipe_screen *screen;
 };
 
@@ -110,7 +110,7 @@ struct polygon * polygon_create_from_data(float *data, int size)
 void polygon_destroy(struct polygon *poly)
 {
    if (poly->vbuf)
-      pipe_buffer_reference(&poly->vbuf, NULL);
+      pipe_resource_reference(&poly->vbuf, NULL);
 
    free(poly->data);
    free(poly);
@@ -272,13 +272,14 @@ static void draw_polygon(struct vg_context *ctx,
 
    if (poly->vbuf == NULL || poly->dirty) {
       if (poly->vbuf) {
-         pipe_buffer_reference(&poly->vbuf,
+         pipe_resource_reference(&poly->vbuf,
                                NULL);
       }
       poly->screen = pipe->screen;
       poly->vbuf= pipe_user_buffer_create(poly->screen,
                                           poly->data,
-                                          vert_size);
+                                          vert_size,
+					  PIPE_BIND_VERTEX_BUFFER);
       poly->dirty = VG_FALSE;
    }
 
diff --git a/src/gallium/state_trackers/vega/renderer.c b/src/gallium/state_trackers/vega/renderer.c
index 2bb4c8bc756..48fbc3b330e 100644
--- a/src/gallium/state_trackers/vega/renderer.c
+++ b/src/gallium/state_trackers/vega/renderer.c
@@ -61,7 +61,7 @@ static void setup_shaders(struct renderer *ctx)
    ctx->fs = util_make_fragment_tex_shader(pipe, TGSI_TEXTURE_2D);
 }
 
-static struct pipe_buffer *
+static struct pipe_resource *
 setup_vertex_data(struct renderer *ctx,
                   float x0, float y0, float x1, float y1, float z)
 {
@@ -91,10 +91,11 @@ setup_vertex_data(struct renderer *ctx,
 
    return pipe_user_buffer_create( ctx->pipe->screen,
                                    ctx->vertices,
-                                   sizeof(ctx->vertices) );
+                                   sizeof(ctx->vertices),
+				   PIPE_BIND_VERTEX_BUFFER);
 }
 
-static struct pipe_buffer *
+static struct pipe_resource *
 setup_vertex_data_tex(struct renderer *ctx,
                       float x0, float y0, float x1, float y1,
                       float s0, float t0, float s1, float t1,
@@ -126,11 +127,12 @@ setup_vertex_data_tex(struct renderer *ctx,
 
    return pipe_user_buffer_create( ctx->pipe->screen,
                                    ctx->vertices,
-                                   sizeof(ctx->vertices) );
+                                   sizeof(ctx->vertices),
+				   PIPE_BIND_VERTEX_BUFFER);
 }
 
 
-static struct pipe_buffer *
+static struct pipe_resource *
 setup_vertex_data_qtex(struct renderer *ctx,
                        float x0, float y0, float x1, float y1,
                        float x2, float y2, float x3, float y3,
@@ -163,7 +165,8 @@ setup_vertex_data_qtex(struct renderer *ctx,
 
    return pipe_user_buffer_create( ctx->pipe->screen,
                                    ctx->vertices,
-                                   sizeof(ctx->vertices) );
+                                   sizeof(ctx->vertices),
+				   PIPE_BIND_VERTEX_BUFFER);
 }
 
 struct renderer * renderer_create(struct vg_context *owner)
@@ -206,7 +209,7 @@ void renderer_draw_quad(struct renderer *r,
                         VGfloat x2, VGfloat y2,
                         VGfloat depth)
 {
-   struct pipe_buffer *buf;
+   struct pipe_resource *buf;
 
    buf = setup_vertex_data(r, x1, y1, x2, y2, depth);
 
@@ -217,20 +220,20 @@ void renderer_draw_quad(struct renderer *r,
                               4,  /* verts */
                               2); /* attribs/vert */
 
-      pipe_buffer_reference( &buf,
+      pipe_resource_reference( &buf,
                              NULL );
    }
 }
 
 void renderer_draw_texture(struct renderer *r,
-                           struct pipe_texture *tex,
+                           struct pipe_resource *tex,
                            VGfloat x1offset, VGfloat y1offset,
                            VGfloat x2offset, VGfloat y2offset,
                            VGfloat x1, VGfloat y1,
                            VGfloat x2, VGfloat y2)
 {
    struct pipe_context *pipe = r->pipe;
-   struct pipe_buffer *buf;
+   struct pipe_resource *buf;
    VGfloat s0, t0, s1, t1;
 
    assert(tex->width0 != 0);
@@ -256,7 +259,7 @@ void renderer_draw_texture(struct renderer *r,
                            4,  /* verts */
                            2); /* attribs/vert */
 
-      pipe_buffer_reference( &buf,
+      pipe_resource_reference( &buf,
                              NULL );
    }
 
@@ -267,17 +270,17 @@ void renderer_copy_texture(struct renderer *ctx,
                            struct pipe_sampler_view *src,
                            VGfloat sx1, VGfloat sy1,
                            VGfloat sx2, VGfloat sy2,
-                           struct pipe_texture *dst,
+                           struct pipe_resource *dst,
                            VGfloat dx1, VGfloat dy1,
                            VGfloat dx2, VGfloat dy2)
 {
    struct pipe_context *pipe = ctx->pipe;
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_texture *tex = src->texture;
-   struct pipe_buffer *buf;
+   struct pipe_resource *tex = src->texture;
+   struct pipe_resource *buf;
    struct pipe_surface *dst_surf = screen->get_tex_surface(
       screen, dst, 0, 0, 0,
-      PIPE_BUFFER_USAGE_GPU_WRITE);
+      PIPE_BIND_RENDER_TARGET);
    struct pipe_framebuffer_state fb;
    float s0, t0, s1, t1;
 
@@ -304,7 +307,7 @@ void renderer_copy_texture(struct renderer *ctx,
 #endif
 
    assert(screen->is_format_supported(screen, dst_surf->format, PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_RENDER_TARGET, 0));
+                                      PIPE_BIND_RENDER_TARGET, 0));
 
    /* save state (restored below) */
    cso_save_blend(ctx->cso);
@@ -380,7 +383,7 @@ void renderer_copy_texture(struct renderer *ctx,
                               4,  /* verts */
                               2); /* attribs/vert */
 
-      pipe_buffer_reference( &buf,
+      pipe_resource_reference( &buf,
                              NULL );
    }
 
@@ -407,10 +410,10 @@ void renderer_copy_surface(struct renderer *ctx,
 {
    struct pipe_context *pipe = ctx->pipe;
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_buffer *buf;
+   struct pipe_resource *buf;
    struct pipe_sampler_view view_templ;
    struct pipe_sampler_view *view;
-   struct pipe_texture texTemp, *tex;
+   struct pipe_resource texTemp, *tex;
    struct pipe_surface *texSurf;
    struct pipe_framebuffer_state fb;
    struct st_framebuffer *stfb = ctx->owner->draw_buffer;
@@ -437,11 +440,11 @@ void renderer_copy_surface(struct renderer *ctx,
    }
 
    assert(screen->is_format_supported(screen, src->format, PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_SAMPLER, 0));
+                                      PIPE_BIND_SAMPLER_VIEW, 0));
    assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_SAMPLER, 0));
+                                      PIPE_BIND_SAMPLER_VIEW, 0));
    assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_RENDER_TARGET, 0));
+                                      PIPE_BIND_RENDER_TARGET, 0));
 
    /*
     * XXX for now we're always creating a temporary texture.
@@ -457,7 +460,7 @@ void renderer_copy_surface(struct renderer *ctx,
    texTemp.height0 = srcH;
    texTemp.depth0 = 1;
 
-   tex = screen->texture_create(screen, &texTemp);
+   tex = screen->resource_create(screen, &texTemp);
    if (!tex)
       return;
 
@@ -468,7 +471,7 @@ void renderer_copy_surface(struct renderer *ctx,
       return;
 
    texSurf = screen->get_tex_surface(screen, tex, 0, 0, 0,
-                                     PIPE_BUFFER_USAGE_GPU_WRITE);
+                                     PIPE_BIND_RENDER_TARGET);
 
    /* load temp texture */
    if (pipe->surface_copy) {
@@ -554,7 +557,7 @@ void renderer_copy_surface(struct renderer *ctx,
                               4,  /* verts */
                               2); /* attribs/vert */
 
-      pipe_buffer_reference( &buf,
+      pipe_resource_reference( &buf,
                              NULL );
    }
 
@@ -568,12 +571,12 @@ void renderer_copy_surface(struct renderer *ctx,
    cso_restore_vertex_shader(ctx->cso);
    cso_restore_viewport(ctx->cso);
 
-   pipe_texture_reference(&tex, NULL);
+   pipe_resource_reference(&tex, NULL);
    pipe_sampler_view_reference(&view, NULL);
 }
 
 void renderer_texture_quad(struct renderer *r,
-                           struct pipe_texture *tex,
+                           struct pipe_resource *tex,
                            VGfloat x1offset, VGfloat y1offset,
                            VGfloat x2offset, VGfloat y2offset,
                            VGfloat x1, VGfloat y1,
@@ -582,7 +585,7 @@ void renderer_texture_quad(struct renderer *r,
                            VGfloat x4, VGfloat y4)
 {
    struct pipe_context *pipe = r->pipe;
-   struct pipe_buffer *buf;
+   struct pipe_resource *buf;
    VGfloat s0, t0, s1, t1;
 
    assert(tex->width0 != 0);
@@ -608,7 +611,7 @@ void renderer_texture_quad(struct renderer *r,
                               4,  /* verts */
                               2); /* attribs/vert */
 
-      pipe_buffer_reference(&buf,
+      pipe_resource_reference(&buf,
                             NULL);
    }
 
diff --git a/src/gallium/state_trackers/vega/renderer.h b/src/gallium/state_trackers/vega/renderer.h
index 03366f13614..b1a9fb58be6 100644
--- a/src/gallium/state_trackers/vega/renderer.h
+++ b/src/gallium/state_trackers/vega/renderer.h
@@ -32,7 +32,7 @@
 struct renderer;
 
 struct vg_context;
-struct pipe_texture;
+struct pipe_resource;
 struct pipe_sampler_view;
 struct pipe_surface;
 
@@ -44,13 +44,13 @@ void renderer_draw_quad(struct renderer *,
                         VGfloat x2, VGfloat y2,
                         VGfloat depth);
 void renderer_draw_texture(struct renderer *,
-                           struct pipe_texture *texture,
+                           struct pipe_resource *texture,
                            VGfloat x1offset, VGfloat y1offset,
                            VGfloat x2offset, VGfloat y2offset,
                            VGfloat x1, VGfloat y1,
                            VGfloat x2, VGfloat y2);
 void renderer_texture_quad(struct renderer *,
-                           struct pipe_texture *texture,
+                           struct pipe_resource *texture,
                            VGfloat x1offset, VGfloat y1offset,
                            VGfloat x2offset, VGfloat y2offset,
                            VGfloat x1, VGfloat y1,
@@ -61,7 +61,7 @@ void renderer_copy_texture(struct renderer *r,
                            struct pipe_sampler_view *src,
                            VGfloat sx1, VGfloat sy1,
                            VGfloat sx2, VGfloat sy2,
-                           struct pipe_texture *dst,
+                           struct pipe_resource *dst,
                            VGfloat dx1, VGfloat dy1,
                            VGfloat dx2, VGfloat dy2);
 void renderer_copy_surface(struct renderer *r,
diff --git a/src/gallium/state_trackers/vega/shader.c b/src/gallium/state_trackers/vega/shader.c
index f2ec24c57ff..6eef94ce767 100644
--- a/src/gallium/state_trackers/vega/shader.c
+++ b/src/gallium/state_trackers/vega/shader.c
@@ -51,7 +51,7 @@ struct shader {
    VGImageMode image_mode;
 
    float constants[MAX_CONSTANTS];
-   struct pipe_buffer *cbuf;
+   struct pipe_resource *cbuf;
    struct pipe_shader_state fs_state;
    void *fs;
 };
@@ -96,7 +96,7 @@ static void setup_constant_buffer(struct shader *shader)
 {
    struct vg_context *ctx = shader->context;
    struct pipe_context *pipe = shader->context->pipe;
-   struct pipe_buffer **cbuf = &shader->cbuf;
+   struct pipe_resource **cbuf = &shader->cbuf;
    VGint param_bytes = paint_constant_buffer_size(shader->paint);
    float temp_buf[MAX_CONSTANTS];
 
@@ -106,12 +106,13 @@ static void setup_constant_buffer(struct shader *shader)
    if (*cbuf == NULL ||
        memcmp(temp_buf, shader->constants, param_bytes) != 0)
    {
-      pipe_buffer_reference(cbuf, NULL);
+      pipe_resource_reference(cbuf, NULL);
 
       memcpy(shader->constants, temp_buf, param_bytes);
       *cbuf = pipe_user_buffer_create(pipe->screen,
                                       &shader->constants,
-                                      sizeof(shader->constants));
+                                      sizeof(shader->constants),
+				      PIPE_BIND_VERTEX_BUFFER);
    }
 
    ctx->pipe->set_constant_buffer(ctx->pipe, PIPE_SHADER_FRAGMENT, 0, *cbuf);
diff --git a/src/gallium/state_trackers/vega/st_inlines.h b/src/gallium/state_trackers/vega/st_inlines.h
index 4d12a4efdd6..7eaa67c76ae 100644
--- a/src/gallium/state_trackers/vega/st_inlines.h
+++ b/src/gallium/state_trackers/vega/st_inlines.h
@@ -42,8 +42,8 @@
 #include "pipe/p_state.h"
 
 static INLINE struct pipe_transfer *
-st_cond_flush_get_tex_transfer(struct vg_context *st,
-			       struct pipe_texture *pt,
+st_cond_flush_get_transfer(struct vg_context *st,
+			       struct pipe_resource *pt,
 			       unsigned int face,
 			       unsigned int level,
 			       unsigned int zslice,
@@ -52,20 +52,14 @@ st_cond_flush_get_tex_transfer(struct vg_context *st,
 			       unsigned int w, unsigned int h)
 {
    struct pipe_context *pipe = st->pipe;
-   unsigned referenced =
-      pipe->is_texture_referenced(pipe, pt, face, level);
 
-   if (referenced && ((referenced & PIPE_REFERENCED_FOR_WRITE) ||
-		      (usage & PIPE_TRANSFER_WRITE)))
-      vgFlush();
-
-   return pipe->get_tex_transfer(pipe, pt, face, level, zslice, usage,
-				   x, y, w, h);
+   return pipe_get_transfer(pipe, pt, face, level, zslice, usage,
+			    x, y, w, h);
 }
 
 static INLINE struct pipe_transfer *
-st_no_flush_get_tex_transfer(struct vg_context *st,
-			     struct pipe_texture *pt,
+st_no_flush_get_transfer(struct vg_context *st,
+			     struct pipe_resource *pt,
 			     unsigned int face,
 			     unsigned int level,
 			     unsigned int zslice,
@@ -75,82 +69,53 @@ st_no_flush_get_tex_transfer(struct vg_context *st,
 {
    struct pipe_context *pipe = st->pipe;
 
-   return pipe->get_tex_transfer(pipe, pt, face, level,
-				 zslice, usage, x, y, w, h);
-}
-
-static INLINE void *
-st_cond_flush_pipe_buffer_map(struct vg_context *st,
-			      struct pipe_buffer *buf,
-			      unsigned int map_flags)
-{
-   struct pipe_context *pipe = st->pipe;
-   unsigned int referenced = pipe->is_buffer_referenced(pipe, buf);
-
-   if (referenced && ((referenced & PIPE_REFERENCED_FOR_WRITE) ||
-		      (map_flags & PIPE_BUFFER_USAGE_CPU_WRITE)))
-      vgFlush();
-
-   return pipe_buffer_map(pipe->screen, buf, map_flags);
-}
-
-static INLINE void *
-st_no_flush_pipe_buffer_map(struct vg_context *st,
-			    struct pipe_buffer *buf,
-			    unsigned int map_flags)
-{
-   return pipe_buffer_map(st->pipe->screen, buf, map_flags);
+   return pipe_get_transfer(pipe, pt, face, level,
+			    zslice, usage, x, y, w, h);
 }
 
 
 static INLINE void
 st_cond_flush_pipe_buffer_write(struct vg_context *st,
-				struct pipe_buffer *buf,
+				struct pipe_resource *buf,
 				unsigned int offset,
 				unsigned int size,
 				const void * data)
 {
    struct pipe_context *pipe = st->pipe;
 
-   if (pipe->is_buffer_referenced(pipe, buf))
-      vgFlush();
-
-   pipe_buffer_write(pipe->screen, buf, offset, size, data);
+   pipe_buffer_write(pipe, buf, offset, size, data);
 }
 
 static INLINE void
 st_no_flush_pipe_buffer_write(struct vg_context *st,
-			      struct pipe_buffer *buf,
+			      struct pipe_resource *buf,
 			      unsigned int offset,
 			      unsigned int size,
 			      const void * data)
 {
-   pipe_buffer_write(st->pipe->screen, buf, offset, size, data);
+   pipe_buffer_write(st->pipe, buf, offset, size, data);
 }
 
 static INLINE void
 st_cond_flush_pipe_buffer_read(struct vg_context *st,
-			       struct pipe_buffer *buf,
+			       struct pipe_resource *buf,
 			       unsigned int offset,
 			       unsigned int size,
 			       void * data)
 {
    struct pipe_context *pipe = st->pipe;
 
-   if (pipe->is_buffer_referenced(pipe, buf) & PIPE_REFERENCED_FOR_WRITE)
-      vgFlush();
-
-   pipe_buffer_read(pipe->screen, buf, offset, size, data);
+   pipe_buffer_read(pipe, buf, offset, size, data);
 }
 
 static INLINE void
 st_no_flush_pipe_buffer_read(struct vg_context *st,
-			     struct pipe_buffer *buf,
+			     struct pipe_resource *buf,
 			     unsigned int offset,
 			     unsigned int size,
 			     void * data)
 {
-   pipe_buffer_read(st->pipe->screen, buf, offset, size, data);
+   pipe_buffer_read(st->pipe, buf, offset, size, data);
 }
 
 #endif
diff --git a/src/gallium/state_trackers/vega/vg_context.c b/src/gallium/state_trackers/vega/vg_context.c
index 11ebbbe5444..1a8952ce34a 100644
--- a/src/gallium/state_trackers/vega/vg_context.c
+++ b/src/gallium/state_trackers/vega/vg_context.c
@@ -132,8 +132,8 @@ struct vg_context * vg_create_context(struct pipe_context *pipe,
 
 void vg_destroy_context(struct vg_context *ctx)
 {
-   struct pipe_buffer **cbuf = &ctx->mask.cbuf;
-   struct pipe_buffer **vsbuf = &ctx->vs_const_buffer;
+   struct pipe_resource **cbuf = &ctx->mask.cbuf;
+   struct pipe_resource **vsbuf = &ctx->vs_const_buffer;
 
    util_destroy_blit(ctx->blit);
    renderer_destroy(ctx->renderer);
@@ -142,10 +142,10 @@ void vg_destroy_context(struct vg_context *ctx)
    paint_destroy(ctx->default_paint);
 
    if (*cbuf)
-      pipe_buffer_reference(cbuf, NULL);
+      pipe_resource_reference(cbuf, NULL);
 
    if (*vsbuf)
-      pipe_buffer_reference(vsbuf, NULL);
+      pipe_resource_reference(vsbuf, NULL);
 
    if (ctx->clear.fs) {
       cso_delete_fragment_shader(ctx->cso_context, ctx->clear.fs);
@@ -381,14 +381,14 @@ void vg_validate_state(struct vg_context *ctx)
          2.f/fb->width, 2.f/fb->height, 1, 1,
          -1, -1, 0, 0
       };
-      struct pipe_buffer **cbuf = &ctx->vs_const_buffer;
+      struct pipe_resource **cbuf = &ctx->vs_const_buffer;
 
       vg_set_viewport(ctx, VEGA_Y0_BOTTOM);
 
-      pipe_buffer_reference(cbuf, NULL);
-      *cbuf = pipe_buffer_create(ctx->pipe->screen, 16,
-                                        PIPE_BUFFER_USAGE_CONSTANT,
-                                        param_bytes);
+      pipe_resource_reference(cbuf, NULL);
+      *cbuf = pipe_buffer_create(ctx->pipe->screen, 
+				 PIPE_BIND_CONSTANT_BUFFER,
+				 param_bytes);
 
       if (*cbuf) {
          st_no_flush_pipe_buffer_write(ctx, *cbuf,
@@ -451,7 +451,8 @@ void vg_prepare_blend_surface(struct vg_context *ctx)
    dest_surface = pipe->screen->get_tex_surface(pipe->screen,
                                                 stfb->blend_texture_view->texture,
                                                 0, 0, 0,
-                                                PIPE_BUFFER_USAGE_GPU_WRITE);
+                                                PIPE_BIND_BLIT_DESTINATION |
+						PIPE_BIND_RENDER_TARGET);
    /* flip it, because we want to use it as a sampler */
    util_blit_pixels_tex(ctx->blit,
                         view,
@@ -487,7 +488,8 @@ void vg_prepare_blend_surface_from_mask(struct vg_context *ctx)
    dest_surface = pipe->screen->get_tex_surface(pipe->screen,
                                                 stfb->blend_texture_view->texture,
                                                 0, 0, 0,
-                                                PIPE_BUFFER_USAGE_GPU_WRITE);
+                                                PIPE_BIND_BLIT_DESTINATION |
+						PIPE_BIND_RENDER_TARGET);
 
    /* flip it, because we want to use it as a sampler */
    util_blit_pixels_tex(ctx->blit,
diff --git a/src/gallium/state_trackers/vega/vg_context.h b/src/gallium/state_trackers/vega/vg_context.h
index c9e36d7d767..dac67192a54 100644
--- a/src/gallium/state_trackers/vega/vg_context.h
+++ b/src/gallium/state_trackers/vega/vg_context.h
@@ -46,7 +46,7 @@ struct vg_shader;
 struct st_renderbuffer {
    enum pipe_format   format;
    struct pipe_surface *surface;
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    VGint width, height;
 };
 
@@ -121,7 +121,7 @@ struct vg_context
    } clear;
 
    struct {
-      struct pipe_buffer *cbuf;
+      struct pipe_resource *cbuf;
       struct pipe_sampler_state sampler;
 
       struct vg_shader *union_fs;
@@ -134,7 +134,7 @@ struct vg_context
 
    struct cso_context *cso_context;
 
-   struct pipe_buffer *stencil_quad;
+   struct pipe_resource *stencil_quad;
    VGfloat stencil_vertices[4][2][4];
 
    struct renderer *renderer;
@@ -143,7 +143,7 @@ struct vg_context
 
    struct pipe_sampler_state blend_sampler;
    struct {
-      struct pipe_buffer *buffer;
+      struct pipe_resource *buffer;
       void *color_matrix_fs;
    } filter;
    struct vg_paint *default_paint;
@@ -153,7 +153,7 @@ struct vg_context
    struct vg_shader *plain_vs;
    struct vg_shader *clear_vs;
    struct vg_shader *texture_vs;
-   struct pipe_buffer *vs_const_buffer;
+   struct pipe_resource *vs_const_buffer;
    struct pipe_vertex_element velems[2];
 };
 
diff --git a/src/gallium/state_trackers/vega/vg_manager.c b/src/gallium/state_trackers/vega/vg_manager.c
index 25c2e853f2a..e4226754d13 100644
--- a/src/gallium/state_trackers/vega/vg_manager.c
+++ b/src/gallium/state_trackers/vega/vg_manager.c
@@ -2,6 +2,7 @@
  * Mesa 3-D graphics library
  * Version:  7.9
  *
+ * Copyright 2009 VMware, Inc.  All Rights Reserved.
  * Copyright (C) 2010 LunarG Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -14,12 +15,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
@@ -31,11 +33,243 @@
 #include "pipe/p_screen.h"
 #include "util/u_memory.h"
 #include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "util/u_sampler.h"
 
 #include "vg_manager.h"
 #include "vg_context.h"
-#include "vg_tracker.h" /* for st_resize_framebuffer */
 #include "image.h"
+#include "mask.h"
+
+static struct pipe_resource *
+create_texture(struct pipe_context *pipe, enum pipe_format format,
+                    VGint width, VGint height)
+{
+   struct pipe_resource templ;
+
+   memset(&templ, 0, sizeof(templ));
+
+   if (format != PIPE_FORMAT_NONE) {
+      templ.format = format;
+   }
+   else {
+      templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
+   }
+
+   templ.target = PIPE_TEXTURE_2D;
+   templ.width0 = width;
+   templ.height0 = height;
+   templ.depth0 = 1;
+   templ.last_level = 0;
+
+   if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1)) {
+      templ.bind = PIPE_BIND_DEPTH_STENCIL;
+   } else {
+      templ.bind = (PIPE_BIND_DISPLAY_TARGET |
+                    PIPE_BIND_RENDER_TARGET |
+                    PIPE_BIND_SAMPLER_VIEW);
+   }
+
+   return pipe->screen->resource_create(pipe->screen, &templ);
+}
+
+static struct pipe_sampler_view *
+create_tex_and_view(struct pipe_context *pipe, enum pipe_format format,
+                    VGint width, VGint height)
+{
+   struct pipe_resource *texture;
+   struct pipe_sampler_view view_templ;
+   struct pipe_sampler_view *view;
+
+   texture = create_texture(pipe, format, width, height);
+
+   if (!texture)
+      return NULL;
+
+   u_sampler_view_default_template(&view_templ, texture, texture->format);
+   view = pipe->create_sampler_view(pipe, texture, &view_templ);
+   /* want the texture to go away if the view is freed */
+   pipe_resource_reference(&texture, NULL);
+
+   return view;
+}
+
+static void
+setup_new_alpha_mask(struct vg_context *ctx, struct st_framebuffer *stfb)
+{
+   struct pipe_context *pipe = ctx->pipe;
+   struct pipe_sampler_view *old_sampler_view = stfb->alpha_mask_view;
+
+   /*
+     we use PIPE_FORMAT_B8G8R8A8_UNORM because we want to render to
+     this texture and use it as a sampler, so while this wastes some
+     space it makes both of those a lot simpler
+   */
+   stfb->alpha_mask_view = create_tex_and_view(pipe,
+         PIPE_FORMAT_B8G8R8A8_UNORM, stfb->width, stfb->height);
+
+   if (!stfb->alpha_mask_view) {
+      if (old_sampler_view)
+         pipe_sampler_view_reference(&old_sampler_view, NULL);
+      return;
+   }
+
+   /* XXX could this call be avoided? */
+   vg_validate_state(ctx);
+
+   /* alpha mask starts with 1.f alpha */
+   mask_fill(0, 0, stfb->width, stfb->height, 1.f);
+
+   /* if we had an old surface copy it over */
+   if (old_sampler_view) {
+      struct pipe_surface *surface = pipe->screen->get_tex_surface(
+         pipe->screen,
+         stfb->alpha_mask_view->texture,
+         0, 0, 0,
+         PIPE_BIND_RENDER_TARGET |
+         PIPE_BIND_BLIT_DESTINATION);
+      struct pipe_surface *old_surface = pipe->screen->get_tex_surface(
+         pipe->screen,
+         old_sampler_view->texture,
+         0, 0, 0,
+         PIPE_BIND_BLIT_SOURCE);
+      pipe->surface_copy(pipe,
+                         surface,
+                         0, 0,
+                         old_surface,
+                         0, 0,
+                         MIN2(old_surface->width, surface->width),
+                         MIN2(old_surface->height, surface->height));
+      if (surface)
+         pipe_surface_reference(&surface, NULL);
+      if (old_surface)
+         pipe_surface_reference(&old_surface, NULL);
+   }
+
+   /* Free the old texture
+    */
+   if (old_sampler_view)
+      pipe_sampler_view_reference(&old_sampler_view, NULL);
+}
+
+static boolean
+vg_context_update_depth_stencil_rb(struct vg_context * ctx,
+                                   uint width, uint height)
+{
+   struct st_renderbuffer *dsrb = ctx->draw_buffer->dsrb;
+   struct pipe_context *pipe = ctx->pipe;
+   unsigned surface_usage;
+
+   if ((dsrb->width == width && dsrb->height == height) && dsrb->texture)
+      return FALSE;
+
+   /* unreference existing ones */
+   pipe_surface_reference(&dsrb->surface, NULL);
+   pipe_resource_reference(&dsrb->texture, NULL);
+   dsrb->width = dsrb->height = 0;
+
+   /* Probably need dedicated flags for surface usage too:
+    */
+   surface_usage = (PIPE_BIND_RENDER_TARGET |
+                    PIPE_BIND_BLIT_SOURCE |
+                    PIPE_BIND_BLIT_DESTINATION);
+
+   dsrb->texture = create_texture(pipe, dsrb->format, width, height);
+   if (!dsrb->texture)
+      return TRUE;
+
+   dsrb->surface = pipe->screen->get_tex_surface(pipe->screen,
+                                                 dsrb->texture,
+                                                 0, 0, 0,
+                                                 surface_usage);
+   if (!dsrb->surface) {
+      pipe_resource_reference(&dsrb->texture, NULL);
+      return TRUE;
+   }
+
+   dsrb->width = width;
+   dsrb->height = height;
+
+   assert(dsrb->surface->width == width);
+   assert(dsrb->surface->height == height);
+
+   return TRUE;
+}
+
+static boolean
+vg_context_update_color_rb(struct vg_context *ctx, struct pipe_resource *pt)
+{
+   struct st_renderbuffer *strb = ctx->draw_buffer->strb;
+   struct pipe_screen *screen = ctx->pipe->screen;
+
+   if (strb->texture == pt) {
+      pipe_resource_reference(&pt, NULL);
+      return FALSE;
+   }
+
+   /* unreference existing ones */
+   pipe_surface_reference(&strb->surface, NULL);
+   pipe_resource_reference(&strb->texture, NULL);
+   strb->width = strb->height = 0;
+
+   strb->texture = pt;
+   strb->surface = screen->get_tex_surface(screen, strb->texture, 0, 0, 0,
+         PIPE_BIND_RENDER_TARGET |
+         PIPE_BIND_BLIT_SOURCE |
+         PIPE_BIND_BLIT_DESTINATION);
+   if (!strb->surface) {
+      pipe_resource_reference(&strb->texture, NULL);
+      return TRUE;
+   }
+
+   strb->width = pt->width0;
+   strb->height = pt->height0;
+
+   return TRUE;
+}
+
+static void
+vg_context_update_draw_buffer(struct vg_context *ctx, struct pipe_resource *pt)
+{
+   struct st_framebuffer *stfb = ctx->draw_buffer;
+   boolean new_cbuf, new_zsbuf, new_size;
+
+   new_cbuf = vg_context_update_color_rb(ctx, pt);
+   new_zsbuf =
+      vg_context_update_depth_stencil_rb(ctx, pt->width0, pt->height0);
+
+   new_size = (stfb->width != pt->width0 || stfb->height != pt->height0);
+   stfb->width = pt->width0;
+   stfb->height = pt->height0;
+
+   if (new_cbuf || new_zsbuf || new_size) {
+      struct pipe_framebuffer_state *state = &ctx->state.g3d.fb;
+
+      memset(state, 0, sizeof(struct pipe_framebuffer_state));
+      state->width  = stfb->width;
+      state->height = stfb->height;
+      state->nr_cbufs = 1;
+      state->cbufs[0] = stfb->strb->surface;
+      state->zsbuf = stfb->dsrb->surface;
+
+      cso_set_framebuffer(ctx->cso_context, state);
+   }
+
+   if (new_zsbuf || new_size) {
+      ctx->state.dirty |= VIEWPORT_DIRTY;
+      ctx->state.dirty |= DEPTH_STENCIL_DIRTY;/*to reset the scissors*/
+
+      ctx->pipe->clear(ctx->pipe, PIPE_CLEAR_DEPTHSTENCIL, NULL, 0.0, 0);
+
+      /* we need all the other state already set */
+
+      setup_new_alpha_mask(ctx, stfb);
+
+      pipe_sampler_view_reference( &stfb->blend_texture_view, NULL);
+      stfb->blend_texture_view = create_tex_and_view(ctx->pipe,
+            PIPE_FORMAT_B8G8R8A8_UNORM, stfb->width, stfb->height);
+   }
+}
 
 /**
  * Flush the front buffer if the current context renders to the front buffer.
@@ -48,16 +282,6 @@ vg_manager_flush_frontbuffer(struct vg_context *ctx)
    if (!stfb)
       return;
 
-   /* st_public.h is used */
-   if (!stfb->iface) {
-      struct pipe_screen *screen = ctx->pipe->screen;
-      if (screen->flush_frontbuffer) {
-         screen->flush_frontbuffer(screen,
-               stfb->strb->surface, ctx->pipe->priv);
-      }
-      return;
-   }
-
    switch (stfb->strb_att) {
    case ST_ATTACHMENT_FRONT_LEFT:
    case ST_ATTACHMENT_FRONT_RIGHT:
@@ -74,23 +298,13 @@ vg_manager_flush_frontbuffer(struct vg_context *ctx)
 void
 vg_manager_validate_framebuffer(struct vg_context *ctx)
 {
-   struct pipe_screen *screen = ctx->pipe->screen;
    struct st_framebuffer *stfb = ctx->draw_buffer;
-   struct st_renderbuffer *rb;
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
 
    /* no binding surface */
    if (!stfb)
       return;
 
-   /* st_public.h is used */
-   if (!stfb->iface) {
-      struct pipe_screen *screen = ctx->pipe->screen;
-      if (screen->update_buffer)
-         screen->update_buffer(screen, ctx->pipe->priv);
-      return;
-   }
-
    if (!p_atomic_read(&ctx->draw_buffer_invalid))
       return;
 
@@ -98,26 +312,13 @@ vg_manager_validate_framebuffer(struct vg_context *ctx)
    if (!stfb->iface->validate(stfb->iface, &stfb->strb_att, 1, &pt) || !pt)
       return;
 
-   rb = stfb->strb;
-   if (rb->texture == pt) {
-      pipe_texture_reference(&pt, NULL);
-      return;
-   }
-
-   /* unreference existing ones */
-   pipe_surface_reference(&rb->surface, NULL);
-   pipe_texture_reference(&rb->texture, NULL);
-
-   rb->texture = pt;
-   rb->surface = screen->get_tex_surface(screen, rb->texture, 0, 0, 0,
-         PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE);
-
-   rb->width = rb->surface->width;
-   rb->height = rb->surface->height;
-
-   st_resize_framebuffer(stfb, rb->width, rb->height);
-
+   /*
+    * unset draw_buffer_invalid first because vg_context_update_draw_buffer
+    * will cause the framebuffer to be validated again because of a call to
+    * vg_validate_state
+    */
    p_atomic_set(&ctx->draw_buffer_invalid, FALSE);
+   vg_context_update_draw_buffer(ctx, pt);
 }
 
 
@@ -194,7 +395,7 @@ static void
 destroy_renderbuffer(struct st_renderbuffer *strb)
 {
    pipe_surface_reference(&strb->surface, NULL);
-   pipe_texture_reference(&strb->texture, NULL);
+   pipe_resource_reference(&strb->texture, NULL);
    free(strb);
 }
 
@@ -329,10 +530,7 @@ vg_api_is_visual_supported(struct st_api *stapi,
                            const struct st_visual *visual)
 {
    /* the impl requires a depth/stencil buffer */
-   if (visual->depth_stencil_format == PIPE_FORMAT_NONE)
-      return FALSE;
-
-   return TRUE;
+   return util_format_is_depth_and_stencil(visual->depth_stencil_format);
 }
 
 static st_proc_t
diff --git a/src/gallium/state_trackers/vega/vg_manager.h b/src/gallium/state_trackers/vega/vg_manager.h
index 1a276c0f35e..1d97eb864ba 100644
--- a/src/gallium/state_trackers/vega/vg_manager.h
+++ b/src/gallium/state_trackers/vega/vg_manager.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
diff --git a/src/gallium/state_trackers/vega/vg_tracker.c b/src/gallium/state_trackers/vega/vg_tracker.c
deleted file mode 100644
index 108dd6a9751..00000000000
--- a/src/gallium/state_trackers/vega/vg_tracker.c
+++ /dev/null
@@ -1,461 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.  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 VMWARE 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.
- *
- **************************************************************************/
-
-#include "vg_context.h"
-#include "vg_tracker.h"
-#include "mask.h"
-
-#include "pipe/p_context.h"
-#include "util/u_inlines.h"
-#include "pipe/p_screen.h"
-#include "util/u_format.h"
-#include "util/u_sampler.h"
-#include "util/u_memory.h"
-#include "util/u_math.h"
-#include "util/u_rect.h"
-
-/* advertise OpenVG support */
-PUBLIC const int st_api_OpenVG = 1;
-
-static struct pipe_texture *
-create_texture(struct pipe_context *pipe, enum pipe_format format,
-                    VGint width, VGint height)
-{
-   struct pipe_texture templ;
-
-   memset(&templ, 0, sizeof(templ));
-
-   if (format != PIPE_FORMAT_NONE) {
-      templ.format = format;
-   }
-   else {
-      templ.format = PIPE_FORMAT_B8G8R8A8_UNORM;
-   }
-
-   templ.target = PIPE_TEXTURE_2D;
-   templ.width0 = width;
-   templ.height0 = height;
-   templ.depth0 = 1;
-   templ.last_level = 0;
-
-   if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1)) {
-      templ.tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
-   } else {
-      templ.tex_usage = (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                         PIPE_TEXTURE_USAGE_RENDER_TARGET |
-                         PIPE_TEXTURE_USAGE_SAMPLER);
-   }
-
-   return pipe->screen->texture_create(pipe->screen, &templ);
-}
-
-static struct pipe_sampler_view *
-create_tex_and_view(struct pipe_context *pipe, enum pipe_format format,
-                    VGint width, VGint height)
-{
-   struct pipe_texture *texture;
-   struct pipe_sampler_view view_templ;
-   struct pipe_sampler_view *view;
-
-   texture = create_texture(pipe, format, width, height);
-
-   if (!texture)
-      return NULL;
-
-   u_sampler_view_default_template(&view_templ, texture, texture->format);
-   view = pipe->create_sampler_view(pipe, texture, &view_templ);
-   /* want the texture to go away if the view is freed */
-   pipe_texture_reference(&texture, NULL);
-
-   return view;
-}
-
-/**
- * Allocate a renderbuffer for a an on-screen window (not a user-created
- * renderbuffer).  The window system code determines the format.
- */
-static struct st_renderbuffer *
-st_new_renderbuffer_fb(enum pipe_format format)
-{
-   struct st_renderbuffer *strb;
-
-   strb = CALLOC_STRUCT(st_renderbuffer);
-   if (!strb) {
-      /*_vega_error(NULL, VG_OUT_OF_MEMORY, "creating renderbuffer");*/
-      return NULL;
-   }
-
-   strb->format = format;
-
-   return strb;
-}
-
-
-/**
- * This is called to allocate the original drawing surface, and
- * during window resize.
- */
-static VGboolean
-st_renderbuffer_alloc_storage(struct vg_context * ctx,
-                              struct st_renderbuffer *strb,
-                              VGuint width, VGuint height)
-{
-   struct pipe_context *pipe = ctx->pipe;
-   unsigned surface_usage;
-
-   /* Free the old surface and texture
-    */
-   pipe_surface_reference(&strb->surface, NULL);
-   pipe_texture_reference(&strb->texture, NULL);
-
-
-   /* Probably need dedicated flags for surface usage too:
-    */
-   surface_usage = (PIPE_BUFFER_USAGE_GPU_READ  |
-                    PIPE_BUFFER_USAGE_GPU_WRITE);
-
-   strb->texture = create_texture(pipe, strb->format, width, height);
-
-
-   if (!strb->texture)
-      return FALSE;
-
-   strb->surface = pipe->screen->get_tex_surface(pipe->screen,
-                                                 strb->texture,
-                                                 0, 0, 0,
-                                                 surface_usage);
-   strb->width = width;
-   strb->height = height;
-
-   assert(strb->surface->width == width);
-   assert(strb->surface->height == height);
-
-   return strb->surface != NULL;
-}
-
-struct vg_context * st_create_context(struct pipe_context *pipe,
-                                      const void *visual,
-                                      struct vg_context *share)
-{
-   struct vg_context *ctx = vg_create_context(pipe, visual, share);
-   /*debug_printf("--------- CREATE CONTEXT %p\n", ctx);*/
-   return ctx;
-}
-
-void st_destroy_context(struct vg_context *st)
-{
-   /*debug_printf("--------- DESTROY CONTEXT %p\n", st);*/
-   vg_destroy_context(st);
-}
-
-void st_copy_context_state(struct vg_context *dst, struct vg_context *src,
-                           uint mask)
-{
-   fprintf(stderr, "FIXME: %s\n", __FUNCTION__);
-}
-
-void st_get_framebuffer_dimensions(struct st_framebuffer *stfb,
-				   uint *width,
-				   uint *height)
-{
-   *width = stfb->strb->width;
-   *height = stfb->strb->height;
-}
-
-struct st_framebuffer * st_create_framebuffer(const void *visual,
-                                              enum pipe_format colorFormat,
-                                              enum pipe_format depthFormat,
-                                              enum pipe_format stencilFormat,
-                                              uint width, uint height,
-                                              void *privateData)
-{
-   struct st_framebuffer *stfb = CALLOC_STRUCT(st_framebuffer);
-   if (stfb) {
-      struct st_renderbuffer *rb =
-         st_new_renderbuffer_fb(colorFormat);
-      stfb->strb = rb;
-#if 0
-      if (doubleBuffer) {
-         struct st_renderbuffer *rb =
-            st_new_renderbuffer_fb(colorFormat);
-      }
-#endif
-
-      /* we want to combine the depth/stencil */
-      if (stencilFormat == depthFormat)
-         stfb->dsrb = st_new_renderbuffer_fb(stencilFormat);
-      else
-         stfb->dsrb = st_new_renderbuffer_fb(PIPE_FORMAT_Z24_UNORM_S8_USCALED);
-
-      /*### currently we always allocate it but it's possible it's
-        not necessary if EGL_ALPHA_MASK_SIZE was 0
-      */
-      stfb->alpha_mask_view = NULL;
-
-      stfb->width = width;
-      stfb->height = height;
-      stfb->privateData = privateData;
-   }
-
-   return stfb;
-}
-
-static void setup_new_alpha_mask(struct vg_context *ctx,
-                                 struct st_framebuffer *stfb,
-                                 uint width, uint height)
-{
-   struct pipe_context *pipe = ctx->pipe;
-   struct pipe_sampler_view *old_sampler_view = stfb->alpha_mask_view;
-
-   /*
-     we use PIPE_FORMAT_B8G8R8A8_UNORM because we want to render to
-     this texture and use it as a sampler, so while this wastes some
-     space it makes both of those a lot simpler
-   */
-   stfb->alpha_mask_view =
-      create_tex_and_view(pipe, PIPE_FORMAT_B8G8R8A8_UNORM, width, height);
-
-   if (!stfb->alpha_mask_view) {
-      if (old_sampler_view)
-         pipe_sampler_view_reference(&old_sampler_view, NULL);
-      return;
-   }
-
-   vg_validate_state(ctx);
-
-   /* alpha mask starts with 1.f alpha */
-   mask_fill(0, 0, width, height, 1.f);
-
-   /* if we had an old surface copy it over */
-   if (old_sampler_view) {
-      struct pipe_surface *surface = pipe->screen->get_tex_surface(
-         pipe->screen,
-         stfb->alpha_mask_view->texture,
-         0, 0, 0,
-         PIPE_BUFFER_USAGE_GPU_WRITE);
-      struct pipe_surface *old_surface = pipe->screen->get_tex_surface(
-         pipe->screen,
-         old_sampler_view->texture,
-         0, 0, 0,
-         PIPE_BUFFER_USAGE_GPU_READ);
-      if (pipe->surface_copy) {
-         pipe->surface_copy(pipe,
-                            surface,
-                            0, 0,
-                            old_surface,
-                            0, 0,
-                            MIN2(old_surface->width, width),
-                            MIN2(old_surface->height, height));
-      } else {
-         util_surface_copy(pipe, FALSE,
-                           surface,
-                           0, 0,
-                           old_surface,
-                           0, 0,
-                           MIN2(old_surface->width, width),
-                           MIN2(old_surface->height, height));
-      }
-      if (surface)
-         pipe_surface_reference(&surface, NULL);
-      if (old_surface)
-         pipe_surface_reference(&old_surface, NULL);
-   }
-
-   /* Free the old texture
-    */
-   if (old_sampler_view)
-      pipe_sampler_view_reference(&old_sampler_view, NULL);
-}
-
-void st_resize_framebuffer(struct st_framebuffer *stfb,
-                           uint width, uint height)
-{
-   struct vg_context *ctx = vg_current_context();
-   struct st_renderbuffer *strb = stfb->strb;
-   struct pipe_framebuffer_state *state;
-
-   if (!ctx)
-      return;
-
-   state = &ctx->state.g3d.fb;
-
-   /* If this is a noop, exit early and don't do the clear, etc below.
-    */
-   if (stfb->width == width &&
-       stfb->height == height &&
-       state->zsbuf)
-      return;
-
-   stfb->width = width;
-   stfb->height = height;
-
-   if (strb->width != width || strb->height != height)
-      st_renderbuffer_alloc_storage(ctx, strb,
-                                 width, height);
-
-   if (stfb->dsrb->width != width || stfb->dsrb->height != height)
-      st_renderbuffer_alloc_storage(ctx, stfb->dsrb,
-                                 width, height);
-
-   {
-      VGuint i;
-
-      memset(state, 0, sizeof(struct pipe_framebuffer_state));
-
-      state->width  = width;
-      state->height = height;
-
-      state->nr_cbufs = 1;
-      state->cbufs[0] = strb->surface;
-      for (i = 1; i < PIPE_MAX_COLOR_BUFS; ++i)
-         state->cbufs[i] = 0;
-
-      state->zsbuf = stfb->dsrb->surface;
-
-      cso_set_framebuffer(ctx->cso_context, state);
-   }
-
-   ctx->state.dirty |= VIEWPORT_DIRTY;
-   ctx->state.dirty |= DEPTH_STENCIL_DIRTY;/*to reset the scissors*/
-
-   ctx->pipe->clear(ctx->pipe, PIPE_CLEAR_DEPTHSTENCIL,
-                    NULL, 0.0, 0);
-
-   /* we need all the other state already set */
-
-   setup_new_alpha_mask(ctx, stfb, width, height);
-
-   pipe_sampler_view_reference( &stfb->blend_texture_view, NULL );
-   stfb->blend_texture_view = create_tex_and_view(ctx->pipe, PIPE_FORMAT_B8G8R8A8_UNORM,
-                                                  width, height);
-}
-
-void st_set_framebuffer_surface(struct st_framebuffer *stfb,
-                                uint surfIndex, struct pipe_surface *surf)
-{
-   struct st_renderbuffer *rb = stfb->strb;
-
-   /* unreference existing surfaces */
-   pipe_surface_reference( &rb->surface, NULL );
-   pipe_texture_reference( &rb->texture, NULL );
-
-   /* reference new ones */
-   pipe_surface_reference( &rb->surface, surf );
-   pipe_texture_reference( &rb->texture, surf->texture );
-
-   rb->width  = surf->width;
-   rb->height = surf->height;
-}
-
-int st_get_framebuffer_surface(struct st_framebuffer *stfb,
-                               uint surfIndex, struct pipe_surface **surf)
-{
-   struct st_renderbuffer *rb = stfb->strb;
-   *surf = rb->surface;
-   return VG_TRUE;
-}
-
-int st_get_framebuffer_texture(struct st_framebuffer *stfb,
-                               uint surfIndex, struct pipe_texture **tex)
-{
-   struct st_renderbuffer *rb = stfb->strb;
-   *tex = rb->texture;
-   return VG_TRUE;
-}
-
-void * st_framebuffer_private(struct st_framebuffer *stfb)
-{
-   return stfb->privateData;
-}
-
-void st_unreference_framebuffer(struct st_framebuffer *stfb)
-{
-   /* FIXME */
-}
-
-boolean st_make_current(struct vg_context *st,
-                        struct st_framebuffer *draw,
-                        struct st_framebuffer *read,
-                        void *winsys_drawable_handle)
-{
-   vg_set_current_context(st);
-   if (st)
-      st->draw_buffer = draw;
-   return VG_TRUE;
-}
-
-struct vg_context *st_get_current(void)
-{
-   return vg_current_context();
-}
-
-void st_flush(struct vg_context *st, uint pipeFlushFlags,
-              struct pipe_fence_handle **fence)
-{
-   st->pipe->flush(st->pipe, pipeFlushFlags, fence);
-}
-
-void st_finish(struct vg_context *st)
-{
-   struct pipe_fence_handle *fence = NULL;
-
-   st_flush(st, PIPE_FLUSH_RENDER_CACHE, &fence);
-
-   st->pipe->screen->fence_finish(st->pipe->screen, fence, 0);
-   st->pipe->screen->fence_reference(st->pipe->screen, &fence, NULL);
-}
-
-void st_notify_swapbuffers(struct st_framebuffer *stfb)
-{
-   struct vg_context *ctx = vg_current_context();
-   if (ctx && ctx->draw_buffer == stfb) {
-      st_flush(ctx,
-	       PIPE_FLUSH_RENDER_CACHE | 
-	       PIPE_FLUSH_SWAPBUFFERS |
-	       PIPE_FLUSH_FRAME,
-               NULL);
-   }
-}
-
-void st_notify_swapbuffers_complete(struct st_framebuffer *stfb)
-{
-}
-
-int st_bind_texture_surface(struct pipe_surface *ps, int target, int level,
-                            enum pipe_format format)
-{
-   return 0;
-}
-
-int st_unbind_texture_surface(struct pipe_surface *ps, int target, int level)
-{
-   return 0;
-}
-
-st_proc st_get_proc_address(const char *procname)
-{
-   return NULL;
-}
diff --git a/src/gallium/state_trackers/vega/vg_tracker.h b/src/gallium/state_trackers/vega/vg_tracker.h
deleted file mode 100644
index 165a6b7a332..00000000000
--- a/src/gallium/state_trackers/vega/vg_tracker.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.  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 VMWARE 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 VG_TRACKER_H
-#define VG_TRACKER_H
-
-#include "VG/openvg.h"
-
-#include "pipe/p_compiler.h"
-#include "pipe/p_format.h"
-
-#define ST_SURFACE_FRONT_LEFT   0
-#define ST_SURFACE_BACK_LEFT    1
-#define ST_SURFACE_FRONT_RIGHT  2
-#define ST_SURFACE_BACK_RIGHT   3
-#define ST_SURFACE_DEPTH        8
-
-struct vg_context;
-struct st_framebuffer;
-struct pipe_context;
-struct pipe_fence_handle;
-struct pipe_surface;
-
-
-PUBLIC
-struct vg_context *st_create_context(struct pipe_context *pipe,
-                                     const void *visual,
-                                     struct vg_context *share);
-
-PUBLIC
-void st_destroy_context( struct vg_context *st );
-
-PUBLIC
-void st_copy_context_state(struct vg_context *dst, struct vg_context *src,
-                           uint mask);
-
-PUBLIC
-struct st_framebuffer *st_create_framebuffer(const void *visual,
-                                             enum pipe_format colorFormat,
-                                             enum pipe_format depthFormat,
-                                             enum pipe_format stencilFormat,
-                                             uint width, uint height,
-                                             void *privateData);
-
-PUBLIC
-void st_resize_framebuffer(struct st_framebuffer *stfb,
-                           uint width, uint height);
-
-PUBLIC
-void st_set_framebuffer_surface(struct st_framebuffer *stfb,
-                                uint surfIndex, struct pipe_surface *surf);
-
-PUBLIC
-void st_get_framebuffer_dimensions( struct st_framebuffer *stfb,
-				    uint *width, uint *height);
-
-PUBLIC
-int st_bind_texture_surface(struct pipe_surface *ps, int target, int level,
-                            enum pipe_format format);
-
-PUBLIC
-int st_unbind_texture_surface(struct pipe_surface *ps, int target, int level);
-
-PUBLIC
-int st_get_framebuffer_surface(struct st_framebuffer *stfb,
-                               uint surfIndex, struct pipe_surface **surf);
-
-PUBLIC
-int st_get_framebuffer_texture(struct st_framebuffer *stfb,
-                               uint surfIndex, struct pipe_texture **tex);
-
-PUBLIC
-void *st_framebuffer_private(struct st_framebuffer *stfb);
-
-PUBLIC
-void st_unreference_framebuffer(struct st_framebuffer *stfb);
-
-PUBLIC
-boolean st_make_current(struct vg_context *st,
-                        struct st_framebuffer *draw,
-                        struct st_framebuffer *read,
-                        void *winsys_drawable_handle);
-
-PUBLIC
-struct vg_context *st_get_current(void);
-
-PUBLIC
-void st_flush(struct vg_context *st, uint pipeFlushFlags,
-               struct pipe_fence_handle **fence);
-PUBLIC
-void st_finish(struct vg_context *st);
-
-PUBLIC
-void st_notify_swapbuffers(struct st_framebuffer *stfb);
-PUBLIC
-void st_notify_swapbuffers_complete(struct st_framebuffer *stfb);
-
-
-/** Generic function type */
-typedef void (*st_proc)();
-
-PUBLIC
-st_proc st_get_proc_address(const char *procname);
-
-#endif
diff --git a/src/gallium/state_trackers/wgl/SConscript b/src/gallium/state_trackers/wgl/SConscript
index 352c087475e..f59f3a9638a 100644
--- a/src/gallium/state_trackers/wgl/SConscript
+++ b/src/gallium/state_trackers/wgl/SConscript
@@ -28,6 +28,7 @@ if env['platform'] in ['windows']:
         'stw_framebuffer.c',
         'stw_getprocaddress.c',
         'stw_pixelformat.c',
+        'stw_st.c',
         'stw_tls.c',
         'stw_wgl.c',
     ]
diff --git a/src/gallium/state_trackers/wgl/stw_context.c b/src/gallium/state_trackers/wgl/stw_context.c
index 1f11b649c3e..0fb7cd83069 100644
--- a/src/gallium/state_trackers/wgl/stw_context.c
+++ b/src/gallium/state_trackers/wgl/stw_context.c
@@ -27,12 +27,13 @@
 
 #include <windows.h>
 
-#include "main/mtypes.h"
-#include "main/context.h"
 #include "pipe/p_compiler.h"
 #include "pipe/p_context.h"
+#include "state_tracker/st_api.h"
+
+/* for _mesa_share_state */
 #include "state_tracker/st_context.h"
-#include "state_tracker/st_public.h"
+#include "main/context.h"
 
 #include "stw_icd.h"
 #include "stw_device.h"
@@ -44,25 +45,13 @@
 
 
 static INLINE struct stw_context *
-stw_context(GLcontext *glctx)
-{
-   if(!glctx)
-      return NULL;
-   assert(glctx->DriverCtx);
-   return (struct stw_context *)glctx->DriverCtx;
-}
-
-static INLINE struct stw_context *
 stw_current_context(void)
 {
-   /* We must check if multiple threads are being used or GET_CURRENT_CONTEXT 
-    * might return the current context of the thread first seen. */
-   _glapi_check_multithread();
+   struct st_context_iface *st;
 
-   {
-      GET_CURRENT_CONTEXT( glctx );
-      return stw_context(glctx);
-   }
+   st = (stw_dev) ? stw_dev->stapi->get_current(stw_dev->stapi) : NULL;
+
+   return (struct stw_context *) ((st) ? st->st_manager_private : NULL);
 }
 
 BOOL APIENTRY
@@ -114,7 +103,11 @@ DrvShareLists(
    ctx2 = stw_lookup_context_locked( dhglrc2 );
 
    if (ctx1 && ctx2) {
-      ret = _mesa_share_state(ctx2->st->ctx, ctx1->st->ctx);
+      struct st_context *st1, *st2;
+
+      st1 = (struct st_context *) ctx1->st;
+      st2 = (struct st_context *) ctx2->st;
+      ret = _mesa_share_state(st2->ctx, st1->ctx);
    }
 
    pipe_mutex_unlock( stw_dev->ctx_mutex );
@@ -122,20 +115,6 @@ DrvShareLists(
    return ret;
 }
 
-static void
-stw_viewport(GLcontext * glctx, GLint x, GLint y,
-             GLsizei width, GLsizei height)
-{
-   struct stw_context *ctx = (struct stw_context *)glctx->DriverCtx;
-   struct stw_framebuffer *fb;
-   
-   fb = stw_framebuffer_from_hdc( ctx->hdc );
-   if(fb) {
-      stw_framebuffer_update(fb);
-      stw_framebuffer_release(fb);
-   }
-}
-
 DHGLRC APIENTRY
 DrvCreateContext(
    HDC hdc )
@@ -150,9 +129,7 @@ DrvCreateLayerContext(
 {
    int iPixelFormat;
    const struct stw_pixelformat_info *pfi;
-   GLvisual visual;
    struct stw_context *ctx = NULL;
-   struct pipe_context *pipe = NULL;
    
    if(!stw_dev)
       return 0;
@@ -165,7 +142,6 @@ DrvCreateLayerContext(
       return 0;
    
    pfi = stw_pixelformat_get_info( iPixelFormat - 1 );
-   stw_pixelformat_visual(&visual, pfi);
    
    ctx = CALLOC_STRUCT( stw_context );
    if (ctx == NULL)
@@ -174,18 +150,12 @@ DrvCreateLayerContext(
    ctx->hdc = hdc;
    ctx->iPixelFormat = iPixelFormat;
 
-   /* priv == hdc, pass to stw_flush_frontbuffer as context_private
-    */
-   pipe = stw_dev->screen->context_create( stw_dev->screen, hdc );
-   if (pipe == NULL) 
-      goto no_pipe;
-
-   ctx->st = st_create_context( pipe, &visual, NULL );
+   ctx->st = stw_dev->stapi->create_context(stw_dev->stapi,
+         stw_dev->smapi, &pfi->stvis, NULL);
    if (ctx->st == NULL) 
       goto no_st_ctx;
 
-   ctx->st->ctx->DriverCtx = ctx;
-   ctx->st->ctx->Driver.Viewport = stw_viewport;
+   ctx->st->st_manager_private = (void *) ctx;
 
    pipe_mutex_lock( stw_dev->ctx_mutex );
    ctx->dhglrc = handle_table_add(stw_dev->ctx_table, ctx);
@@ -196,11 +166,8 @@ DrvCreateLayerContext(
    return ctx->dhglrc;
 
 no_hglrc:
-   st_destroy_context(ctx->st);
-   goto no_pipe; /* st_context_destroy already destroys pipe */
+   ctx->st->destroy(ctx->st);
 no_st_ctx:
-   pipe->destroy( pipe );
-no_pipe:
    FREE(ctx);
 no_ctx:
    return 0;
@@ -226,9 +193,9 @@ DrvDeleteContext(
       
       /* Unbind current if deleting current context. */
       if (curctx == ctx)
-         st_make_current( NULL, NULL, NULL, NULL );
+         stw_dev->stapi->make_current(stw_dev->stapi, NULL, NULL, NULL);
 
-      st_destroy_context(ctx->st);
+      ctx->st->destroy(ctx->st);
       FREE(ctx);
 
       ret = TRUE;
@@ -306,7 +273,7 @@ stw_make_current(
    curctx = stw_current_context();
    if (curctx != NULL) {
       if (curctx->dhglrc != dhglrc)
-	 st_flush(curctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
+         curctx->st->flush(curctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
       
       /* Return if already current. */
       if (curctx->dhglrc == dhglrc && curctx->hdc == hdc) {
@@ -314,10 +281,12 @@ stw_make_current(
          fb = stw_framebuffer_from_hdc( hdc );
          goto success;
       }
+
+      stw_framebuffer_reference(&curctx->current_framebuffer, NULL);
    }
 
    if (hdc == NULL || dhglrc == 0) {
-      return st_make_current( NULL, NULL, NULL, NULL );
+      return stw_dev->stapi->make_current(stw_dev->stapi, NULL, NULL, NULL);
    }
 
    pipe_mutex_lock( stw_dev->ctx_mutex ); 
@@ -327,7 +296,10 @@ stw_make_current(
       goto fail;
 
    fb = stw_framebuffer_from_hdc( hdc );
-   if(!fb) { 
+   if (fb) {
+      stw_framebuffer_update(fb);
+   }
+   else {
       /* Applications should call SetPixelFormat before creating a context,
        * but not all do, and the opengl32 runtime seems to use a default pixel
        * format in some cases, so we must create a framebuffer for those here
@@ -342,23 +314,17 @@ stw_make_current(
    if(fb->iPixelFormat != ctx->iPixelFormat)
       goto fail;
 
-   /* Lazy allocation of the frame buffer */
-   if(!stw_framebuffer_allocate(fb))
-      goto fail;
-
    /* Bind the new framebuffer */
    ctx->hdc = hdc;
    
-   /* pass to stw_flush_frontbuffer as context_private */
-   ctx->st->pipe->priv = hdc;
-   
-   if(!st_make_current( ctx->st, fb->stfb, fb->stfb, hdc ))
+   if (!stw_dev->stapi->make_current(stw_dev->stapi, ctx->st, fb->stfb, fb->stfb))
       goto fail;
 
+   stw_framebuffer_reference(&ctx->current_framebuffer, fb);
+
 success:
    assert(fb);
    if(fb) {
-      stw_framebuffer_update(fb);
       stw_framebuffer_release(fb);
    }
    
@@ -367,11 +333,40 @@ success:
 fail:
    if(fb)
       stw_framebuffer_release(fb);
-   st_make_current( NULL, NULL, NULL, NULL );
+   stw_dev->stapi->make_current(stw_dev->stapi, NULL, NULL, NULL);
    return FALSE;
 }
 
 /**
+ * Flush the current context if it is bound to the framebuffer.
+ */
+void
+stw_flush_current_locked( struct stw_framebuffer *fb )
+{
+   struct stw_context *ctx = stw_current_context();
+
+   if (ctx && ctx->current_framebuffer == fb) {
+      ctx->st->flush(ctx->st,
+            PIPE_FLUSH_RENDER_CACHE | 
+            PIPE_FLUSH_SWAPBUFFERS |
+            PIPE_FLUSH_FRAME,
+            NULL);
+   }
+}
+
+/**
+ * Notify the current context that the framebuffer has become invalid.
+ */
+void
+stw_notify_current_locked( struct stw_framebuffer *fb )
+{
+   struct stw_context *ctx = stw_current_context();
+
+   if (ctx && ctx->current_framebuffer == fb)
+      ctx->st->notify_invalid_framebuffer(ctx->st, fb->stfb);
+}
+
+/**
  * Although WGL allows different dispatch entrypoints per context
  */
 static const GLCLTPROCTABLE cpt =
diff --git a/src/gallium/state_trackers/wgl/stw_context.h b/src/gallium/state_trackers/wgl/stw_context.h
index 256c27e21ef..0bbed84104a 100644
--- a/src/gallium/state_trackers/wgl/stw_context.h
+++ b/src/gallium/state_trackers/wgl/stw_context.h
@@ -30,14 +30,17 @@
 
 #include <windows.h>
 
-struct st_context;
+struct stw_framebuffer;
+struct st_context_iface;
 
 struct stw_context
 {
-   struct st_context *st;
+   struct st_context_iface *st;
    DHGLRC dhglrc;
    int iPixelFormat;
    HDC hdc;
+
+   struct stw_framebuffer *current_framebuffer;
 };
 
 DHGLRC stw_get_current_context( void );
@@ -46,4 +49,7 @@ HDC stw_get_current_dc( void );
 
 BOOL stw_make_current( HDC hdc, DHGLRC dhglrc );
 
+void stw_flush_current_locked( struct stw_framebuffer *fb );
+void stw_notify_current_locked( struct stw_framebuffer *fb );
+
 #endif /* STW_CONTEXT_H */
diff --git a/src/gallium/state_trackers/wgl/stw_device.c b/src/gallium/state_trackers/wgl/stw_device.c
index ea300f27cb5..61b207525ca 100644
--- a/src/gallium/state_trackers/wgl/stw_device.c
+++ b/src/gallium/state_trackers/wgl/stw_device.c
@@ -30,8 +30,8 @@
 #include "glapi/glthread.h"
 #include "util/u_debug.h"
 #include "util/u_math.h"
+#include "util/u_memory.h"
 #include "pipe/p_screen.h"
-#include "state_tracker/st_public.h"
 
 #include "stw_device.h"
 #include "stw_winsys.h"
@@ -39,6 +39,7 @@
 #include "stw_icd.h"
 #include "stw_tls.h"
 #include "stw_framebuffer.h"
+#include "stw_st.h"
 
 #ifdef WIN32_THREADS
 extern _glthread_Mutex OneTimeLock;
@@ -48,28 +49,6 @@ extern _glthread_Mutex OneTimeLock;
 struct stw_device *stw_dev = NULL;
 
 
-/**
- * XXX: Dispatch pipe_screen::flush_front_buffer to our 
- * stw_winsys::flush_front_buffer.
- */
-static void 
-stw_flush_frontbuffer(struct pipe_screen *screen,
-                     struct pipe_surface *surface,
-                     void *context_private )
-{
-   HDC hdc = (HDC)context_private;
-   struct stw_framebuffer *fb;
-   
-   fb = stw_framebuffer_from_hdc( hdc );
-   if (!fb) {
-      /* fb can be NULL if window was destroyed already */
-      return;
-   }
-
-   stw_framebuffer_present_locked(hdc, fb, surface);
-}
-
-
 boolean
 stw_init(const struct stw_winsys *stw_winsys)
 {
@@ -95,6 +74,11 @@ stw_init(const struct stw_winsys *stw_winsys)
    _glthread_INIT_MUTEX(OneTimeLock);
 #endif
 
+   stw_dev->stapi = stw_st_create_api();
+   stw_dev->smapi = CALLOC_STRUCT(st_manager);
+   if (!stw_dev->stapi || !stw_dev->smapi)
+      goto error1;
+
    screen = stw_winsys->create_screen();
    if(!screen)
       goto error1;
@@ -102,12 +86,9 @@ stw_init(const struct stw_winsys *stw_winsys)
    if(stw_winsys->get_adapter_luid)
       stw_winsys->get_adapter_luid(screen, &stw_dev->AdapterLuid);
 
+   stw_dev->smapi->screen = screen;
    stw_dev->screen = screen;
 
-   /* XXX
-    */
-   stw_dev->screen->flush_frontbuffer = &stw_flush_frontbuffer;
-   
    pipe_mutex_init( stw_dev->ctx_mutex );
    pipe_mutex_init( stw_dev->fb_mutex );
 
@@ -121,6 +102,11 @@ stw_init(const struct stw_winsys *stw_winsys)
    return TRUE;
 
 error1:
+   if (stw_dev->smapi)
+      FREE(stw_dev->smapi);
+   if (stw_dev->stapi)
+      stw_dev->stapi->destroy(stw_dev->stapi);
+
    stw_dev = NULL;
    return FALSE;
 }
@@ -170,6 +156,9 @@ stw_cleanup(void)
    pipe_mutex_destroy( stw_dev->fb_mutex );
    pipe_mutex_destroy( stw_dev->ctx_mutex );
    
+   FREE(stw_dev->smapi);
+   stw_dev->stapi->destroy(stw_dev->stapi);
+
    stw_dev->screen->destroy(stw_dev->screen);
 
 #ifdef WIN32_THREADS
diff --git a/src/gallium/state_trackers/wgl/stw_device.h b/src/gallium/state_trackers/wgl/stw_device.h
index 2e9ba197dfa..1b836960d0d 100644
--- a/src/gallium/state_trackers/wgl/stw_device.h
+++ b/src/gallium/state_trackers/wgl/stw_device.h
@@ -40,6 +40,8 @@
 
 
 struct pipe_screen;
+struct st_api;
+struct st_manager;
 struct stw_framebuffer;
 
 struct stw_device
@@ -48,6 +50,9 @@ struct stw_device
    
    struct pipe_screen *screen;
    
+   struct st_api *stapi;
+   struct st_manager *smapi;
+
    LUID AdapterLuid;
 
    struct stw_pixelformat_info pixelformats[STW_MAX_PIXELFORMATS];
diff --git a/src/gallium/state_trackers/wgl/stw_ext_pixelformat.c b/src/gallium/state_trackers/wgl/stw_ext_pixelformat.c
index 8a9995aba8e..ab56800e28d 100644
--- a/src/gallium/state_trackers/wgl/stw_ext_pixelformat.c
+++ b/src/gallium/state_trackers/wgl/stw_ext_pixelformat.c
@@ -227,11 +227,11 @@ stw_query_attrib(
       break;
 
    case WGL_SAMPLE_BUFFERS_ARB:
-      *pvalue = pfi->numSampleBuffers;
+      *pvalue = 1;
       break;
 
    case WGL_SAMPLES_ARB:
-      *pvalue = pfi->numSamples;
+      *pvalue = pfi->stvis.samples;
       break;
 
    default:
diff --git a/src/gallium/state_trackers/wgl/stw_framebuffer.c b/src/gallium/state_trackers/wgl/stw_framebuffer.c
index 4f1629de2f2..259b22f22c7 100644
--- a/src/gallium/state_trackers/wgl/stw_framebuffer.c
+++ b/src/gallium/state_trackers/wgl/stw_framebuffer.c
@@ -27,18 +27,19 @@
 
 #include <windows.h>
 
-#include "main/context.h"
 #include "pipe/p_format.h"
 #include "pipe/p_screen.h"
 #include "util/u_format.h"
-#include "state_tracker/st_context.h"
-#include "state_tracker/st_public.h"
+#include "util/u_memory.h"
+#include "state_tracker/st_api.h"
 
 #include "stw_icd.h"
 #include "stw_framebuffer.h"
 #include "stw_device.h"
 #include "stw_winsys.h"
 #include "stw_tls.h"
+#include "stw_context.h"
+#include "stw_st.h"
 
 
 /**
@@ -63,8 +64,8 @@ stw_framebuffer_from_hwnd_locked(
 
 /**
  * Destroy this framebuffer. Both stw_dev::fb_mutex and stw_framebuffer::mutex
- * must be held, by this order. Obviously no further access to fb can be done 
- * after this.
+ * must be held, by this order.  If there are still references to the
+ * framebuffer, nothing will happen.
  */
 static INLINE void
 stw_framebuffer_destroy_locked(
@@ -72,6 +73,13 @@ stw_framebuffer_destroy_locked(
 {
    struct stw_framebuffer **link;
 
+   /* check the reference count */
+   fb->refcnt--;
+   if (fb->refcnt) {
+      pipe_mutex_unlock( fb->mutex );
+      return;
+   }
+
    link = &stw_dev->fb_head;
    while (*link != fb)
       link = &(*link)->next;
@@ -82,7 +90,7 @@ stw_framebuffer_destroy_locked(
    if(fb->shared_surface)
       stw_dev->stw_winsys->shared_surface_close(stw_dev->screen, fb->shared_surface);
 
-   st_unreference_framebuffer(fb->stfb);
+   stw_st_destroy_framebuffer_locked(fb->stfb);
    
    pipe_mutex_unlock( fb->mutex );
 
@@ -230,9 +238,14 @@ stw_framebuffer_create(
    fb->iPixelFormat = iPixelFormat;
 
    fb->pfi = pfi = stw_pixelformat_get_info( iPixelFormat - 1 );
+   fb->stfb = stw_st_create_framebuffer( fb );
+   if (!fb->stfb) {
+      FREE( fb );
+      return NULL;
+   }
+
+   fb->refcnt = 1;
 
-   stw_pixelformat_visual(&fb->visual, pfi);
-   
    stw_framebuffer_get_size(fb);
 
    pipe_mutex_init( fb->mutex );
@@ -251,47 +264,31 @@ stw_framebuffer_create(
    return fb;
 }
 
-
-BOOL
-stw_framebuffer_allocate(
+/**
+ * Have ptr reference fb.  The referenced framebuffer should be locked.
+ */
+void
+stw_framebuffer_reference(
+   struct stw_framebuffer **ptr,
    struct stw_framebuffer *fb)
 {
-   assert(fb);
-   
-   if(!fb->stfb) {
-      const struct stw_pixelformat_info *pfi = fb->pfi;
-      enum pipe_format colorFormat, depthFormat, stencilFormat;
+   struct stw_framebuffer *old_fb = *ptr;
 
-      colorFormat = pfi->color_format;
+   if (old_fb == fb)
+      return;
 
-      if(util_format_get_component_bits(pfi->depth_stencil_format, UTIL_FORMAT_COLORSPACE_ZS, 0))
-         depthFormat = pfi->depth_stencil_format;
-      else
-         depthFormat = PIPE_FORMAT_NONE;
-   
-      if(util_format_get_component_bits(pfi->depth_stencil_format, UTIL_FORMAT_COLORSPACE_ZS, 1))
-         stencilFormat = pfi->depth_stencil_format;
-      else
-         stencilFormat = PIPE_FORMAT_NONE;
-   
-      assert(fb->must_resize);
-      assert(fb->width);
-      assert(fb->height);
-
-      fb->stfb = st_create_framebuffer(
-         &fb->visual,
-         colorFormat,
-         depthFormat,
-         stencilFormat,
-         fb->width,
-         fb->height,
-         (void *) fb );
-      
-      // to notify the context
-      fb->must_resize = TRUE;
+   if (fb)
+      fb->refcnt++;
+   if (old_fb) {
+      pipe_mutex_lock(stw_dev->fb_mutex);
+
+      pipe_mutex_lock(old_fb->mutex);
+      stw_framebuffer_destroy_locked(old_fb);
+
+      pipe_mutex_unlock(stw_dev->fb_mutex);
    }
-   
-   return fb->stfb ? TRUE : FALSE;
+
+   *ptr = fb;
 }
 
 
@@ -313,11 +310,6 @@ stw_framebuffer_update(
     * to know of their existing without using the not very portable PSAPI.
     */
    stw_framebuffer_get_size(fb);
-   
-   if(fb->must_resize) {
-      st_resize_framebuffer(fb->stfb, fb->width, fb->height);
-      fb->must_resize = FALSE;
-   }
 }                      
 
 
@@ -516,6 +508,7 @@ DrvPresentBuffers(HDC hdc, PGLPRESENTBUFFERSDATA data)
    }
 
    stw_framebuffer_update(fb);
+   stw_notify_current_locked(fb);
 
    stw_framebuffer_release(fb);
 
@@ -544,6 +537,7 @@ stw_framebuffer_present_locked(HDC hdc,
       data.rect = fb->client_rect;
       data.pPrivateData = (void *)surface;
 
+      stw_notify_current_locked(fb);
       stw_framebuffer_release(fb);
 
       return stw_dev->callbacks.wglCbPresentBuffers(hdc, &data);
@@ -554,7 +548,7 @@ stw_framebuffer_present_locked(HDC hdc,
       stw_dev->stw_winsys->present( screen, surface, hdc );
 
       stw_framebuffer_update(fb);
-
+      stw_notify_current_locked(fb);
       stw_framebuffer_release(fb);
 
       return TRUE;
@@ -567,7 +561,6 @@ DrvSwapBuffers(
    HDC hdc )
 {
    struct stw_framebuffer *fb;
-   struct pipe_surface *surface = NULL;
 
    if (!stw_dev)
       return FALSE;
@@ -581,9 +574,9 @@ DrvSwapBuffers(
       return TRUE;
    }
 
-   st_swapbuffers(fb->stfb, &surface, NULL);
+   stw_flush_current_locked(fb);
 
-   return stw_framebuffer_present_locked(hdc, fb, surface);
+   return stw_st_swap_framebuffer_locked(fb->stfb);
 }
 
 
diff --git a/src/gallium/state_trackers/wgl/stw_framebuffer.h b/src/gallium/state_trackers/wgl/stw_framebuffer.h
index e61e9bf9c26..89d12300e67 100644
--- a/src/gallium/state_trackers/wgl/stw_framebuffer.h
+++ b/src/gallium/state_trackers/wgl/stw_framebuffer.h
@@ -30,11 +30,10 @@
 
 #include <windows.h>
 
-#include "main/mtypes.h"
-
 #include "os/os_thread.h"
 
 struct pipe_surface;
+struct st_framebuffer_iface;
 struct stw_pixelformat_info;
 
 /**
@@ -64,13 +63,15 @@ struct stw_framebuffer
 
    int iPixelFormat;
    const struct stw_pixelformat_info *pfi;
-   GLvisual visual;
+
+   struct st_framebuffer_iface *stfb;
 
    /*
     * Mutable members. 
     */
 
-   struct st_framebuffer *stfb;
+   unsigned refcnt;
+
    
    /* FIXME: Make this work for multiple contexts bound to the same framebuffer */
    boolean must_resize;
@@ -114,6 +115,11 @@ stw_framebuffer_create(
    HDC hdc,
    int iPixelFormat );
 
+void
+stw_framebuffer_reference(
+   struct stw_framebuffer **ptr,
+   struct stw_framebuffer *fb);
+
 /**
  * Search a framebuffer with a matching HWND.
  * 
@@ -135,10 +141,6 @@ stw_framebuffer_from_hdc(
    HDC hdc );
 
 BOOL
-stw_framebuffer_allocate(
-   struct stw_framebuffer *fb );
-
-BOOL
 stw_framebuffer_present_locked(HDC hdc,
                                struct stw_framebuffer *fb,
                                struct pipe_surface *surface);
diff --git a/src/gallium/state_trackers/wgl/stw_pixelformat.c b/src/gallium/state_trackers/wgl/stw_pixelformat.c
index 02ff89a388b..11e779d25f8 100644
--- a/src/gallium/state_trackers/wgl/stw_pixelformat.c
+++ b/src/gallium/state_trackers/wgl/stw_pixelformat.c
@@ -142,9 +142,6 @@ stw_pixelformat_add(
    
    memset(pfi, 0, sizeof *pfi);
    
-   pfi->color_format = color->format;
-   pfi->depth_stencil_format = depth->format;
-   
    pfi->pfd.nSize = sizeof pfi->pfd;
    pfi->pfd.nVersion = 1;
 
@@ -184,11 +181,22 @@ stw_pixelformat_add(
    pfi->pfd.dwVisibleMask = 0;
    pfi->pfd.dwDamageMask = 0;
 
-   if(samples) {
-      pfi->numSampleBuffers = 1;
-      pfi->numSamples = samples;
-      extended = TRUE;
-   }
+   /*
+    * since state trackers can allocate depth/stencil/accum buffers, we provide
+    * only color buffers here
+    */
+   pfi->stvis.buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
+   if (doublebuffer)
+      pfi->stvis.buffer_mask = ST_ATTACHMENT_BACK_LEFT_MASK;
+
+   pfi->stvis.color_format = color->format;
+   pfi->stvis.depth_stencil_format = depth->format;
+
+   pfi->stvis.accum_format = (accum) ?
+      PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE;
+
+   pfi->stvis.samples = samples;
+   pfi->stvis.render_buffer = ST_ATTACHMENT_INVALID;
    
    ++stw_dev->pixelformat_extended_count;
    
@@ -218,8 +226,8 @@ stw_pixelformat_init( void )
          const struct stw_pf_color_info *color = &stw_pf_color[j];
          
          if(!screen->is_format_supported(screen, color->format, PIPE_TEXTURE_2D, 
-                                         PIPE_TEXTURE_USAGE_RENDER_TARGET |
-                                         PIPE_TEXTURE_USAGE_DISPLAY_TARGET, 0))
+                                         PIPE_BIND_RENDER_TARGET |
+                                         PIPE_BIND_DISPLAY_TARGET, 0))
             continue;
          
          for(k = 0; k < Elements(stw_pf_doublebuffer); ++k) {
@@ -229,7 +237,7 @@ stw_pixelformat_init( void )
                const struct stw_pf_depth_info *depth = &stw_pf_depth_stencil[l];
                
                if(!screen->is_format_supported(screen, depth->format, PIPE_TEXTURE_2D, 
-                                               PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0))
+                                               PIPE_BIND_DEPTH_STENCIL, 0))
                   continue;
 
                stw_pixelformat_add( stw_dev, color, depth,  0, doublebuffer, samples );
@@ -264,29 +272,6 @@ stw_pixelformat_get_info( uint index )
 }
 
 
-void
-stw_pixelformat_visual(GLvisual *visual, 
-                       const struct stw_pixelformat_info *pfi )
-{
-   memset(visual, 0, sizeof *visual);
-   _mesa_initialize_visual(
-      visual,
-      (pfi->pfd.dwFlags & PFD_DOUBLEBUFFER) ? GL_TRUE : GL_FALSE,
-      (pfi->pfd.dwFlags & PFD_STEREO) ? GL_TRUE : GL_FALSE,
-      pfi->pfd.cRedBits,
-      pfi->pfd.cGreenBits,
-      pfi->pfd.cBlueBits,
-      pfi->pfd.cAlphaBits,
-      pfi->pfd.cDepthBits,
-      pfi->pfd.cStencilBits,
-      pfi->pfd.cAccumRedBits,
-      pfi->pfd.cAccumGreenBits,
-      pfi->pfd.cAccumBlueBits,
-      pfi->pfd.cAccumAlphaBits,
-      pfi->numSamples );
-}
-
-
 LONG APIENTRY
 DrvDescribePixelFormat(
    HDC hdc,
diff --git a/src/gallium/state_trackers/wgl/stw_pixelformat.h b/src/gallium/state_trackers/wgl/stw_pixelformat.h
index 3a690b35bad..d405172773c 100644
--- a/src/gallium/state_trackers/wgl/stw_pixelformat.h
+++ b/src/gallium/state_trackers/wgl/stw_pixelformat.h
@@ -38,16 +38,13 @@
 
 #include "pipe/p_compiler.h"
 #include "pipe/p_format.h"
+#include "state_tracker/st_api.h"
 
 struct stw_pixelformat_info
 {
-   enum pipe_format color_format;
-   enum pipe_format depth_stencil_format;
-   
    PIXELFORMATDESCRIPTOR pfd;
    
-   unsigned numSampleBuffers;
-   unsigned numSamples;
+   struct st_visual stvis;
 };
 
 void
@@ -62,10 +59,6 @@ stw_pixelformat_get_extended_count( void );
 const struct stw_pixelformat_info *
 stw_pixelformat_get_info( uint index );
 
-void
-stw_pixelformat_visual(GLvisual *visual, 
-                       const struct stw_pixelformat_info *pfi );
-
 int
 stw_pixelformat_choose( HDC hdc,
                         CONST PIXELFORMATDESCRIPTOR *ppfd );
diff --git a/src/gallium/state_trackers/wgl/stw_st.c b/src/gallium/state_trackers/wgl/stw_st.c
new file mode 100644
index 00000000000..f4ea61ed2c6
--- /dev/null
+++ b/src/gallium/state_trackers/wgl/stw_st.c
@@ -0,0 +1,312 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.9
+ *
+ * Copyright (C) 2010 LunarG Inc.
+ *
+ * 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, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Chia-I Wu <olv@lunarg.com>
+ */
+
+#include "util/u_memory.h"
+#include "util/u_inlines.h"
+#include "state_tracker/st_manager.h" /* for st_manager_create_api */
+
+#include "stw_st.h"
+#include "stw_device.h"
+#include "stw_framebuffer.h"
+#include "stw_pixelformat.h"
+
+struct stw_st_framebuffer {
+   struct st_framebuffer_iface base;
+
+   struct stw_framebuffer *fb;
+   struct st_visual stvis;
+
+   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
+   unsigned texture_width, texture_height;
+   unsigned texture_mask;
+
+   struct pipe_surface *front_surface, *back_surface;
+};
+
+static INLINE struct stw_st_framebuffer *
+stw_st_framebuffer(struct st_framebuffer_iface *stfb)
+{
+   return (struct stw_st_framebuffer *) stfb;
+}
+
+/**
+ * Remove outdated textures and create the requested ones.
+ */
+static void
+stw_st_framebuffer_validate_locked(struct st_framebuffer_iface *stfb,
+                                   unsigned width, unsigned height,
+                                   unsigned mask)
+{
+   struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
+   struct pipe_resource templ;
+   unsigned i;
+
+   /* remove outdated surface */
+   pipe_surface_reference(&stwfb->front_surface, NULL);
+   pipe_surface_reference(&stwfb->back_surface, NULL);
+
+   /* remove outdated textures */
+   if (stwfb->texture_width != width || stwfb->texture_height != height) {
+      for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
+         pipe_resource_reference(&stwfb->textures[i], NULL);
+   }
+
+   memset(&templ, 0, sizeof(templ));
+   templ.target = PIPE_TEXTURE_2D;
+   templ.width0 = width;
+   templ.height0 = height;
+   templ.depth0 = 1;
+   templ.last_level = 0;
+
+   for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
+      enum pipe_format format;
+      unsigned bind;
+
+      /* the texture already exists or not requested */
+      if (stwfb->textures[i] || !(mask & (1 << i))) {
+         /* remember the texture */
+         if (stwfb->textures[i])
+            mask |= (1 << i);
+         continue;
+      }
+
+      switch (i) {
+      case ST_ATTACHMENT_FRONT_LEFT:
+      case ST_ATTACHMENT_BACK_LEFT:
+         format = stwfb->stvis.color_format;
+         bind = PIPE_BIND_DISPLAY_TARGET |
+                PIPE_BIND_RENDER_TARGET;
+         break;
+      case ST_ATTACHMENT_DEPTH_STENCIL:
+         format = stwfb->stvis.depth_stencil_format;
+         bind = PIPE_BIND_DEPTH_STENCIL;
+         break;
+      default:
+         format = PIPE_FORMAT_NONE;
+         break;
+      }
+
+      if (format != PIPE_FORMAT_NONE) {
+         templ.format = format;
+         templ.bind = bind;
+
+         stwfb->textures[i] =
+            stw_dev->screen->resource_create(stw_dev->screen, &templ);
+      }
+   }
+
+   stwfb->texture_width = width;
+   stwfb->texture_height = height;
+   stwfb->texture_mask = mask;
+}
+
+static boolean 
+stw_st_framebuffer_validate(struct st_framebuffer_iface *stfb,
+                            const enum st_attachment_type *statts,
+                            unsigned count,
+                            struct pipe_resource **out)
+{
+   struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
+   unsigned statt_mask, i;
+
+   statt_mask = 0x0;
+   for (i = 0; i < count; i++)
+      statt_mask |= 1 << statts[i];
+
+   pipe_mutex_lock(stwfb->fb->mutex);
+
+   if (stwfb->fb->must_resize || (statt_mask & ~stwfb->texture_mask)) {
+      stw_st_framebuffer_validate_locked(&stwfb->base,
+            stwfb->fb->width, stwfb->fb->height, statt_mask);
+      stwfb->fb->must_resize = FALSE;
+   }
+
+   for (i = 0; i < count; i++) {
+      out[i] = NULL;
+      pipe_resource_reference(&out[i], stwfb->textures[statts[i]]);
+   }
+
+   stw_framebuffer_release(stwfb->fb);
+
+   return TRUE;
+}
+
+static struct pipe_surface *
+get_present_surface_locked(struct st_framebuffer_iface *stfb,
+                           enum st_attachment_type statt)
+{
+   struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
+   struct pipe_resource *ptex;
+   struct pipe_surface *psurf, **cache;
+   
+   ptex = stwfb->textures[statt];
+   if (!ptex)
+      return NULL;
+
+   psurf = NULL;
+
+   switch (statt) {
+   case ST_ATTACHMENT_FRONT_LEFT:
+      cache = &stwfb->front_surface;
+      break;
+   case ST_ATTACHMENT_BACK_LEFT:
+      cache = &stwfb->back_surface;
+      break;
+   default:
+      cache = &psurf;
+      break;
+   }
+
+   if (!*cache) {
+      *cache = stw_dev->screen->get_tex_surface(stw_dev->screen,
+            ptex, 0, 0, 0,
+            PIPE_BIND_DISPLAY_TARGET |
+            PIPE_BIND_RENDER_TARGET);
+   }
+
+   if (psurf != *cache)
+      pipe_surface_reference(&psurf, *cache);
+
+   return psurf;
+}
+
+/**
+ * Present an attachment of the framebuffer.
+ */
+static boolean
+stw_st_framebuffer_present_locked(struct st_framebuffer_iface *stfb,
+                                  enum st_attachment_type statt)
+{
+   struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
+   struct pipe_surface *psurf;
+   
+   psurf = get_present_surface_locked(&stwfb->base, statt);
+   if (psurf) {
+      stw_framebuffer_present_locked(stwfb->fb->hDC, stwfb->fb, psurf);
+      pipe_surface_reference(&psurf, NULL);
+   }
+
+   return TRUE;
+}
+
+static boolean
+stw_st_framebuffer_flush_front(struct st_framebuffer_iface *stfb,
+                               enum st_attachment_type statt)
+{
+   struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
+
+   pipe_mutex_lock(stwfb->fb->mutex);
+
+   return stw_st_framebuffer_present_locked(&stwfb->base, statt);
+}
+
+/**
+ * Create a framebuffer interface.
+ */
+struct st_framebuffer_iface *
+stw_st_create_framebuffer(struct stw_framebuffer *fb)
+{
+   struct stw_st_framebuffer *stwfb;
+
+   stwfb = CALLOC_STRUCT(stw_st_framebuffer);
+   if (!stwfb)
+      return NULL;
+
+   stwfb->fb = fb;
+   stwfb->stvis = fb->pfi->stvis;
+
+   stwfb->base.visual = &stwfb->stvis;
+   stwfb->base.flush_front = stw_st_framebuffer_flush_front;
+   stwfb->base.validate = stw_st_framebuffer_validate;
+
+   return &stwfb->base;
+}
+
+/**
+ * Destroy a framebuffer interface.
+ */
+void
+stw_st_destroy_framebuffer_locked(struct st_framebuffer_iface *stfb)
+{
+   struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
+   int i;
+
+   pipe_surface_reference(&stwfb->front_surface, NULL);
+   pipe_surface_reference(&stwfb->back_surface, NULL);
+
+   for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
+      pipe_resource_reference(&stwfb->textures[i], NULL);
+
+   FREE(stwfb);
+}
+
+/**
+ * Swap the buffers of the given framebuffer.
+ */
+boolean
+stw_st_swap_framebuffer_locked(struct st_framebuffer_iface *stfb)
+{
+   struct stw_st_framebuffer *stwfb = stw_st_framebuffer(stfb);
+   unsigned front = ST_ATTACHMENT_FRONT_LEFT, back = ST_ATTACHMENT_BACK_LEFT;
+   struct pipe_resource *ptex;
+   struct pipe_surface *psurf;
+   unsigned mask;
+
+   /* swap the textures */
+   ptex = stwfb->textures[front];
+   stwfb->textures[front] = stwfb->textures[back];
+   stwfb->textures[back] = ptex;
+
+   /* swap the surfaces */
+   psurf = stwfb->front_surface;
+   stwfb->front_surface = stwfb->back_surface;
+   stwfb->back_surface = psurf;
+
+   /* convert to mask */
+   front = 1 << front;
+   back = 1 << back;
+
+   /* swap the bits in mask */
+   mask = stwfb->texture_mask & ~(front | back);
+   if (stwfb->texture_mask & front)
+      mask |= back;
+   if (stwfb->texture_mask & back)
+      mask |= front;
+   stwfb->texture_mask = mask;
+
+   front = ST_ATTACHMENT_FRONT_LEFT;
+   return stw_st_framebuffer_present_locked(&stwfb->base, front);
+}
+
+/**
+ * Create an st_api of the state tracker.
+ */
+struct st_api *
+stw_st_create_api(void)
+{
+   return st_manager_create_api();
+}
diff --git a/src/gallium/state_trackers/wgl/stw_st.h b/src/gallium/state_trackers/wgl/stw_st.h
new file mode 100644
index 00000000000..23771d8bef6
--- /dev/null
+++ b/src/gallium/state_trackers/wgl/stw_st.h
@@ -0,0 +1,47 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.9
+ *
+ * Copyright (C) 2010 LunarG Inc.
+ *
+ * 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, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ *
+ * Authors:
+ *    Chia-I Wu <olv@lunarg.com>
+ */
+
+#ifndef STW_ST_H
+#define STW_ST_H
+
+#include "state_tracker/st_api.h"
+
+struct stw_framebuffer;
+
+struct st_api *
+stw_st_create_api(void);
+
+struct st_framebuffer_iface *
+stw_st_create_framebuffer(struct stw_framebuffer *fb);
+
+void
+stw_st_destroy_framebuffer_locked(struct st_framebuffer_iface *stfb);
+
+boolean
+stw_st_swap_framebuffer_locked(struct st_framebuffer_iface *stfb);
+
+#endif /* STW_ST_H */
diff --git a/src/gallium/state_trackers/xorg/xorg_crtc.c b/src/gallium/state_trackers/xorg/xorg_crtc.c
index eef428232b0..669bd9edcf0 100644
--- a/src/gallium/state_trackers/xorg/xorg_crtc.c
+++ b/src/gallium/state_trackers/xorg/xorg_crtc.c
@@ -62,7 +62,7 @@ struct crtc_private
     drmModeCrtcPtr drm_crtc;
 
     /* hwcursor */
-    struct pipe_texture *cursor_tex;
+    struct pipe_resource *cursor_tex;
     struct kms_bo *cursor_bo;
 
     unsigned cursor_handle;
@@ -197,12 +197,12 @@ crtc_load_cursor_argb_ga3d(xf86CrtcPtr crtc, CARD32 * image)
     struct pipe_transfer *transfer;
 
     if (!crtcp->cursor_tex) {
-	struct pipe_texture templat;
+	struct pipe_resource templat;
 	struct winsys_handle whandle;
 
 	memset(&templat, 0, sizeof(templat));
-	templat.tex_usage |= PIPE_TEXTURE_USAGE_RENDER_TARGET;
-	templat.tex_usage |= PIPE_TEXTURE_USAGE_SCANOUT;
+	templat.bind |= PIPE_BIND_RENDER_TARGET;
+	templat.bind |= PIPE_BIND_SCANOUT;
 	templat.target = PIPE_TEXTURE_2D;
 	templat.last_level = 0;
 	templat.depth0 = 1;
@@ -213,14 +213,14 @@ crtc_load_cursor_argb_ga3d(xf86CrtcPtr crtc, CARD32 * image)
 	memset(&whandle, 0, sizeof(whandle));
 	whandle.type = DRM_API_HANDLE_TYPE_KMS;
 
-	crtcp->cursor_tex = ms->screen->texture_create(ms->screen,
+	crtcp->cursor_tex = ms->screen->resource_create(ms->screen,
 						       &templat);
-	ms->screen->texture_get_handle(ms->screen, crtcp->cursor_tex, &whandle);
+	ms->screen->resource_get_handle(ms->screen, crtcp->cursor_tex, &whandle);
 
 	crtcp->cursor_handle = whandle.handle;
     }
 
-    transfer = ms->ctx->get_tex_transfer(ms->ctx, crtcp->cursor_tex,
+    transfer = pipe_get_transfer(ms->ctx, crtcp->cursor_tex,
                                          0, 0, 0,
                                          PIPE_TRANSFER_WRITE,
                                          0, 0, 64, 64);
@@ -229,7 +229,7 @@ crtc_load_cursor_argb_ga3d(xf86CrtcPtr crtc, CARD32 * image)
 		   transfer->stride, 0, 0,
 		   64, 64, (void*)image, 64 * 4, 0, 0);
     ms->ctx->transfer_unmap(ms->ctx, transfer);
-    ms->ctx->tex_transfer_destroy(ms->ctx, transfer);
+    ms->ctx->transfer_destroy(ms->ctx, transfer);
 }
 
 #if HAVE_LIBKMS
@@ -329,7 +329,7 @@ xorg_crtc_cursor_destroy(xf86CrtcPtr crtc)
     struct crtc_private *crtcp = crtc->driver_private;
 
     if (crtcp->cursor_tex)
-	pipe_texture_reference(&crtcp->cursor_tex, NULL);
+	pipe_resource_reference(&crtcp->cursor_tex, NULL);
 #ifdef HAVE_LIBKMS
     if (crtcp->cursor_bo)
 	kms_bo_destroy(&crtcp->cursor_bo);
diff --git a/src/gallium/state_trackers/xorg/xorg_dri2.c b/src/gallium/state_trackers/xorg/xorg_dri2.c
index 91c251bb4ff..b90f9c908d2 100644
--- a/src/gallium/state_trackers/xorg/xorg_dri2.c
+++ b/src/gallium/state_trackers/xorg/xorg_dri2.c
@@ -53,14 +53,14 @@ static Bool set_format_in_do_create_buffer;
 
 typedef struct {
     PixmapPtr pPixmap;
-    struct pipe_texture *tex;
+    struct pipe_resource *tex;
     struct pipe_fence_handle *fence;
 } *BufferPrivatePtr;
 
 static Bool
 dri2_do_create_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer, unsigned int format)
 {
-    struct pipe_texture *tex = NULL;
+    struct pipe_resource *tex = NULL;
     ScreenPtr pScreen = pDraw->pScreen;
     ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
     modesettingPtr ms = modesettingPTR(pScrn);
@@ -101,9 +101,9 @@ dri2_do_create_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer, unsigned int form
         /* Fall through */
     case DRI2BufferDepth:
 	if (exa_priv->depth_stencil_tex)
-	    pipe_texture_reference(&tex, exa_priv->depth_stencil_tex);
+	    pipe_resource_reference(&tex, exa_priv->depth_stencil_tex);
         else {
-	    struct pipe_texture template;
+	    struct pipe_resource template;
             unsigned depthBits = (format != 0) ? format : pDraw->depth;
 	    memset(&template, 0, sizeof(template));
 	    template.target = PIPE_TEXTURE_2D;
@@ -128,10 +128,10 @@ dri2_do_create_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer, unsigned int form
 	    template.height0 = pDraw->height;
 	    template.depth0 = 1;
 	    template.last_level = 0;
-	    template.tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL |
-		PIPE_TEXTURE_USAGE_SHARED;
-	    tex = ms->screen->texture_create(ms->screen, &template);
-	    pipe_texture_reference(&exa_priv->depth_stencil_tex, tex);
+	    template.bind = PIPE_BIND_DEPTH_STENCIL |
+		PIPE_BIND_SHARED;
+	    tex = ms->screen->resource_create(ms->screen, &template);
+	    pipe_resource_reference(&exa_priv->depth_stencil_tex, tex);
 	}
 	break;
     }
@@ -157,7 +157,7 @@ dri2_do_create_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer, unsigned int form
     memset(&whandle, 0, sizeof(whandle));
     whandle.type = DRM_API_HANDLE_TYPE_SHARED;
 
-    ms->screen->texture_get_handle(ms->screen, tex, &whandle);
+    ms->screen->resource_get_handle(ms->screen, tex, &whandle);
 
     buffer->name = whandle.handle;
     buffer->pitch = whandle.stride;
@@ -185,9 +185,9 @@ dri2_do_destroy_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer)
     BufferPrivatePtr private = buffer->driverPrivate;
     struct exa_pixmap_priv *exa_priv = exaGetPixmapDriverPrivate(private->pPixmap);
 
-    pipe_texture_reference(&private->tex, NULL);
+    pipe_resource_reference(&private->tex, NULL);
     ms->screen->fence_reference(ms->screen, &private->fence, NULL);
-    pipe_texture_reference(&exa_priv->depth_stencil_tex, NULL);
+    pipe_resource_reference(&exa_priv->depth_stencil_tex, NULL);
     (*pScreen->DestroyPixmap)(private->pPixmap);
 }
 
@@ -437,11 +437,11 @@ xorg_dri2_init(ScreenPtr pScreen)
     ms->d_depth_bits_last =
 	 ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24X8_UNORM,
 					 PIPE_TEXTURE_2D,
-					 PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+					 PIPE_BIND_DEPTH_STENCIL, 0);
     ms->ds_depth_bits_last =
 	 ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 					 PIPE_TEXTURE_2D,
-					 PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0);
+					 PIPE_BIND_DEPTH_STENCIL, 0);
 
     return DRI2ScreenInit(pScreen, &dri2info);
 }
diff --git a/src/gallium/state_trackers/xorg/xorg_driver.c b/src/gallium/state_trackers/xorg/xorg_driver.c
index 8ac5179545a..3687ee0db4e 100644
--- a/src/gallium/state_trackers/xorg/xorg_driver.c
+++ b/src/gallium/state_trackers/xorg/xorg_driver.c
@@ -676,10 +676,9 @@ drv_screen_init(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
     }
 
     if (ms->screen) {
-	float maxf;
 	int max;
-	maxf = ms->screen->get_paramf(ms->screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS);
-	max = (1 << (int)(maxf - 1.0f));
+	max = ms->screen->get_param(ms->screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS);
+	max = 1 << (max - 1);
 	max_width = max < max_width ? max : max_width;
 	max_height = max < max_height ? max : max_height;
     }
@@ -986,7 +985,7 @@ drv_destroy_front_buffer_ga3d(ScrnInfoPtr pScrn)
 	ms->fb_id = -1;
     }
 
-    pipe_texture_reference(&ms->root_texture, NULL);
+    pipe_resource_reference(&ms->root_texture, NULL);
     return TRUE;
 }
 
@@ -994,7 +993,7 @@ static Bool
 drv_create_front_buffer_ga3d(ScrnInfoPtr pScrn)
 {
     modesettingPtr ms = modesettingPTR(pScrn);
-    struct pipe_texture *tex;
+    struct pipe_resource *tex;
     struct winsys_handle whandle;
     unsigned fb_id;
     int ret;
@@ -1010,7 +1009,7 @@ drv_create_front_buffer_ga3d(ScrnInfoPtr pScrn)
     memset(&whandle, 0, sizeof(whandle));
     whandle.type = DRM_API_HANDLE_TYPE_KMS;
 
-    if (!ms->screen->texture_get_handle(ms->screen, tex, &whandle))
+    if (!ms->screen->resource_get_handle(ms->screen, tex, &whandle))
 	goto err_destroy;
 
     ret = drmModeAddFB(ms->fd,
@@ -1034,14 +1033,14 @@ drv_create_front_buffer_ga3d(ScrnInfoPtr pScrn)
     pScrn->frameY0 = 0;
     drv_adjust_frame(pScrn->scrnIndex, pScrn->frameX0, pScrn->frameY0, 0);
 
-    pipe_texture_reference(&ms->root_texture, tex);
-    pipe_texture_reference(&tex, NULL);
+    pipe_resource_reference(&ms->root_texture, tex);
+    pipe_resource_reference(&tex, NULL);
     ms->fb_id = fb_id;
 
     return TRUE;
 
 err_destroy:
-    pipe_texture_reference(&tex, NULL);
+    pipe_resource_reference(&tex, NULL);
     return FALSE;
 }
 
@@ -1051,7 +1050,7 @@ drv_bind_front_buffer_ga3d(ScrnInfoPtr pScrn)
     modesettingPtr ms = modesettingPTR(pScrn);
     ScreenPtr pScreen = pScrn->pScreen;
     PixmapPtr rootPixmap = pScreen->GetScreenPixmap(pScreen);
-    struct pipe_texture *check;
+    struct pipe_resource *check;
 
     xorg_exa_set_displayed_usage(rootPixmap);
     xorg_exa_set_shared_usage(rootPixmap);
@@ -1063,7 +1062,7 @@ drv_bind_front_buffer_ga3d(ScrnInfoPtr pScrn)
     if (ms->root_texture != check)
 	FatalError("Created new root texture\n");
 
-    pipe_texture_reference(&check, NULL);
+    pipe_resource_reference(&check, NULL);
     return TRUE;
 }
 
diff --git a/src/gallium/state_trackers/xorg/xorg_exa.c b/src/gallium/state_trackers/xorg/xorg_exa.c
index 76e6411bb8c..d5a1be81747 100644
--- a/src/gallium/state_trackers/xorg/xorg_exa.c
+++ b/src/gallium/state_trackers/xorg/xorg_exa.c
@@ -188,7 +188,7 @@ ExaDownloadFromScreen(PixmapPtr pPix, int x,  int y, int w,  int h, char *dst,
     if (!priv || !priv->tex)
 	return FALSE;
 
-    transfer = exa->pipe->get_tex_transfer(exa->pipe, priv->tex, 0, 0, 0,
+    transfer = pipe_get_transfer(exa->pipe, priv->tex, 0, 0, 0,
 					   PIPE_TRANSFER_READ, x, y, w, h);
     if (!transfer)
 	return FALSE;
@@ -203,7 +203,7 @@ ExaDownloadFromScreen(PixmapPtr pPix, int x,  int y, int w,  int h, char *dst,
 		   transfer->stride, 0, 0);
 
     exa->pipe->transfer_unmap(exa->pipe, transfer);
-    exa->pipe->tex_transfer_destroy(exa->pipe, transfer);
+    exa->pipe->transfer_destroy(exa->pipe, transfer);
 
     return TRUE;
 }
@@ -222,7 +222,7 @@ ExaUploadToScreen(PixmapPtr pPix, int x, int y, int w, int h, char *src,
     if (!priv || !priv->tex)
 	return FALSE;
 
-    transfer = exa->pipe->get_tex_transfer(exa->pipe, priv->tex, 0, 0, 0,
+    transfer = pipe_get_transfer(exa->pipe, priv->tex, 0, 0, 0,
 					   PIPE_TRANSFER_WRITE, x, y, w, h);
     if (!transfer)
 	return FALSE;
@@ -237,7 +237,7 @@ ExaUploadToScreen(PixmapPtr pPix, int x, int y, int w, int h, char *src,
 		   (unsigned char*)src, src_pitch, 0, 0);
 
     exa->pipe->transfer_unmap(exa->pipe, transfer);
-    exa->pipe->tex_transfer_destroy(exa->pipe, transfer);
+    exa->pipe->transfer_destroy(exa->pipe, transfer);
 
     return TRUE;
 }
@@ -265,7 +265,7 @@ ExaPrepareAccess(PixmapPtr pPix, int index)
         assert(pPix->drawable.height <= priv->tex->height0);
 
 	priv->map_transfer =
-	    exa->pipe->get_tex_transfer(exa->pipe, priv->tex, 0, 0, 0,
+	   pipe_get_transfer(exa->pipe, priv->tex, 0, 0, 0,
 #ifdef EXA_MIXED_PIXMAPS
 					PIPE_TRANSFER_MAP_DIRECTLY |
 #endif
@@ -309,7 +309,7 @@ ExaFinishAccess(PixmapPtr pPix, int index)
     if (--priv->map_count == 0) {
 	assert(priv->map_transfer);
 	exa->pipe->transfer_unmap(exa->pipe, priv->map_transfer);
-	exa->pipe->tex_transfer_destroy(exa->pipe, priv->map_transfer);
+	exa->pipe->transfer_destroy(exa->pipe, priv->map_transfer);
 	priv->map_transfer = NULL;
 	pPix->devPrivate.ptr = NULL;
     }
@@ -347,7 +347,7 @@ ExaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg)
 
     if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
                                         priv->tex->target,
-                                        PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
+                                        PIPE_BIND_RENDER_TARGET, 0)) {
 	XORG_FALLBACK("format %s", util_format_name(priv->tex->format));
     }
 
@@ -428,12 +428,12 @@ ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir,
 
     if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
                                         priv->tex->target,
-                                        PIPE_TEXTURE_USAGE_RENDER_TARGET, 0))
+                                        PIPE_BIND_RENDER_TARGET, 0))
 	XORG_FALLBACK("pDst format %s", util_format_name(priv->tex->format));
 
     if (!exa->scrn->is_format_supported(exa->scrn, src_priv->tex->format,
                                         src_priv->tex->target,
-                                        PIPE_TEXTURE_USAGE_SAMPLER, 0))
+                                        PIPE_BIND_SAMPLER_VIEW, 0))
 	XORG_FALLBACK("pSrc format %s", util_format_name(src_priv->tex->format));
 
     exa->copy.src = src_priv;
@@ -453,13 +453,13 @@ ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir,
           exa->scrn->get_tex_surface( exa->scrn,
                                       exa->copy.src->tex,
                                       0, 0, 0,
-                                      PIPE_BUFFER_USAGE_GPU_READ);
+                                      PIPE_BIND_BLIT_SOURCE);
 
        exa->copy.dst_surface =
           exa->scrn->get_tex_surface( exa->scrn, 
                                       exa->copy.dst->tex,
                                       0, 0, 0, 
-                                      PIPE_BUFFER_USAGE_GPU_WRITE );
+                                      PIPE_BIND_BLIT_DESTINATION );
     }
     else {
        exa->copy.use_surface_copy = FALSE;
@@ -468,14 +468,14 @@ ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir,
           exa->copy.src_texture = renderer_clone_texture( exa->renderer,
                                                           exa->copy.src->tex );
        else
-          pipe_texture_reference(&exa->copy.src_texture,
+          pipe_resource_reference(&exa->copy.src_texture,
                                  exa->copy.src->tex);
 
        exa->copy.dst_surface =
           exa->scrn->get_tex_surface(exa->scrn,
                                      exa->copy.dst->tex,
                                      0, 0, 0,
-                                     PIPE_BUFFER_USAGE_GPU_WRITE);
+                                     PIPE_BIND_BLIT_DESTINATION);
 
 
        renderer_copy_prepare(exa->renderer, 
@@ -541,7 +541,7 @@ ExaDoneCopy(PixmapPtr pPixmap)
    exa->copy.dst = NULL;
    pipe_surface_reference(&exa->copy.src_surface, NULL);
    pipe_surface_reference(&exa->copy.dst_surface, NULL);
-   pipe_texture_reference(&exa->copy.src_texture, NULL);
+   pipe_resource_reference(&exa->copy.src_texture, NULL);
 }
 
 
@@ -639,7 +639,7 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture,
 
    if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
                                        priv->tex->target,
-                                       PIPE_TEXTURE_USAGE_RENDER_TARGET, 0))
+                                       PIPE_BIND_RENDER_TARGET, 0))
       XORG_FALLBACK("pDst format: %s", util_format_name(priv->tex->format));
 
    if (priv->picture_format != pDstPicture->format)
@@ -654,7 +654,7 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture,
 
       if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
                                           priv->tex->target,
-                                          PIPE_TEXTURE_USAGE_SAMPLER, 0))
+                                          PIPE_BIND_SAMPLER_VIEW, 0))
          XORG_FALLBACK("pSrc format: %s", util_format_name(priv->tex->format));
 
       if (!picture_check_formats(priv, pSrcPicture))
@@ -671,7 +671,7 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture,
 
       if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
                                           priv->tex->target,
-                                          PIPE_TEXTURE_USAGE_SAMPLER, 0))
+                                          PIPE_BIND_SAMPLER_VIEW, 0))
          XORG_FALLBACK("pMask format: %s", util_format_name(priv->tex->format));
 
       if (!picture_check_formats(priv, pMaskPicture))
@@ -744,7 +744,7 @@ ExaDestroyPixmap(ScreenPtr pScreen, void *dPriv)
     if (!priv)
 	return;
 
-    pipe_texture_reference(&priv->tex, NULL);
+    pipe_resource_reference(&priv->tex, NULL);
 
     xfree(priv);
 }
@@ -776,7 +776,7 @@ xorg_exa_set_displayed_usage(PixmapPtr pPixmap)
 	return 0;
     }
 
-    priv->flags |= PIPE_TEXTURE_USAGE_SCANOUT;
+    priv->flags |= PIPE_BIND_SCANOUT;
 
     return 0;
 }
@@ -792,7 +792,7 @@ xorg_exa_set_shared_usage(PixmapPtr pPixmap)
 	return 0;
     }
 
-    priv->flags |= PIPE_TEXTURE_USAGE_SHARED;
+    priv->flags |= PIPE_BIND_SHARED;
 
     return 0;
 }
@@ -867,8 +867,8 @@ ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
          !size_match(width, priv->tex->width0) ||
          !size_match(height, priv->tex->height0) ||
          priv->tex_flags != priv->flags)) {
-	struct pipe_texture *texture = NULL;
-	struct pipe_texture template;
+	struct pipe_resource *texture = NULL;
+	struct pipe_resource template;
 
 	memset(&template, 0, sizeof(template));
 	template.target = PIPE_TEXTURE_2D;
@@ -884,16 +884,16 @@ ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
 
 	template.depth0 = 1;
 	template.last_level = 0;
-	template.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET | priv->flags;
+	template.bind = PIPE_BIND_RENDER_TARGET | priv->flags;
 	priv->tex_flags = priv->flags;
-	texture = exa->scrn->texture_create(exa->scrn, &template);
+	texture = exa->scrn->resource_create(exa->scrn, &template);
 
 	if (priv->tex) {
 	    struct pipe_surface *dst_surf;
 	    struct pipe_surface *src_surf;
 
 	    dst_surf = exa->scrn->get_tex_surface(
-		exa->scrn, texture, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
+		exa->scrn, texture, 0, 0, 0, PIPE_BIND_BLIT_DESTINATION);
 	    src_surf = xorg_gpu_surface(exa->pipe->screen, priv);
             if (exa->pipe->surface_copy) {
                exa->pipe->surface_copy(exa->pipe, dst_surf, 0, 0, src_surf,
@@ -908,29 +908,29 @@ ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
 	    exa->scrn->tex_surface_destroy(src_surf);
 	}
 
-	pipe_texture_reference(&priv->tex, texture);
+	pipe_resource_reference(&priv->tex, texture);
 	/* the texture we create has one reference */
-	pipe_texture_reference(&texture, NULL);
+	pipe_resource_reference(&texture, NULL);
     }
 
     return TRUE;
 }
 
-struct pipe_texture *
+struct pipe_resource *
 xorg_exa_get_texture(PixmapPtr pPixmap)
 {
    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
-   struct pipe_texture *tex = NULL;
-   pipe_texture_reference(&tex, priv->tex);
+   struct pipe_resource *tex = NULL;
+   pipe_resource_reference(&tex, priv->tex);
    return tex;
 }
 
 Bool
-xorg_exa_set_texture(PixmapPtr pPixmap, struct  pipe_texture *tex)
+xorg_exa_set_texture(PixmapPtr pPixmap, struct  pipe_resource *tex)
 {
     struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
 
-    int mask = PIPE_TEXTURE_USAGE_SHARED | PIPE_TEXTURE_USAGE_SCANOUT;
+    int mask = PIPE_BIND_SHARED | PIPE_BIND_SCANOUT;
 
     if (!priv)
 	return FALSE;
@@ -939,20 +939,20 @@ xorg_exa_set_texture(PixmapPtr pPixmap, struct  pipe_texture *tex)
 	pPixmap->drawable.height != tex->height0)
 	return FALSE;
 
-    pipe_texture_reference(&priv->tex, tex);
-    priv->tex_flags = tex->tex_usage & mask;
+    pipe_resource_reference(&priv->tex, tex);
+    priv->tex_flags = tex->bind & mask;
 
     return TRUE;
 }
 
-struct pipe_texture *
+struct pipe_resource *
 xorg_exa_create_root_texture(ScrnInfoPtr pScrn,
 			     int width, int height,
 			     int depth, int bitsPerPixel)
 {
     modesettingPtr ms = modesettingPTR(pScrn);
     struct exa_context *exa = ms->exa;
-    struct pipe_texture template;
+    struct pipe_resource template;
     int dummy;
 
     memset(&template, 0, sizeof(template));
@@ -962,11 +962,11 @@ xorg_exa_create_root_texture(ScrnInfoPtr pScrn,
     template.height0 = height;
     template.depth0 = 1;
     template.last_level = 0;
-    template.tex_usage |= PIPE_TEXTURE_USAGE_RENDER_TARGET;
-    template.tex_usage |= PIPE_TEXTURE_USAGE_SCANOUT;
-    template.tex_usage |= PIPE_TEXTURE_USAGE_SHARED;
+    template.bind |= PIPE_BIND_RENDER_TARGET;
+    template.bind |= PIPE_BIND_SCANOUT;
+    template.bind |= PIPE_BIND_SHARED;
 
-    return exa->scrn->texture_create(exa->scrn, &template);
+    return exa->scrn->resource_create(exa->scrn, &template);
 }
 
 void
@@ -1073,9 +1073,12 @@ out_err:
 struct pipe_surface *
 xorg_gpu_surface(struct pipe_screen *scrn, struct exa_pixmap_priv *priv)
 {
+   
+   /* seems to get called both for blits and render target usage */
    return scrn->get_tex_surface(scrn, priv->tex, 0, 0, 0,
-                                PIPE_BUFFER_USAGE_GPU_READ |
-                                PIPE_BUFFER_USAGE_GPU_WRITE);
+                                PIPE_BIND_BLIT_SOURCE |
+                                PIPE_BIND_BLIT_DESTINATION |
+                                PIPE_BIND_RENDER_TARGET);
 
 }
 
diff --git a/src/gallium/state_trackers/xorg/xorg_exa.h b/src/gallium/state_trackers/xorg/xorg_exa.h
index 41b19061599..a35e9a5c901 100644
--- a/src/gallium/state_trackers/xorg/xorg_exa.h
+++ b/src/gallium/state_trackers/xorg/xorg_exa.h
@@ -43,7 +43,7 @@ struct exa_context
       struct pipe_surface *src_surface;
       struct pipe_surface *dst_surface;
 
-      struct pipe_texture *src_texture;
+      struct pipe_resource *src_texture;
    } copy;
 };
 
@@ -56,8 +56,8 @@ struct exa_pixmap_priv
 
    int picture_format;
 
-   struct pipe_texture *tex;
-   struct pipe_texture *depth_stencil_tex;
+   struct pipe_resource *tex;
+   struct pipe_resource *depth_stencil_tex;
 
    struct pipe_transfer *map_transfer;
    unsigned map_count;
diff --git a/src/gallium/state_trackers/xorg/xorg_renderer.c b/src/gallium/state_trackers/xorg/xorg_renderer.c
index 81b0dcf656f..13fa561390f 100644
--- a/src/gallium/state_trackers/xorg/xorg_renderer.c
+++ b/src/gallium/state_trackers/xorg/xorg_renderer.c
@@ -42,14 +42,16 @@ static INLINE void map_point(float *mat, float x, float y,
    }
 }
 
-static INLINE struct pipe_buffer *
+static INLINE struct pipe_resource *
 renderer_buffer_create(struct xorg_renderer *r)
 {
-   struct pipe_buffer *buf =
+   struct pipe_resource *buf =
       pipe_user_buffer_create(r->pipe->screen,
                               r->buffer,
                               sizeof(float)*
-                              r->buffer_size);
+                              r->buffer_size,
+/* XXX was: PIPE_BUFFER_USAGE_PIXEL/PIPE_BUFFER_USAGE_GPU_WRITE even though this is a vertex buffer??? */
+			      PIPE_BIND_VERTEX_BUFFER);
    r->buffer_size = 0;
 
    return buf;
@@ -59,7 +61,7 @@ static INLINE void
 renderer_draw(struct xorg_renderer *r)
 {
    struct pipe_context *pipe = r->pipe;
-   struct pipe_buffer *buf = 0;
+   struct pipe_resource *buf = 0;
    int num_verts = r->buffer_size/(r->attrs_per_vertex * NUM_COMPONENTS);
 
    if (!r->buffer_size)
@@ -76,7 +78,7 @@ renderer_draw(struct xorg_renderer *r)
                               num_verts,  /* verts */
                               r->attrs_per_vertex); /* attribs/vert */
 
-      pipe_buffer_reference(&buf, NULL);
+      pipe_resource_reference(&buf, NULL);
    }
 }
 
@@ -161,7 +163,7 @@ static void
 add_vertex_data1(struct xorg_renderer *r,
                  float srcX, float srcY,  float dstX, float dstY,
                  float width, float height,
-                 struct pipe_texture *src, float *src_matrix)
+                 struct pipe_resource *src, float *src_matrix)
 {
    float s0, t0, s1, t1, s2, t2, s3, t3;
    float pt0[2], pt1[2], pt2[2], pt3[2];
@@ -231,8 +233,8 @@ static void
 add_vertex_data2(struct xorg_renderer *r,
                  float srcX, float srcY, float maskX, float maskY,
                  float dstX, float dstY, float width, float height,
-                 struct pipe_texture *src,
-                 struct pipe_texture *mask,
+                 struct pipe_resource *src,
+                 struct pipe_resource *mask,
                  float *src_matrix, float *mask_matrix)
 {
    float src_s0, src_t0, src_s1, src_t1;
@@ -284,11 +286,11 @@ add_vertex_data2(struct xorg_renderer *r,
                    src_s0, src_t1, mask_s0, mask_t1);
 }
 
-static struct pipe_buffer *
+static struct pipe_resource *
 setup_vertex_data_yuv(struct xorg_renderer *r,
                       float srcX, float srcY, float srcW, float srcH,
                       float dstX, float dstY, float dstW, float dstH,
-                      struct pipe_texture **tex)
+                      struct pipe_resource **tex)
 {
    float s0, t0, s1, t1;
    float spt0[2], spt1[2];
@@ -390,14 +392,14 @@ struct xorg_renderer * renderer_create(struct pipe_context *pipe)
 
 void renderer_destroy(struct xorg_renderer *r)
 {
-   struct pipe_buffer **vsbuf = &r->vs_const_buffer;
-   struct pipe_buffer **fsbuf = &r->fs_const_buffer;
+   struct pipe_resource **vsbuf = &r->vs_const_buffer;
+   struct pipe_resource **fsbuf = &r->fs_const_buffer;
 
    if (*vsbuf)
-      pipe_buffer_reference(vsbuf, NULL);
+      pipe_resource_reference(vsbuf, NULL);
 
    if (*fsbuf)
-      pipe_buffer_reference(fsbuf, NULL);
+      pipe_resource_reference(fsbuf, NULL);
 
    if (r->shaders) {
       xorg_shaders_destroy(r->shaders);
@@ -420,17 +422,17 @@ void renderer_set_constants(struct xorg_renderer *r,
                             const float *params,
                             int param_bytes)
 {
-   struct pipe_buffer **cbuf =
+   struct pipe_resource **cbuf =
       (shader_type == PIPE_SHADER_VERTEX) ? &r->vs_const_buffer :
       &r->fs_const_buffer;
 
-   pipe_buffer_reference(cbuf, NULL);
-   *cbuf = pipe_buffer_create(r->pipe->screen, 16,
-                              PIPE_BUFFER_USAGE_CONSTANT,
+   pipe_resource_reference(cbuf, NULL);
+   *cbuf = pipe_buffer_create(r->pipe->screen,
+                              PIPE_BIND_CONSTANT_BUFFER,
                               param_bytes);
 
    if (*cbuf) {
-      pipe_buffer_write(r->pipe->screen, *cbuf,
+      pipe_buffer_write(r->pipe, *cbuf,
                         0, param_bytes, params);
    }
    r->pipe->set_constant_buffer(r->pipe, shader_type, 0, *cbuf);
@@ -439,7 +441,7 @@ void renderer_set_constants(struct xorg_renderer *r,
 
 void renderer_copy_prepare(struct xorg_renderer *r,
                            struct pipe_surface *dst_surface,
-                           struct pipe_texture *src_texture)
+                           struct pipe_resource *src_texture)
 {
    struct pipe_context *pipe = r->pipe;
    struct pipe_screen *screen = pipe->screen;
@@ -447,7 +449,7 @@ void renderer_copy_prepare(struct xorg_renderer *r,
 
    assert(screen->is_format_supported(screen, dst_surface->format,
                                       PIPE_TEXTURE_2D,
-                                      PIPE_TEXTURE_USAGE_RENDER_TARGET,
+                                      PIPE_BIND_RENDER_TARGET,
                                       0));
    (void) screen;
 
@@ -506,24 +508,24 @@ void renderer_copy_prepare(struct xorg_renderer *r,
    r->attrs_per_vertex = 2;
 }
 
-struct pipe_texture *
+struct pipe_resource *
 renderer_clone_texture(struct xorg_renderer *r,
-                       struct pipe_texture *src)
+                       struct pipe_resource *src)
 {
    enum pipe_format format;
    struct pipe_context *pipe = r->pipe;
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_texture *pt;
-   struct pipe_texture templ;
+   struct pipe_resource *pt;
+   struct pipe_resource templ;
 
-   if (pipe->is_texture_referenced(pipe, src, 0, 0) &
+   if (pipe->is_resource_referenced(pipe, src, 0, 0) &
        PIPE_REFERENCED_FOR_WRITE)
       pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
 
    /* the coming in texture should already have that invariance */
    debug_assert(screen->is_format_supported(screen, src->format,
                                             PIPE_TEXTURE_2D,
-                                            PIPE_TEXTURE_USAGE_SAMPLER, 0));
+                                            PIPE_BIND_SAMPLER_VIEW, 0));
 
    format = src->format;
 
@@ -534,9 +536,9 @@ renderer_clone_texture(struct xorg_renderer *r,
    templ.width0 = src->width0;
    templ.height0 = src->height0;
    templ.depth0 = 1;
-   templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
+   templ.bind = PIPE_BIND_SAMPLER_VIEW;
 
-   pt = screen->texture_create(screen, &templ);
+   pt = screen->resource_create(screen, &templ);
 
    debug_assert(!pt || pipe_is_referenced(&pt->reference));
 
@@ -546,9 +548,9 @@ renderer_clone_texture(struct xorg_renderer *r,
    {
       /* copy source framebuffer surface into texture */
       struct pipe_surface *ps_read = screen->get_tex_surface(
-         screen, src, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ);
+         screen, src, 0, 0, 0, PIPE_BIND_BLIT_SOURCE);
       struct pipe_surface *ps_tex = screen->get_tex_surface(
-         screen, pt, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE );
+         screen, pt, 0, 0, 0, PIPE_BIND_BLIT_DESTINATION );
       if (pipe->surface_copy) {
          pipe->surface_copy(pipe,
                 ps_tex, /* dest */
@@ -608,10 +610,10 @@ void renderer_copy_pixmap(struct xorg_renderer *r,
 void renderer_draw_yuv(struct xorg_renderer *r,
                        int src_x, int src_y, int src_w, int src_h,
                        int dst_x, int dst_y, int dst_w, int dst_h,
-                       struct pipe_texture **textures)
+                       struct pipe_resource **textures)
 {
    struct pipe_context *pipe = r->pipe;
-   struct pipe_buffer *buf = 0;
+   struct pipe_resource *buf = 0;
 
    buf = setup_vertex_data_yuv(r,
                                src_x, src_y, src_w, src_h,
@@ -628,7 +630,7 @@ void renderer_draw_yuv(struct xorg_renderer *r,
                               4,  /* verts */
                               num_attribs); /* attribs/vert */
 
-      pipe_buffer_reference(&buf, NULL);
+      pipe_resource_reference(&buf, NULL);
    }
 }
 
diff --git a/src/gallium/state_trackers/xorg/xorg_renderer.h b/src/gallium/state_trackers/xorg/xorg_renderer.h
index cc5802e79b2..0454a6513d4 100644
--- a/src/gallium/state_trackers/xorg/xorg_renderer.h
+++ b/src/gallium/state_trackers/xorg/xorg_renderer.h
@@ -23,8 +23,8 @@ struct xorg_renderer {
 
    int fb_width;
    int fb_height;
-   struct pipe_buffer *vs_const_buffer;
-   struct pipe_buffer *fs_const_buffer;
+   struct pipe_resource *vs_const_buffer;
+   struct pipe_resource *fs_const_buffer;
 
    float buffer[BUF_SIZE];
    int buffer_size;
@@ -56,7 +56,7 @@ void renderer_set_constants(struct xorg_renderer *r,
 void renderer_draw_yuv(struct xorg_renderer *r,
                        int src_x, int src_y, int src_w, int src_h,
                        int dst_x, int dst_y, int dst_w, int dst_h,
-                       struct pipe_texture **textures);
+                       struct pipe_resource **textures);
 
 void renderer_begin_solid(struct xorg_renderer *r);
 void renderer_solid(struct xorg_renderer *r,
@@ -77,13 +77,13 @@ void renderer_texture(struct xorg_renderer *r,
 
 void renderer_draw_flush(struct xorg_renderer *r);
 
-struct pipe_texture *
+struct pipe_resource *
 renderer_clone_texture(struct xorg_renderer *r,
-                       struct pipe_texture *src);
+                       struct pipe_resource *src);
 
 void renderer_copy_prepare(struct xorg_renderer *r,
                            struct pipe_surface *dst_surface,
-                           struct pipe_texture *src_texture);
+                           struct pipe_resource *src_texture);
 
 void renderer_copy_pixmap(struct xorg_renderer *r,
                           int dx, int dy,
diff --git a/src/gallium/state_trackers/xorg/xorg_tracker.h b/src/gallium/state_trackers/xorg/xorg_tracker.h
index c1884ebd115..cb6773424a8 100644
--- a/src/gallium/state_trackers/xorg/xorg_tracker.h
+++ b/src/gallium/state_trackers/xorg/xorg_tracker.h
@@ -118,7 +118,7 @@ typedef struct _modesettingRec
     struct pipe_context *ctx;
     boolean d_depth_bits_last;
     boolean ds_depth_bits_last;
-    struct pipe_texture *root_texture;
+    struct pipe_resource *root_texture;
 
     /* exa */
     struct exa_context *exa;
@@ -142,7 +142,7 @@ Bool xorg_has_gallium(ScrnInfoPtr pScrn);
 /***********************************************************************
  * xorg_exa.c
  */
-struct pipe_texture *
+struct pipe_resource *
 xorg_exa_get_texture(PixmapPtr pPixmap);
 
 int
@@ -152,9 +152,9 @@ int
 xorg_exa_set_shared_usage(PixmapPtr pPixmap);
 
 Bool
-xorg_exa_set_texture(PixmapPtr pPixmap, struct  pipe_texture *tex);
+xorg_exa_set_texture(PixmapPtr pPixmap, struct  pipe_resource *tex);
 
-struct pipe_texture *
+struct pipe_resource *
 xorg_exa_create_root_texture(ScrnInfoPtr pScrn,
 			     int width, int height,
 			     int depth, int bpp);
diff --git a/src/gallium/state_trackers/xorg/xorg_xv.c b/src/gallium/state_trackers/xorg/xorg_xv.c
index 5efda6837de..a221594454e 100644
--- a/src/gallium/state_trackers/xorg/xorg_xv.c
+++ b/src/gallium/state_trackers/xorg/xorg_xv.c
@@ -91,7 +91,7 @@ struct xorg_xv_port_priv {
    int current_set;
    /* juggle two sets of seperate Y, U and V
     * textures */
-   struct pipe_texture *yuv[2][3];
+   struct pipe_resource *yuv[2][3];
    struct pipe_sampler_view *yuv_views[2][3];
 };
 
@@ -156,13 +156,13 @@ query_best_size(ScrnInfoPtr pScrn,
    *p_h = drw_h;
 }
 
-static INLINE struct pipe_texture *
+static INLINE struct pipe_resource *
 create_component_texture(struct pipe_context *pipe,
                          int width, int height)
 {
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_texture *tex = 0;
-   struct pipe_texture templ;
+   struct pipe_resource *tex = 0;
+   struct pipe_resource templ;
 
    memset(&templ, 0, sizeof(templ));
    templ.target = PIPE_TEXTURE_2D;
@@ -171,9 +171,9 @@ create_component_texture(struct pipe_context *pipe,
    templ.width0 = width;
    templ.height0 = height;
    templ.depth0 = 1;
-   templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
+   templ.bind = PIPE_BIND_SAMPLER_VIEW;
 
-   tex = screen->texture_create(screen, &templ);
+   tex = screen->resource_create(screen, &templ);
 
    return tex;
 }
@@ -181,7 +181,7 @@ create_component_texture(struct pipe_context *pipe,
 static int
 check_yuv_textures(struct xorg_xv_port_priv *priv,  int width, int height)
 {
-   struct pipe_texture **dst = priv->yuv[priv->current_set];
+   struct pipe_resource **dst = priv->yuv[priv->current_set];
    struct pipe_sampler_view **dst_view = priv->yuv_views[priv->current_set];
    struct pipe_sampler_view view_templ;
    struct pipe_context *pipe = priv->r->pipe;
@@ -189,19 +189,19 @@ check_yuv_textures(struct xorg_xv_port_priv *priv,  int width, int height)
    if (!dst[0] ||
        dst[0]->width0 != width ||
        dst[0]->height0 != height) {
-      pipe_texture_reference(&dst[0], NULL);
+      pipe_resource_reference(&dst[0], NULL);
       pipe_sampler_view_reference(&dst_view[0], NULL);
    }
    if (!dst[1] ||
        dst[1]->width0 != width ||
        dst[1]->height0 != height) {
-      pipe_texture_reference(&dst[1], NULL);
+      pipe_resource_reference(&dst[1], NULL);
       pipe_sampler_view_reference(&dst_view[1], NULL);
    }
    if (!dst[2] ||
        dst[2]->width0 != width ||
        dst[2]->height0 != height) {
-      pipe_texture_reference(&dst[2], NULL);
+      pipe_resource_reference(&dst[2], NULL);
       pipe_sampler_view_reference(&dst_view[2], NULL);
    }
 
@@ -303,7 +303,7 @@ copy_packed_data(ScrnInfoPtr pScrn,
                  unsigned short w, unsigned short h)
 {
    int i, j;
-   struct pipe_texture **dst = port->yuv[port->current_set];
+   struct pipe_resource **dst = port->yuv[port->current_set];
    struct pipe_transfer *ytrans, *utrans, *vtrans;
    struct pipe_context *pipe = port->r->pipe;
    char *ymap, *vmap, *umap;
@@ -311,15 +311,15 @@ copy_packed_data(ScrnInfoPtr pScrn,
    int yidx, uidx, vidx;
    int y_array_size = w * h;
 
-   ytrans = pipe->get_tex_transfer(pipe, dst[0],
+   ytrans = pipe_get_transfer(pipe, dst[0],
                                    0, 0, 0,
                                    PIPE_TRANSFER_WRITE,
                                    left, top, w, h);
-   utrans = pipe->get_tex_transfer(pipe, dst[1],
+   utrans = pipe_get_transfer(pipe, dst[1],
                                    0, 0, 0,
                                    PIPE_TRANSFER_WRITE,
                                    left, top, w, h);
-   vtrans = pipe->get_tex_transfer(pipe, dst[2],
+   vtrans = pipe_get_transfer(pipe, dst[2],
                                    0, 0, 0,
                                    PIPE_TRANSFER_WRITE,
                                    left, top, w, h);
@@ -395,9 +395,9 @@ copy_packed_data(ScrnInfoPtr pScrn,
    pipe->transfer_unmap(pipe, ytrans);
    pipe->transfer_unmap(pipe, utrans);
    pipe->transfer_unmap(pipe, vtrans);
-   pipe->tex_transfer_destroy(pipe, ytrans);
-   pipe->tex_transfer_destroy(pipe, utrans);
-   pipe->tex_transfer_destroy(pipe, vtrans);
+   pipe->transfer_destroy(pipe, ytrans);
+   pipe->transfer_destroy(pipe, utrans);
+   pipe->transfer_destroy(pipe, vtrans);
 }
 
 
@@ -416,7 +416,7 @@ draw_yuv(struct xorg_xv_port_priv *port,
          int src_x, int src_y, int src_w, int src_h,
          int dst_x, int dst_y, int dst_w, int dst_h)
 {
-   struct pipe_texture **textures = port->yuv[port->current_set];
+   struct pipe_resource **textures = port->yuv[port->current_set];
 
    /*debug_printf("  draw_yuv([%d, %d, %d ,%d], [%d, %d, %d, %d])\n",
                 src_x, src_y, src_w, src_h,
@@ -461,12 +461,12 @@ bind_shaders(struct xorg_xv_port_priv *port)
 }
 
 static INLINE void
-conditional_flush(struct pipe_context *pipe, struct pipe_texture **tex,
+conditional_flush(struct pipe_context *pipe, struct pipe_resource **tex,
                   int num)
 {
    int i;
    for (i = 0; i < num; ++i) {
-      if (tex[i] && pipe->is_texture_referenced(pipe, tex[i], 0, 0) &
+      if (tex[i] && pipe->is_resource_referenced(pipe, tex[i], 0, 0) &
           PIPE_REFERENCED_FOR_WRITE) {
          pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
          return;
@@ -479,7 +479,7 @@ bind_samplers(struct xorg_xv_port_priv *port)
 {
    struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS];
    struct pipe_sampler_state sampler;
-   struct pipe_texture **dst = port->yuv[port->current_set];
+   struct pipe_resource **dst = port->yuv[port->current_set];
    struct pipe_sampler_view **dst_views = port->yuv_views[port->current_set];
 
    memset(&sampler, 0, sizeof(struct pipe_sampler_state));
diff --git a/src/gallium/state_trackers/xorg/xvmc/Makefile b/src/gallium/state_trackers/xorg/xvmc/Makefile
deleted file mode 100644
index 126dc6d58f1..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/Makefile
+++ /dev/null
@@ -1,16 +0,0 @@
-TOP = ../../../../..
-include $(TOP)/configs/current
-
-LIBNAME = xvmctracker
-
-LIBRARY_INCLUDES = \
-	$(shell pkg-config --cflags-only-I xvmc) \
-	-I$(TOP)/src/gallium/winsys/g3dvl
-
-C_SOURCES = block.c \
-            surface.c \
-            context.c \
-            subpicture.c \
-            attributes.c
-
-include ../../../Makefile.template
diff --git a/src/gallium/state_trackers/xorg/xvmc/SConscript b/src/gallium/state_trackers/xorg/xvmc/SConscript
deleted file mode 100644
index cb25d68bd80..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/SConscript
+++ /dev/null
@@ -1,27 +0,0 @@
-#######################################################################
-# SConscript for xvmc state_tracker
-
-Import('*')
-
-if 'xorg/xvmc' in env['statetrackers']:
-
-    env = env.Clone()
-    
-    env.Append(CPPPATH = [
-	'#/src/gallium/include',
-	'#/src/gallium/auxiliary',
-	'#/src/gallium/winsys/g3dvl',
-    ])
-
-    env.ParseConfig('pkg-config --cflags --libs xvmc')
-
-    st_xvmc = env.ConvenienceLibrary(
-	target = 'st_xvmc',
-	source = [ 'block.c',
-		'surface.c',
-		'context.c',
-		'subpicture.c',
-		'attributes.c',
-		]
-    )
-    Export('st_xvmc')
diff --git a/src/gallium/state_trackers/xorg/xvmc/block.c b/src/gallium/state_trackers/xorg/xvmc/block.c
deleted file mode 100644
index 5102375fcf8..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/block.c
+++ /dev/null
@@ -1,88 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include <assert.h>
-#include <X11/Xlib.h>
-#include <X11/extensions/XvMClib.h>
-#include <util/u_memory.h>
-#include "xvmc_private.h"
-
-Status XvMCCreateBlocks(Display *dpy, XvMCContext *context, unsigned int num_blocks, XvMCBlockArray *blocks)
-{
-   assert(dpy);
-
-   if (!context)
-      return XvMCBadContext;
-   if (num_blocks == 0)
-      return BadValue;
-
-   assert(blocks);
-
-   blocks->context_id = context->context_id;
-   blocks->num_blocks = num_blocks;
-   blocks->blocks = MALLOC(BLOCK_SIZE_BYTES * num_blocks);
-   blocks->privData = NULL;
-
-   return Success;
-}
-
-Status XvMCDestroyBlocks(Display *dpy, XvMCBlockArray *blocks)
-{
-   assert(dpy);
-   assert(blocks);
-   FREE(blocks->blocks);
-
-   return Success;
-}
-
-Status XvMCCreateMacroBlocks(Display *dpy, XvMCContext *context, unsigned int num_blocks, XvMCMacroBlockArray *blocks)
-{
-   assert(dpy);
-
-   if (!context)
-      return XvMCBadContext;
-   if (num_blocks == 0)
-      return BadValue;
-
-   assert(blocks);
-
-   blocks->context_id = context->context_id;
-   blocks->num_blocks = num_blocks;
-   blocks->macro_blocks = MALLOC(sizeof(XvMCMacroBlock) * num_blocks);
-   blocks->privData = NULL;
-
-   return Success;
-}
-
-Status XvMCDestroyMacroBlocks(Display *dpy, XvMCMacroBlockArray *blocks)
-{
-   assert(dpy);
-   assert(blocks);
-   FREE(blocks->macro_blocks);
-
-   return Success;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/context.c b/src/gallium/state_trackers/xorg/xvmc/context.c
deleted file mode 100644
index c8a389385a8..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/context.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include <assert.h>
-#include <X11/Xlibint.h>
-#include <X11/extensions/XvMClib.h>
-#include <pipe/p_screen.h>
-#include <pipe/p_video_context.h>
-#include <pipe/p_video_state.h>
-#include <pipe/p_state.h>
-#include <vl_winsys.h>
-#include <util/u_memory.h>
-#include <util/u_debug.h>
-#include <vl/vl_csc.h>
-#include "xvmc_private.h"
-
-static Status Validate(Display *dpy, XvPortID port, int surface_type_id,
-                       unsigned int width, unsigned int height, int flags,
-                       bool *found_port, int *screen, int *chroma_format,
-                       int *mc_type, int *surface_flags)
-{
-   bool found_surface = false;
-   XvAdaptorInfo *adaptor_info;
-   unsigned int num_adaptors;
-   int num_types;
-   unsigned int max_width, max_height;
-   Status ret;
-
-   assert(dpy);
-   assert(found_port);
-   assert(screen);
-   assert(chroma_format);
-   assert(mc_type);
-   assert(surface_flags);
-
-   *found_port = false;
-
-   for (unsigned int i = 0; i < XScreenCount(dpy); ++i) {
-      ret = XvQueryAdaptors(dpy, XRootWindow(dpy, i), &num_adaptors, &adaptor_info);
-      if (ret != Success)
-         return ret;
-
-      for (unsigned int j = 0; j < num_adaptors && !*found_port; ++j) {
-         for (unsigned int k = 0; k < adaptor_info[j].num_ports && !*found_port; ++k) {
-            XvMCSurfaceInfo *surface_info;
-
-            if (adaptor_info[j].base_id + k != port)
-               continue;
-
-            *found_port = true;
-
-            surface_info = XvMCListSurfaceTypes(dpy, adaptor_info[j].base_id, &num_types);
-            if (!surface_info) {
-               XvFreeAdaptorInfo(adaptor_info);
-               return BadAlloc;
-            }
-
-            for (unsigned int l = 0; l < num_types && !found_surface; ++l) {
-               if (surface_info[l].surface_type_id != surface_type_id)
-                  continue;
-
-               found_surface = true;
-               max_width = surface_info[l].max_width;
-               max_height = surface_info[l].max_height;
-               *chroma_format = surface_info[l].chroma_format;
-               *mc_type = surface_info[l].mc_type;
-               *surface_flags = surface_info[l].flags;
-               *screen = i;
-            }
-
-            XFree(surface_info);
-         }
-      }
-
-      XvFreeAdaptorInfo(adaptor_info);
-   }
-
-   if (!*found_port)
-      return XvBadPort;
-   if (!found_surface)
-      return BadMatch;
-   if (width > max_width || height > max_height)
-      return BadValue;
-   if (flags != XVMC_DIRECT && flags != 0)
-      return BadValue;
-
-   return Success;
-}
-
-static enum pipe_video_profile ProfileToPipe(int xvmc_profile)
-{
-   if (xvmc_profile & XVMC_MPEG_1)
-      assert(0);
-   if (xvmc_profile & XVMC_MPEG_2)
-      return PIPE_VIDEO_PROFILE_MPEG2_MAIN;
-   if (xvmc_profile & XVMC_H263)
-      assert(0);
-   if (xvmc_profile & XVMC_MPEG_4)
-      assert(0);
-	
-   assert(0);
-
-   return -1;
-}
-
-static enum pipe_video_chroma_format FormatToPipe(int xvmc_format)
-{
-   switch (xvmc_format) {
-      case XVMC_CHROMA_FORMAT_420:
-         return PIPE_VIDEO_CHROMA_FORMAT_420;
-      case XVMC_CHROMA_FORMAT_422:
-         return PIPE_VIDEO_CHROMA_FORMAT_422;
-      case XVMC_CHROMA_FORMAT_444:
-         return PIPE_VIDEO_CHROMA_FORMAT_444;
-      default:
-         assert(0);
-   }
-
-   return -1;
-}
-
-Status XvMCCreateContext(Display *dpy, XvPortID port, int surface_type_id,
-                         int width, int height, int flags, XvMCContext *context)
-{
-   bool found_port;
-   int scrn;
-   int chroma_format;
-   int mc_type;
-   int surface_flags;
-   Status ret;
-   struct pipe_screen *screen;
-   struct pipe_video_context *vpipe;
-   XvMCContextPrivate *context_priv;
-   float csc[16];
-
-   assert(dpy);
-
-   if (!context)
-      return XvMCBadContext;
-
-   ret = Validate(dpy, port, surface_type_id, width, height, flags,
-                  &found_port, &scrn, &chroma_format, &mc_type, &surface_flags);
-
-   /* Success and XvBadPort have the same value */
-   if (ret != Success || !found_port)
-      return ret;
-
-   /* XXX: Current limits */
-   if (chroma_format != XVMC_CHROMA_FORMAT_420) {
-      debug_printf("[XvMCg3dvl] Cannot decode requested surface type. Unsupported chroma format.\n");
-      return BadImplementation;
-   }
-   if (mc_type != (XVMC_MOCOMP | XVMC_MPEG_2)) {
-      debug_printf("[XvMCg3dvl] Cannot decode requested surface type. Non-MPEG2/Mocomp acceleration unsupported.\n");
-      return BadImplementation;
-   }
-   if (!(surface_flags & XVMC_INTRA_UNSIGNED)) {
-      debug_printf("[XvMCg3dvl] Cannot decode requested surface type. Signed intra unsupported.\n");
-      return BadImplementation;
-   }
-
-   context_priv = CALLOC(1, sizeof(XvMCContextPrivate));
-   if (!context_priv)
-      return BadAlloc;
-
-   /* TODO: Reuse screen if process creates another context */
-   screen = vl_screen_create(dpy, scrn);
-
-   if (!screen) {
-      FREE(context_priv);
-      return BadAlloc;
-   }
-
-   vpipe = vl_video_create(dpy, scrn, screen, ProfileToPipe(mc_type),
-                           FormatToPipe(chroma_format), width, height);
-
-   if (!vpipe) {
-      screen->destroy(screen);
-      FREE(context_priv);
-      return BadAlloc;
-   }
-
-   /* TODO: Define some Xv attribs to allow users to specify color standard, procamp */
-   vl_csc_get_matrix
-   (
-      debug_get_bool_option("G3DVL_NO_CSC", FALSE) ?
-      VL_CSC_COLOR_STANDARD_IDENTITY : VL_CSC_COLOR_STANDARD_BT_601,
-      NULL, true, csc
-   );
-   vpipe->set_csc_matrix(vpipe, csc);
-
-   context_priv->vpipe = vpipe;
-
-   context->context_id = XAllocID(dpy);
-   context->surface_type_id = surface_type_id;
-   context->width = width;
-   context->height = height;
-   context->flags = flags;
-   context->port = port;
-   context->privData = context_priv;
-	
-   SyncHandle();
-
-   return Success;
-}
-
-Status XvMCDestroyContext(Display *dpy, XvMCContext *context)
-{
-   struct pipe_screen *screen;
-   struct pipe_video_context *vpipe;
-   XvMCContextPrivate *context_priv;
-
-   assert(dpy);
-
-   if (!context || !context->privData)
-      return XvMCBadContext;
-
-   context_priv = context->privData;
-   vpipe = context_priv->vpipe;
-   pipe_surface_reference(&context_priv->backbuffer, NULL);
-   screen = vpipe->screen;
-   vpipe->destroy(vpipe);
-   screen->destroy(screen);
-   FREE(context_priv);
-   context->privData = NULL;
-
-   return Success;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/subpicture.c b/src/gallium/state_trackers/xorg/xvmc/subpicture.c
deleted file mode 100644
index 69898d5fcd3..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/subpicture.c
+++ /dev/null
@@ -1,195 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include <assert.h>
-#include <X11/Xlibint.h>
-#include <X11/extensions/XvMClib.h>
-
-Status XvMCCreateSubpicture(Display *dpy, XvMCContext *context, XvMCSubpicture *subpicture,
-                            unsigned short width, unsigned short height, int xvimage_id)
-{
-   assert(dpy);
-
-   if (!context)
-      return XvMCBadContext;
-
-   assert(subpicture);
-
-   /*if (width > || height > )
-      return BadValue;*/
-
-   /*if (xvimage_id != )
-      return BadMatch;*/
-
-   subpicture->subpicture_id = XAllocID(dpy);
-   subpicture->context_id = context->context_id;
-   subpicture->xvimage_id = xvimage_id;
-   subpicture->width = width;
-   subpicture->height = height;
-   subpicture->num_palette_entries = 0;
-   subpicture->entry_bytes = 0;
-   subpicture->component_order[0] = 0;
-   subpicture->component_order[1] = 0;
-   subpicture->component_order[2] = 0;
-   subpicture->component_order[3] = 0;
-   /* TODO: subpicture->privData = ;*/
-
-   SyncHandle();
-
-   return Success;
-}
-
-Status XvMCClearSubpicture(Display *dpy, XvMCSubpicture *subpicture, short x, short y,
-                           unsigned short width, unsigned short height, unsigned int color)
-{
-   assert(dpy);
-
-   if (!subpicture)
-      return XvMCBadSubpicture;
-
-   /* TODO: Assert clear rect is within bounds? Or clip? */
-
-   return Success;
-}
-
-Status XvMCCompositeSubpicture(Display *dpy, XvMCSubpicture *subpicture, XvImage *image,
-                               short srcx, short srcy, unsigned short width, unsigned short height,
-                               short dstx, short dsty)
-{
-   assert(dpy);
-
-   if (!subpicture)
-      return XvMCBadSubpicture;
-
-   assert(image);
-
-   if (subpicture->xvimage_id != image->id)
-      return BadMatch;
-
-   /* TODO: Assert rects are within bounds? Or clip? */
-
-   return Success;
-}
-
-Status XvMCDestroySubpicture(Display *dpy, XvMCSubpicture *subpicture)
-{
-   assert(dpy);
-
-   if (!subpicture)
-      return XvMCBadSubpicture;
-
-   return BadImplementation;
-}
-
-Status XvMCSetSubpicturePalette(Display *dpy, XvMCSubpicture *subpicture, unsigned char *palette)
-{
-   assert(dpy);
-
-   if (!subpicture)
-      return XvMCBadSubpicture;
-
-   assert(palette);
-
-   /* We don't support paletted subpictures */
-   return BadMatch;
-}
-
-Status XvMCBlendSubpicture(Display *dpy, XvMCSurface *target_surface, XvMCSubpicture *subpicture,
-                           short subx, short suby, unsigned short subw, unsigned short subh,
-                           short surfx, short surfy, unsigned short surfw, unsigned short surfh)
-{
-   assert(dpy);
-
-   if (!target_surface)
-      return XvMCBadSurface;
-
-   if (!subpicture)
-      return XvMCBadSubpicture;
-
-   if (target_surface->context_id != subpicture->context_id)
-      return BadMatch;
-
-   /* TODO: Assert rects are within bounds? Or clip? */
-   return Success;
-}
-
-Status XvMCBlendSubpicture2(Display *dpy, XvMCSurface *source_surface, XvMCSurface *target_surface,
-                            XvMCSubpicture *subpicture, short subx, short suby, unsigned short subw, unsigned short subh,
-                            short surfx, short surfy, unsigned short surfw, unsigned short surfh)
-{
-   assert(dpy);
-
-   if (!source_surface || !target_surface)
-      return XvMCBadSurface;
-
-   if (!subpicture)
-      return XvMCBadSubpicture;
-
-   if (source_surface->context_id != subpicture->context_id)
-      return BadMatch;
-
-   if (source_surface->context_id != subpicture->context_id)
-      return BadMatch;
-
-   /* TODO: Assert rects are within bounds? Or clip? */
-   return Success;
-}
-
-Status XvMCSyncSubpicture(Display *dpy, XvMCSubpicture *subpicture)
-{
-   assert(dpy);
-
-   if (!subpicture)
-      return XvMCBadSubpicture;
-
-   return Success;
-}
-
-Status XvMCFlushSubpicture(Display *dpy, XvMCSubpicture *subpicture)
-{
-   assert(dpy);
-
-   if (!subpicture)
-      return XvMCBadSubpicture;
-
-   return Success;
-}
-
-Status XvMCGetSubpictureStatus(Display *dpy, XvMCSubpicture *subpicture, int *status)
-{
-   assert(dpy);
-
-   if (!subpicture)
-      return XvMCBadSubpicture;
-
-   assert(status);
-
-   /* TODO */
-   *status = 0;
-
-   return Success;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/surface.c b/src/gallium/state_trackers/xorg/xvmc/surface.c
deleted file mode 100644
index 12d94e0c5ca..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/surface.c
+++ /dev/null
@@ -1,408 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2009 Younes Manton.
- * 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.
- *
- **************************************************************************/
-
-#include <assert.h>
-#include <X11/Xlibint.h>
-#include <pipe/p_video_context.h>
-#include <pipe/p_video_state.h>
-#include <pipe/p_state.h>
-#include <util/u_memory.h>
-#include "xvmc_private.h"
-
-static enum pipe_mpeg12_macroblock_type TypeToPipe(int xvmc_mb_type)
-{
-   if (xvmc_mb_type & XVMC_MB_TYPE_INTRA)
-      return PIPE_MPEG12_MACROBLOCK_TYPE_INTRA;
-   if ((xvmc_mb_type & (XVMC_MB_TYPE_MOTION_FORWARD | XVMC_MB_TYPE_MOTION_BACKWARD)) == XVMC_MB_TYPE_MOTION_FORWARD)
-      return PIPE_MPEG12_MACROBLOCK_TYPE_FWD;
-   if ((xvmc_mb_type & (XVMC_MB_TYPE_MOTION_FORWARD | XVMC_MB_TYPE_MOTION_BACKWARD)) == XVMC_MB_TYPE_MOTION_BACKWARD)
-      return PIPE_MPEG12_MACROBLOCK_TYPE_BKWD;
-   if ((xvmc_mb_type & (XVMC_MB_TYPE_MOTION_FORWARD | XVMC_MB_TYPE_MOTION_BACKWARD)) == (XVMC_MB_TYPE_MOTION_FORWARD | XVMC_MB_TYPE_MOTION_BACKWARD))
-      return PIPE_MPEG12_MACROBLOCK_TYPE_BI;
-
-   assert(0);
-
-   return -1;
-}
-
-static enum pipe_mpeg12_picture_type PictureToPipe(int xvmc_pic)
-{
-   switch (xvmc_pic) {
-      case XVMC_TOP_FIELD:
-         return PIPE_MPEG12_PICTURE_TYPE_FIELD_TOP;
-      case XVMC_BOTTOM_FIELD:
-         return PIPE_MPEG12_PICTURE_TYPE_FIELD_BOTTOM;
-      case XVMC_FRAME_PICTURE:
-         return PIPE_MPEG12_PICTURE_TYPE_FRAME;
-      default:
-         assert(0);
-   }
-
-   return -1;
-}
-
-static enum pipe_mpeg12_motion_type MotionToPipe(int xvmc_motion_type, int xvmc_dct_type)
-{
-   switch (xvmc_motion_type) {
-      case XVMC_PREDICTION_FRAME:
-         return xvmc_dct_type == XVMC_DCT_TYPE_FIELD ?
-            PIPE_MPEG12_MOTION_TYPE_16x8 : PIPE_MPEG12_MOTION_TYPE_FRAME;
-      case XVMC_PREDICTION_FIELD:
-         return PIPE_MPEG12_MOTION_TYPE_FIELD;
-      case XVMC_PREDICTION_DUAL_PRIME:
-         return PIPE_MPEG12_MOTION_TYPE_DUALPRIME;
-      default:
-         assert(0);
-   }
-
-   return -1;
-}
-
-static bool
-CreateOrResizeBackBuffer(struct pipe_video_context *vpipe, unsigned int width, unsigned int height,
-                         struct pipe_surface **backbuffer)
-{
-   struct pipe_texture template;
-   struct pipe_texture *tex;
-
-   assert(vpipe);
-
-   if (*backbuffer) {
-      if ((*backbuffer)->width != width || (*backbuffer)->height != height)
-         pipe_surface_reference(backbuffer, NULL);
-      else
-         return true;
-   }
-
-   memset(&template, 0, sizeof(struct pipe_texture));
-   template.target = PIPE_TEXTURE_2D;
-   /* XXX: Needs to match the drawable's format? */
-   template.format = PIPE_FORMAT_B8G8R8X8_UNORM;
-   template.last_level = 0;
-   template.width0 = width;
-   template.height0 = height;
-   template.depth0 = 1;
-   template.tex_usage = PIPE_TEXTURE_USAGE_SHARED;
-
-   tex = vpipe->screen->texture_create(vpipe->screen, &template);
-   if (!tex)
-      return false;
-
-   *backbuffer = vpipe->screen->get_tex_surface(vpipe->screen, tex, 0, 0, 0,
-                                                PIPE_BUFFER_USAGE_GPU_READ |
-                                                PIPE_BUFFER_USAGE_GPU_WRITE);
-   pipe_texture_reference(&tex, NULL);
-
-   if (!*backbuffer)
-      return false;
-
-   /* Clear the backbuffer in case the video doesn't cover the whole window */
-   /* FIXME: Need to clear every time a frame moves and leaves dirty rects */
-   vpipe->clear_surface(vpipe, 0, 0, width, height, 0, *backbuffer);
-
-   return true;
-}
-
-static void
-MacroBlocksToPipe(const XvMCMacroBlockArray *xvmc_macroblocks,
-                  const XvMCBlockArray *xvmc_blocks,
-                  unsigned int first_macroblock,
-                  unsigned int num_macroblocks,
-                  struct pipe_mpeg12_macroblock *pipe_macroblocks)
-{
-   unsigned int i, j, k, l;
-   XvMCMacroBlock *xvmc_mb;
-
-   assert(xvmc_macroblocks);
-   assert(xvmc_blocks);
-   assert(pipe_macroblocks);
-   assert(num_macroblocks);
-
-   xvmc_mb = xvmc_macroblocks->macro_blocks + first_macroblock;
-
-   for (i = 0; i < num_macroblocks; ++i) {
-      pipe_macroblocks->base.codec = PIPE_VIDEO_CODEC_MPEG12;
-      pipe_macroblocks->mbx = xvmc_mb->x;
-      pipe_macroblocks->mby = xvmc_mb->y;
-      pipe_macroblocks->mb_type = TypeToPipe(xvmc_mb->macroblock_type);
-      if (pipe_macroblocks->mb_type != PIPE_MPEG12_MACROBLOCK_TYPE_INTRA)
-         pipe_macroblocks->mo_type = MotionToPipe(xvmc_mb->motion_type, xvmc_mb->dct_type);
-      /* Get rid of Valgrind 'undefined' warnings */
-      else
-         pipe_macroblocks->mo_type = -1;
-      pipe_macroblocks->dct_type = xvmc_mb->dct_type == XVMC_DCT_TYPE_FIELD ?
-         PIPE_MPEG12_DCT_TYPE_FIELD : PIPE_MPEG12_DCT_TYPE_FRAME;
-
-      for (j = 0; j < 2; ++j)
-         for (k = 0; k < 2; ++k)
-            for (l = 0; l < 2; ++l)
-               pipe_macroblocks->pmv[j][k][l] = xvmc_mb->PMV[j][k][l];
-
-      pipe_macroblocks->cbp = xvmc_mb->coded_block_pattern;
-      pipe_macroblocks->blocks = xvmc_blocks->blocks + xvmc_mb->index * BLOCK_SIZE_SAMPLES;
-
-      ++pipe_macroblocks;
-      ++xvmc_mb;
-   }
-}
-
-Status XvMCCreateSurface(Display *dpy, XvMCContext *context, XvMCSurface *surface)
-{
-   XvMCContextPrivate *context_priv;
-   struct pipe_video_context *vpipe;
-   XvMCSurfacePrivate *surface_priv;
-   struct pipe_video_surface *vsfc;
-
-   assert(dpy);
-
-   if (!context)
-      return XvMCBadContext;
-   if (!surface)
-      return XvMCBadSurface;
-
-   context_priv = context->privData;
-   vpipe = context_priv->vpipe;
-
-   surface_priv = CALLOC(1, sizeof(XvMCSurfacePrivate));
-   if (!surface_priv)
-      return BadAlloc;
-
-   vsfc = vpipe->screen->video_surface_create(vpipe->screen, vpipe->chroma_format,
-                                              vpipe->width, vpipe->height);
-   if (!vsfc) {
-      FREE(surface_priv);
-      return BadAlloc;
-   }
-
-   surface_priv->pipe_vsfc = vsfc;
-   surface_priv->context = context;
-
-   surface->surface_id = XAllocID(dpy);
-   surface->context_id = context->context_id;
-   surface->surface_type_id = context->surface_type_id;
-   surface->width = context->width;
-   surface->height = context->height;
-   surface->privData = surface_priv;
-
-   SyncHandle();
-
-   return Success;
-}
-
-Status XvMCRenderSurface(Display *dpy, XvMCContext *context, unsigned int picture_structure,
-                         XvMCSurface *target_surface, XvMCSurface *past_surface, XvMCSurface *future_surface,
-                         unsigned int flags, unsigned int num_macroblocks, unsigned int first_macroblock,
-                         XvMCMacroBlockArray *macroblocks, XvMCBlockArray *blocks
-)
-{
-   struct pipe_video_context *vpipe;
-   struct pipe_surface *t_vsfc;
-   struct pipe_surface *p_vsfc;
-   struct pipe_surface *f_vsfc;
-   XvMCContextPrivate *context_priv;
-   XvMCSurfacePrivate *target_surface_priv;
-   XvMCSurfacePrivate *past_surface_priv;
-   XvMCSurfacePrivate *future_surface_priv;
-   struct pipe_mpeg12_macroblock pipe_macroblocks[num_macroblocks];
-
-   assert(dpy);
-
-   if (!context || !context->privData)
-      return XvMCBadContext;
-   if (!target_surface || !target_surface->privData)
-      return XvMCBadSurface;
-
-   if (picture_structure != XVMC_TOP_FIELD &&
-       picture_structure != XVMC_BOTTOM_FIELD &&
-       picture_structure != XVMC_FRAME_PICTURE)
-      return BadValue;
-   /* Bkwd pred equivalent to fwd (past && !future) */
-   if (future_surface && !past_surface)
-      return BadMatch;
-
-   assert(context->context_id == target_surface->context_id);
-   assert(!past_surface || context->context_id == past_surface->context_id);
-   assert(!future_surface || context->context_id == future_surface->context_id);
-
-   assert(macroblocks);
-   assert(blocks);
-
-   assert(macroblocks->context_id == context->context_id);
-   assert(blocks->context_id == context->context_id);
-
-   assert(flags == 0 || flags == XVMC_SECOND_FIELD);
-
-   target_surface_priv = target_surface->privData;
-   past_surface_priv = past_surface ? past_surface->privData : NULL;
-   future_surface_priv = future_surface ? future_surface->privData : NULL;
-
-   assert(target_surface_priv->context == context);
-   assert(!past_surface || past_surface_priv->context == context);
-   assert(!future_surface || future_surface_priv->context == context);
-
-   context_priv = context->privData;
-   vpipe = context_priv->vpipe;
-
-   t_vsfc = target_surface_priv->pipe_vsfc;
-   p_vsfc = past_surface ? past_surface_priv->pipe_vsfc : NULL;
-   f_vsfc = future_surface ? future_surface_priv->pipe_vsfc : NULL;
-
-   MacroBlocksToPipe(macroblocks, blocks, first_macroblock,
-                     num_macroblocks, pipe_macroblocks);
-
-   vpipe->set_decode_target(vpipe, t_vsfc);
-   vpipe->decode_macroblocks(vpipe, p_vsfc, f_vsfc, num_macroblocks,
-                             &pipe_macroblocks->base, target_surface_priv->render_fence);
-
-   return Success;
-}
-
-Status XvMCFlushSurface(Display *dpy, XvMCSurface *surface)
-{
-   assert(dpy);
-
-   if (!surface)
-      return XvMCBadSurface;
-
-   return Success;
-}
-
-Status XvMCSyncSurface(Display *dpy, XvMCSurface *surface)
-{
-   assert(dpy);
-
-   if (!surface)
-      return XvMCBadSurface;
-
-   return Success;
-}
-
-Status XvMCPutSurface(Display *dpy, XvMCSurface *surface, Drawable drawable,
-                      short srcx, short srcy, unsigned short srcw, unsigned short srch,
-                      short destx, short desty, unsigned short destw, unsigned short desth,
-                      int flags)
-{
-   Window root;
-   int x, y;
-   unsigned int width, height;
-   unsigned int border_width;
-   unsigned int depth;
-   struct pipe_video_context *vpipe;
-   XvMCSurfacePrivate *surface_priv;
-   XvMCContextPrivate *context_priv;
-   XvMCContext *context;
-   struct pipe_video_rect src_rect = {srcx, srcy, srcw, srch};
-   struct pipe_video_rect dst_rect = {destx, desty, destw, desth};
-
-   assert(dpy);
-
-   if (!surface || !surface->privData)
-      return XvMCBadSurface;
-
-   if (XGetGeometry(dpy, drawable, &root, &x, &y, &width, &height, &border_width, &depth) == BadDrawable)
-      return BadDrawable;
-
-   assert(flags == XVMC_TOP_FIELD || flags == XVMC_BOTTOM_FIELD || flags == XVMC_FRAME_PICTURE);
-   assert(srcx + srcw - 1 < surface->width);
-   assert(srcy + srch - 1 < surface->height);
-   /*
-    * Some apps (mplayer) hit these asserts because they call
-    * this function after the window has been resized by the WM
-    * but before they've handled the corresponding XEvent and
-    * know about the new dimensions. The output should be clipped
-    * until the app updates destw and desth.
-    */
-   /*
-   assert(destx + destw - 1 < width);
-   assert(desty + desth - 1 < height);
-    */
-
-   surface_priv = surface->privData;
-   context = surface_priv->context;
-   context_priv = context->privData;
-   vpipe = context_priv->vpipe;
-
-   if (!CreateOrResizeBackBuffer(vpipe, width, height, &context_priv->backbuffer))
-      return BadAlloc;
-
-   vpipe->render_picture(vpipe, surface_priv->pipe_vsfc, PictureToPipe(flags), &src_rect,
-                         context_priv->backbuffer, &dst_rect, surface_priv->disp_fence);
-
-   vl_video_bind_drawable(vpipe, drawable);
-	
-   vpipe->screen->flush_frontbuffer
-   (
-      vpipe->screen,
-      context_priv->backbuffer,
-      vpipe->priv
-   );
-
-   return Success;
-}
-
-Status XvMCGetSurfaceStatus(Display *dpy, XvMCSurface *surface, int *status)
-{
-   assert(dpy);
-
-   if (!surface)
-      return XvMCBadSurface;
-
-   assert(status);
-
-   *status = 0;
-
-   return Success;
-}
-
-Status XvMCDestroySurface(Display *dpy, XvMCSurface *surface)
-{
-   XvMCSurfacePrivate *surface_priv;
-
-   assert(dpy);
-
-   if (!surface || !surface->privData)
-      return XvMCBadSurface;
-
-   surface_priv = surface->privData;
-   pipe_video_surface_reference(&surface_priv->pipe_vsfc, NULL);
-   FREE(surface_priv);
-   surface->privData = NULL;
-
-   return Success;
-}
-
-Status XvMCHideSurface(Display *dpy, XvMCSurface *surface)
-{
-   assert(dpy);
-
-   if (!surface || !surface->privData)
-      return XvMCBadSurface;
-
-   /* No op, only for overlaid rendering */
-
-   return Success;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/tests/.gitignore b/src/gallium/state_trackers/xorg/xvmc/tests/.gitignore
deleted file mode 100644
index e1d2f9023df..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/tests/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-test_context
-test_surface
-test_blocks
-test_rendering
-xvmc_bench
diff --git a/src/gallium/state_trackers/xorg/xvmc/tests/Makefile b/src/gallium/state_trackers/xorg/xvmc/tests/Makefile
deleted file mode 100644
index c875dd76058..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/tests/Makefile
+++ /dev/null
@@ -1,28 +0,0 @@
-TOP = ../../../../../..
-include $(TOP)/configs/current
-
-LIBS = -lXvMCW -lXvMC -lXv -lX11
-
-#############################################
-
-.PHONY: default clean
-
-default: test_context test_surface test_blocks test_rendering xvmc_bench
-
-test_context: test_context.o testlib.o
-	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
-
-test_surface: test_surface.o testlib.o
-	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
-
-test_blocks: test_blocks.o testlib.o
-	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
-
-test_rendering: test_rendering.o testlib.o
-	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
-
-xvmc_bench: xvmc_bench.o testlib.o
-	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
-
-clean:
-	$(RM) -rf *.o test_context test_surface test_blocks test_rendering xvmc_bench
diff --git a/src/gallium/state_trackers/xorg/xvmc/tests/test_blocks.c b/src/gallium/state_trackers/xorg/xvmc/tests/test_blocks.c
deleted file mode 100644
index 994e3ca4d14..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/tests/test_blocks.c
+++ /dev/null
@@ -1,111 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include <assert.h>
-#include <error.h>
-#include "testlib.h"
-
-int main(int argc, char **argv)
-{
-	const unsigned int	width = 16, height = 16;
-	const unsigned int	min_required_blocks = 1, min_required_macroblocks = 1;
-	const unsigned int	mc_types[2] = {XVMC_MOCOMP | XVMC_MPEG_2, XVMC_IDCT | XVMC_MPEG_2};
-
-	Display			*display;
-	XvPortID		port_num;
-	int			surface_type_id;
-	unsigned int		is_overlay, intra_unsigned;
-	int			colorkey;
-	XvMCContext		context;
-	XvMCSurface		surface;
-	XvMCBlockArray		blocks = {0};
-	XvMCMacroBlockArray	macroblocks = {0};
-
-	display = XOpenDisplay(NULL);
-
-	if (!GetPort
-	(
-		display,
-		width,
-		height,
-		XVMC_CHROMA_FORMAT_420,
-    		mc_types,
-    		2,
-    		&port_num,
-    		&surface_type_id,
-    		&is_overlay,
-    		&intra_unsigned
-	))
-	{
-		XCloseDisplay(display);
-		error(1, 0, "Error, unable to find a good port.\n");
-	}
-
-	if (is_overlay)
-	{
-		Atom xv_colorkey = XInternAtom(display, "XV_COLORKEY", 0);
-		XvGetPortAttribute(display, port_num, xv_colorkey, &colorkey);
-	}
-
-	assert(XvMCCreateContext(display, port_num, surface_type_id, width, height, XVMC_DIRECT, &context) == Success);
-	assert(XvMCCreateSurface(display, &context, &surface) == Success);
-
-	/* Test NULL context */
-	assert(XvMCCreateBlocks(display, NULL, 1, &blocks) == XvMCBadContext);
-	/* Test 0 blocks */
-	assert(XvMCCreateBlocks(display, &context, 0, &blocks) == BadValue);
-	/* Test valid params */
-	assert(XvMCCreateBlocks(display, &context, min_required_blocks, &blocks) == Success);
-	/* Test context id assigned and correct */
-	assert(blocks.context_id == context.context_id);
-	/* Test number of blocks assigned and correct */
-	assert(blocks.num_blocks == min_required_blocks);
-	/* Test block pointer valid */
-	assert(blocks.blocks != NULL);
-	/* Test NULL context */
-	assert(XvMCCreateMacroBlocks(display, NULL, 1, &macroblocks) == XvMCBadContext);
-	/* Test 0 macroblocks */
-	assert(XvMCCreateMacroBlocks(display, &context, 0, &macroblocks) == BadValue);
-	/* Test valid params */
-	assert(XvMCCreateMacroBlocks(display, &context, min_required_macroblocks, &macroblocks) == Success);
-	/* Test context id assigned and correct */
-	assert(macroblocks.context_id == context.context_id);
-	/* Test macroblock pointer valid */
-	assert(macroblocks.macro_blocks != NULL);
-	/* Test valid params */
-	assert(XvMCDestroyMacroBlocks(display, &macroblocks) == Success);
-	/* Test valid params */
-	assert(XvMCDestroyBlocks(display, &blocks) == Success);
-
-	assert(XvMCDestroySurface(display, &surface) == Success);
-	assert(XvMCDestroyContext(display, &context) == Success);
-
-	XvUngrabPort(display, port_num, CurrentTime);
-	XCloseDisplay(display);
-
-	return 0;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/tests/test_context.c b/src/gallium/state_trackers/xorg/xvmc/tests/test_context.c
deleted file mode 100644
index 3da957c9330..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/tests/test_context.c
+++ /dev/null
@@ -1,119 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include <assert.h>
-#include <error.h>
-#include "testlib.h"
-
-int main(int argc, char **argv)
-{
-	const unsigned int	width = 16, height = 16;
-	const unsigned int	mc_types[2] = {XVMC_MOCOMP | XVMC_MPEG_2, XVMC_IDCT | XVMC_MPEG_2};
-
-	Display			*display;
-	XvPortID		port_num;
-	int			surface_type_id;
-	unsigned int		is_overlay, intra_unsigned;
-	int			colorkey;
-	XvMCContext		context = {0};
-
-	display = XOpenDisplay(NULL);
-
-	if (!GetPort
-	(
-		display,
-		width,
-		height,
-		XVMC_CHROMA_FORMAT_420,
-    		mc_types,
-    		2,
-    		&port_num,
-    		&surface_type_id,
-    		&is_overlay,
-    		&intra_unsigned
-	))
-	{
-		XCloseDisplay(display);
-		error(1, 0, "Error, unable to find a good port.\n");
-	}
-
-	if (is_overlay)
-	{
-		Atom xv_colorkey = XInternAtom(display, "XV_COLORKEY", 0);
-		XvGetPortAttribute(display, port_num, xv_colorkey, &colorkey);
-	}
-
-	/* Test NULL context */
-	/* XXX: XvMCBadContext not a valid return for XvMCCreateContext in the XvMC API, but openChrome driver returns it */
-	assert(XvMCCreateContext(display, port_num, surface_type_id, width, height, XVMC_DIRECT, NULL) == XvMCBadContext);
-	/* Test invalid port */
-	/* XXX: Success and XvBadPort have the same value, if this call actually gets passed the validation step as of now we'll crash later */
-	assert(XvMCCreateContext(display, -1, surface_type_id, width, height, XVMC_DIRECT, &context) == XvBadPort);
-	/* Test invalid surface */
-	assert(XvMCCreateContext(display, port_num, -1, width, height, XVMC_DIRECT, &context) == BadMatch);
-	/* Test invalid flags */
-	assert(XvMCCreateContext(display, port_num, surface_type_id, width, height, -1, &context) == BadValue);
-	/* Test huge width */
-	assert(XvMCCreateContext(display, port_num, surface_type_id, 16384, height, XVMC_DIRECT, &context) == BadValue);
-	/* Test huge height */
-	assert(XvMCCreateContext(display, port_num, surface_type_id, width, 16384, XVMC_DIRECT, &context) == BadValue);
-	/* Test huge width & height */
-	assert(XvMCCreateContext(display, port_num, surface_type_id, 16384, 16384, XVMC_DIRECT, &context) == BadValue);
-	/* Test valid params */
-	assert(XvMCCreateContext(display, port_num, surface_type_id, width, height, XVMC_DIRECT, &context) == Success);
-	/* Test context id assigned */
-	assert(context.context_id != 0);
-	/* Test surface type id assigned and correct */
-	assert(context.surface_type_id == surface_type_id);
-	/* Test width & height assigned and correct */
-	assert(context.width == width && context.height == height);
-	/* Test port assigned and correct */
-	assert(context.port == port_num);
-	/* Test flags assigned and correct */
-	assert(context.flags == XVMC_DIRECT);
-	/* Test NULL context */
-	assert(XvMCDestroyContext(display, NULL) == XvMCBadContext);
-	/* Test valid params */
-	assert(XvMCDestroyContext(display, &context) == Success);
-	/* Test awkward but valid width */
-	assert(XvMCCreateContext(display, port_num, surface_type_id, width + 1, height, XVMC_DIRECT, &context) == Success);
-	assert(context.width >= width + 1);
-	assert(XvMCDestroyContext(display, &context) == Success);
-	/* Test awkward but valid height */
-	assert(XvMCCreateContext(display, port_num, surface_type_id, width, height + 1, XVMC_DIRECT, &context) == Success);
-	assert(context.height >= height + 1);
-	assert(XvMCDestroyContext(display, &context) == Success);
-	/* Test awkward but valid width & height */
-	assert(XvMCCreateContext(display, port_num, surface_type_id, width + 1, height + 1, XVMC_DIRECT, &context) == Success);
-	assert(context.width >= width + 1 && context.height >= height + 1);
-	assert(XvMCDestroyContext(display, &context) == Success);
-
-	XvUngrabPort(display, port_num, CurrentTime);
-	XCloseDisplay(display);
-
-	return 0;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/tests/test_rendering.c b/src/gallium/state_trackers/xorg/xvmc/tests/test_rendering.c
deleted file mode 100644
index 6058783a798..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/tests/test_rendering.c
+++ /dev/null
@@ -1,317 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-#include <error.h>
-#include "testlib.h"
-
-#define BLOCK_WIDTH			8
-#define BLOCK_HEIGHT			8
-#define BLOCK_SIZE			(BLOCK_WIDTH * BLOCK_HEIGHT)
-#define MACROBLOCK_WIDTH		16
-#define MACROBLOCK_HEIGHT		16
-#define MACROBLOCK_WIDTH_IN_BLOCKS	(MACROBLOCK_WIDTH / BLOCK_WIDTH)
-#define MACROBLOCK_HEIGHT_IN_BLOCKS	(MACROBLOCK_HEIGHT / BLOCK_HEIGHT)
-#define BLOCKS_PER_MACROBLOCK		6
-
-#define INPUT_WIDTH			16
-#define INPUT_HEIGHT			16
-#define INPUT_WIDTH_IN_MACROBLOCKS	(INPUT_WIDTH / MACROBLOCK_WIDTH)
-#define INPUT_HEIGHT_IN_MACROBLOCKS	(INPUT_HEIGHT / MACROBLOCK_HEIGHT)
-#define NUM_MACROBLOCKS			(INPUT_WIDTH_IN_MACROBLOCKS * INPUT_HEIGHT_IN_MACROBLOCKS)
-
-#define DEFAULT_OUTPUT_WIDTH		INPUT_WIDTH
-#define DEFAULT_OUTPUT_HEIGHT		INPUT_HEIGHT
-#define DEFAULT_ACCEPTABLE_ERR		0.01
-
-void ParseArgs(int argc, char **argv, unsigned int *output_width, unsigned int *output_height, double *acceptable_error, int *prompt);
-void Gradient(short *block, unsigned int start, unsigned int stop, int horizontal);
-
-void ParseArgs(int argc, char **argv, unsigned int *output_width, unsigned int *output_height, double *acceptable_error, int *prompt)
-{
-	int fail = 0;
-	int i;
-
-	*output_width = DEFAULT_OUTPUT_WIDTH;
-	*output_height = DEFAULT_OUTPUT_WIDTH;
-	*acceptable_error = DEFAULT_ACCEPTABLE_ERR;
-	*prompt = 1;
-
-	for (i = 1; i < argc && !fail; ++i)
-	{
-		if (!strcmp(argv[i], "-w"))
-		{
-			if (sscanf(argv[++i], "%u", output_width) != 1)
-				fail = 1;
-		}
-		else if (!strcmp(argv[i], "-h"))
-		{
-			if (sscanf(argv[++i], "%u", output_height) != 1)
-				fail = 1;
-		}
-		else if (!strcmp(argv[i], "-e"))
-		{
-			if (sscanf(argv[++i], "%lf", acceptable_error) != 1)
-				fail = 1;
-		}
-		else if (strcmp(argv[i], "-n"))
-			*prompt = 0;
-		else
-			fail = 1;
-	}
-
-	if (fail)
-		error
-		(
-			1, 0,
-			"Bad argument.\n"
-			"\n"
-			"Usage: %s [options]\n"
-			"\t-w <width>\tOutput width\n"
-			"\t-h <height>\tOutput height\n"
-			"\t-e <error>\tAcceptable margin of error per pixel, from 0 to 1\n"
-			"\t-n\tDon't prompt for quit\n",
-			argv[0]
-		);
-}
-
-void Gradient(short *block, unsigned int start, unsigned int stop, int horizontal)
-{
-	unsigned int x, y;
-	unsigned int range = stop - start;
-
-	if (horizontal)
-	{
-		for (y = 0; y < BLOCK_HEIGHT; ++y)
-			for (x = 0; x < BLOCK_WIDTH; ++x)
-				block[y * BLOCK_WIDTH + x] = (short)(start + range * (x / (float)(BLOCK_WIDTH - 1)));
-	}
-	else
-	{
-		for (y = 0; y < BLOCK_HEIGHT; ++y)
-			for (x = 0; x < BLOCK_WIDTH; ++x)
-				block[y * BLOCK_WIDTH + x] = (short)(start + range * (y / (float)(BLOCK_HEIGHT - 1)));
-	}
-}
-
-int main(int argc, char **argv)
-{
-	unsigned int		output_width;
-	unsigned int		output_height;
-	double			acceptable_error;
-	int			prompt;
-	Display			*display;
-	Window			root, window;
-	const unsigned int	mc_types[2] = {XVMC_MOCOMP | XVMC_MPEG_2, XVMC_IDCT | XVMC_MPEG_2};
-	XvPortID		port_num;
-	int			surface_type_id;
-	unsigned int		is_overlay, intra_unsigned;
-	int			colorkey;
-	XvMCContext		context;
-	XvMCSurface		surface;
-	XvMCBlockArray		block_array;
-	XvMCMacroBlockArray	mb_array;
-	int			mbx, mby, bx, by;
-	XvMCMacroBlock		*mb;
-	short			*blocks;
-	int			quit = 0;
-
-	ParseArgs(argc, argv, &output_width, &output_height, &acceptable_error, &prompt);
-
-	display = XOpenDisplay(NULL);
-
-	if (!GetPort
-	(
-		display,
-		INPUT_WIDTH,
-		INPUT_HEIGHT,
-		XVMC_CHROMA_FORMAT_420,
-    		mc_types,
-    		2,
-    		&port_num,
-    		&surface_type_id,
-    		&is_overlay,
-    		&intra_unsigned
-	))
-	{
-		XCloseDisplay(display);
-		error(1, 0, "Error, unable to find a good port.\n");
-	}
-
-	if (is_overlay)
-	{
-		Atom xv_colorkey = XInternAtom(display, "XV_COLORKEY", 0);
-		XvGetPortAttribute(display, port_num, xv_colorkey, &colorkey);
-	}
-
-	root = XDefaultRootWindow(display);
-	window = XCreateSimpleWindow(display, root, 0, 0, output_width, output_height, 0, 0, colorkey);
-
-	assert(XvMCCreateContext(display, port_num, surface_type_id, INPUT_WIDTH, INPUT_HEIGHT, XVMC_DIRECT, &context) == Success);
-	assert(XvMCCreateSurface(display, &context, &surface) == Success);
-	assert(XvMCCreateBlocks(display, &context, NUM_MACROBLOCKS * BLOCKS_PER_MACROBLOCK, &block_array) == Success);
-	assert(XvMCCreateMacroBlocks(display, &context, NUM_MACROBLOCKS, &mb_array) == Success);
-
-	mb = mb_array.macro_blocks;
-	blocks = block_array.blocks;
-
-	for (mby = 0; mby < INPUT_HEIGHT_IN_MACROBLOCKS; ++mby)
-		for (mbx = 0; mbx < INPUT_WIDTH_IN_MACROBLOCKS; ++mbx)
-		{
-			mb->x = mbx;
-			mb->y = mby;
-			mb->macroblock_type = XVMC_MB_TYPE_INTRA;
-			/*mb->motion_type = ;*/
-			/*mb->motion_vertical_field_select = ;*/
-			mb->dct_type = XVMC_DCT_TYPE_FRAME;
-			/*mb->PMV[0][0][0] = ;
-			mb->PMV[0][0][1] = ;
-			mb->PMV[0][1][0] = ;
-			mb->PMV[0][1][1] = ;
-			mb->PMV[1][0][0] = ;
-			mb->PMV[1][0][1] = ;
-			mb->PMV[1][1][0] = ;
-			mb->PMV[1][1][1] = ;*/
-			mb->index = (mby * INPUT_WIDTH_IN_MACROBLOCKS + mbx) * BLOCKS_PER_MACROBLOCK;
-			mb->coded_block_pattern = 0x3F;
-
-			mb++;
-
-			for (by = 0; by < MACROBLOCK_HEIGHT_IN_BLOCKS; ++by)
-				for (bx = 0; bx < MACROBLOCK_WIDTH_IN_BLOCKS; ++bx)
-				{
-					const int start = 16, stop = 235, range = stop - start;
-
-					Gradient
-					(
-						blocks,
-						(short)(start + range * ((mbx * MACROBLOCK_WIDTH + bx * BLOCK_WIDTH) / (float)(INPUT_WIDTH - 1))),
-						(short)(start + range * ((mbx * MACROBLOCK_WIDTH + bx * BLOCK_WIDTH + BLOCK_WIDTH - 1) / (float)(INPUT_WIDTH - 1))),
-						1
-					);
-
-					blocks += BLOCK_SIZE;
-				}
-
-			for (by = 0; by < MACROBLOCK_HEIGHT_IN_BLOCKS / 2; ++by)
-				for (bx = 0; bx < MACROBLOCK_WIDTH_IN_BLOCKS / 2; ++bx)
-				{
-					const int start = 16, stop = 240, range = stop - start;
-
-					Gradient
-					(
-						blocks,
-						(short)(start + range * ((mbx * MACROBLOCK_WIDTH + bx * BLOCK_WIDTH) / (float)(INPUT_WIDTH - 1))),
-						(short)(start + range * ((mbx * MACROBLOCK_WIDTH + bx * BLOCK_WIDTH + BLOCK_WIDTH - 1) / (float)(INPUT_WIDTH - 1))),
-						1
-					);
-
-					blocks += BLOCK_SIZE;
-
-					Gradient
-					(
-						blocks,
-						(short)(start + range * ((mbx * MACROBLOCK_WIDTH + bx * BLOCK_WIDTH) / (float)(INPUT_WIDTH - 1))),
-						(short)(start + range * ((mbx * MACROBLOCK_WIDTH + bx * BLOCK_WIDTH + BLOCK_WIDTH - 1) / (float)(INPUT_WIDTH - 1))),
-						1
-					);
-
-					blocks += BLOCK_SIZE;
-				}
-		}
-
-	XSelectInput(display, window, ExposureMask | KeyPressMask);
-	XMapWindow(display, window);
-	XSync(display, 0);
-
-	/* Test NULL context */
-	assert(XvMCRenderSurface(display, NULL, XVMC_FRAME_PICTURE, &surface, NULL, NULL, 0, NUM_MACROBLOCKS, 0, &mb_array, &block_array) == XvMCBadContext);
-	/* Test NULL surface */
-	assert(XvMCRenderSurface(display, &context, XVMC_FRAME_PICTURE, NULL, NULL, NULL, 0, NUM_MACROBLOCKS, 0, &mb_array, &block_array) == XvMCBadSurface);
-	/* Test bad picture structure */
-	assert(XvMCRenderSurface(display, &context, 0, &surface, NULL, NULL, 0, NUM_MACROBLOCKS, 0, &mb_array, &block_array) == BadValue);
-	/* Test valid params */
-	assert(XvMCRenderSurface(display, &context, XVMC_FRAME_PICTURE, &surface, NULL, NULL, 0, NUM_MACROBLOCKS, 0, &mb_array, &block_array) == Success);
-
-	/* Test NULL surface */
-	assert(XvMCPutSurface(display, NULL, window, 0, 0, INPUT_WIDTH, INPUT_HEIGHT, 0, 0, output_width, output_height, XVMC_FRAME_PICTURE) == XvMCBadSurface);
-	/* Test bad window */
-	/* XXX: X halts with a bad drawable for some reason, doesn't return BadDrawable as expected */
-	/*assert(XvMCPutSurface(display, &surface, 0, 0, 0, width, height, 0, 0, width, height, XVMC_FRAME_PICTURE) == BadDrawable);*/
-
-	if (prompt)
-	{
-		puts("Press any button to quit...");
-
-		while (!quit)
-		{
-			if (XPending(display) > 0)
-			{
-				XEvent event;
-
-				XNextEvent(display, &event);
-
-				switch (event.type)
-				{
-					case Expose:
-					{
-						/* Test valid params */
-						assert
-						(
-							XvMCPutSurface
-							(
-								display, &surface, window,
-								0, 0, INPUT_WIDTH, INPUT_HEIGHT,
-								0, 0, output_width, output_height,
-								XVMC_FRAME_PICTURE
-							) == Success
-						);
-						break;
-					}
-					case KeyPress:
-					{
-						quit = 1;
-						break;
-					}
-				}
-			}
-		}
-	}
-
-	assert(XvMCDestroyBlocks(display, &block_array) == Success);
-	assert(XvMCDestroyMacroBlocks(display, &mb_array) == Success);
-	assert(XvMCDestroySurface(display, &surface) == Success);
-	assert(XvMCDestroyContext(display, &context) == Success);
-
-	XvUngrabPort(display, port_num, CurrentTime);
-	XDestroyWindow(display, window);
-	XCloseDisplay(display);
-
-	return 0;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/tests/test_surface.c b/src/gallium/state_trackers/xorg/xvmc/tests/test_surface.c
deleted file mode 100644
index b65eb265c0a..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/tests/test_surface.c
+++ /dev/null
@@ -1,98 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include <assert.h>
-#include <error.h>
-#include "testlib.h"
-
-int main(int argc, char **argv)
-{
-	const unsigned int	width = 16, height = 16;
-	const unsigned int	mc_types[2] = {XVMC_MOCOMP | XVMC_MPEG_2, XVMC_IDCT | XVMC_MPEG_2};
-
-	Display			*display;
-	XvPortID		port_num;
-	int			surface_type_id;
-	unsigned int		is_overlay, intra_unsigned;
-	int			colorkey;
-	XvMCContext		context;
-	XvMCSurface		surface = {0};
-
-	display = XOpenDisplay(NULL);
-
-	if (!GetPort
-	(
-		display,
-		width,
-		height,
-		XVMC_CHROMA_FORMAT_420,
-    		mc_types,
-    		2,
-    		&port_num,
-    		&surface_type_id,
-    		&is_overlay,
-    		&intra_unsigned
-	))
-	{
-		XCloseDisplay(display);
-		error(1, 0, "Error, unable to find a good port.\n");
-	}
-
-	if (is_overlay)
-	{
-		Atom xv_colorkey = XInternAtom(display, "XV_COLORKEY", 0);
-		XvGetPortAttribute(display, port_num, xv_colorkey, &colorkey);
-	}
-
-	assert(XvMCCreateContext(display, port_num, surface_type_id, width, height, XVMC_DIRECT, &context) == Success);
-
-	/* Test NULL context */
-	assert(XvMCCreateSurface(display, NULL, &surface) == XvMCBadContext);
-	/* Test NULL surface */
-	assert(XvMCCreateSurface(display, &context, NULL) == XvMCBadSurface);
-	/* Test valid params */
-	assert(XvMCCreateSurface(display, &context, &surface) == Success);
-	/* Test surface id assigned */
-	assert(surface.surface_id != 0);
-	/* Test context id assigned and correct */
-	assert(surface.context_id == context.context_id);
-	/* Test surface type id assigned and correct */
-	assert(surface.surface_type_id == surface_type_id);
-	/* Test width & height assigned and correct */
-	assert(surface.width == width && surface.height == height);
-	/* Test valid params */
-	assert(XvMCDestroySurface(display, &surface) == Success);
-	/* Test NULL surface */
-	assert(XvMCDestroySurface(display, NULL) == XvMCBadSurface);
-
-	assert(XvMCDestroyContext(display, &context) == Success);
-
-	XvUngrabPort(display, port_num, CurrentTime);
-	XCloseDisplay(display);
-
-	return 0;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/tests/testlib.c b/src/gallium/state_trackers/xorg/xvmc/tests/testlib.c
deleted file mode 100644
index 142c09bb590..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/tests/testlib.c
+++ /dev/null
@@ -1,146 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include "testlib.h"
-#include <stdio.h>
-
-/*
-void test(int pred, const char *pred_string, const char *doc_string, const char *file, unsigned int line)
-{
-	fputs(doc_string, stderr);
-	if (!pred)
-		fprintf(stderr, " FAIL!\n\t\"%s\" at %s:%u\n", pred_string, file, line);
-	else
-		fputs(" PASS!\n", stderr);
-}
-*/
-
-int GetPort
-(
-	Display *display,
-	unsigned int width,
-	unsigned int height,
-	unsigned int chroma_format,
-	const unsigned int *mc_types,
-	unsigned int num_mc_types,
-	XvPortID *port_id,
-	int *surface_type_id,
-	unsigned int *is_overlay,
-	unsigned int *intra_unsigned
-)
-{
-	unsigned int	found_port = 0;
-	XvAdaptorInfo	*adaptor_info;
-	unsigned int	num_adaptors;
-	int		num_types;
-	int		ev_base, err_base;
-	unsigned int	i, j, k, l;
-
-	if (!XvMCQueryExtension(display, &ev_base, &err_base))
-		return 0;
-	if (XvQueryAdaptors(display, XDefaultRootWindow(display), &num_adaptors, &adaptor_info) != Success)
-		return 0;
-
-	for (i = 0; i < num_adaptors && !found_port; ++i)
-	{
-		if (adaptor_info[i].type & XvImageMask)
-		{
-			XvMCSurfaceInfo *surface_info = XvMCListSurfaceTypes(display, adaptor_info[i].base_id, &num_types);
-
-			if (surface_info)
-			{
-				for (j = 0; j < num_types && !found_port; ++j)
-				{
-					if
-					(
-						surface_info[j].chroma_format == chroma_format &&
-						surface_info[j].max_width >= width &&
-						surface_info[j].max_height >= height
-					)
-					{
-						for (k = 0; k < num_mc_types && !found_port; ++k)
-						{
-							if (surface_info[j].mc_type == mc_types[k])
-							{
-								for (l = 0; l < adaptor_info[i].num_ports && !found_port; ++l)
-								{
-									if (XvGrabPort(display, adaptor_info[i].base_id + l, CurrentTime) == Success)
-									{
-										*port_id = adaptor_info[i].base_id + l;
-										*surface_type_id = surface_info[j].surface_type_id;
-										*is_overlay = surface_info[j].flags & XVMC_OVERLAID_SURFACE;
-										*intra_unsigned = surface_info[j].flags & XVMC_INTRA_UNSIGNED;
-										found_port = 1;
-									}
-								}
-							}
-						}
-					}
-				}
-
-				XFree(surface_info);
-			}
-		}
-	}
-
-	XvFreeAdaptorInfo(adaptor_info);
-
-	return found_port;
-}
-
-unsigned int align(unsigned int value, unsigned int alignment)
-{
-	return (value + alignment - 1) & ~(alignment - 1);
-}
-
-/* From the glibc manual */
-int timeval_subtract(struct timeval *result, struct timeval *x, struct timeval *y)
-{
-	/* Perform the carry for the later subtraction by updating y. */
-	if (x->tv_usec < y->tv_usec)
-	{
-		int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
-		y->tv_usec -= 1000000 * nsec;
-		y->tv_sec += nsec;
-	}
-	if (x->tv_usec - y->tv_usec > 1000000)
-	{
-		int nsec = (x->tv_usec - y->tv_usec) / 1000000;
-		y->tv_usec += 1000000 * nsec;
-		y->tv_sec -= nsec;
-	}
-
-	/*
-	 * Compute the time remaining to wait.
-	 * tv_usec is certainly positive.
-	 */
-	result->tv_sec = x->tv_sec - y->tv_sec;
-	result->tv_usec = x->tv_usec - y->tv_usec;
-
-	/* Return 1 if result is negative. */
-	return x->tv_sec < y->tv_sec;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/tests/testlib.h b/src/gallium/state_trackers/xorg/xvmc/tests/testlib.h
deleted file mode 100644
index 0438e52928b..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/tests/testlib.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 testlib_h
-#define testlib_h
-
-/*
-#define TEST(pred, doc)	test(pred, #pred, doc, __FILE__, __LINE__)
-
-void test(int pred, const char *pred_string, const char *doc_string, const char *file, unsigned int line);
-*/
-
-#include <sys/time.h>
-#include <X11/Xlib.h>
-#include <X11/extensions/XvMClib.h>
-
-/*
- * display: IN			A valid X display
- * width, height: IN		Surface size that the port must display
- * chroma_format: IN		Chroma format that the port must display
- * mc_types, num_mc_types: IN	List of MC types that the port must support, first port that matches the first mc_type will be returned
- * port_id: OUT			Your port's ID
- * surface_type_id: OUT		Your port's surface ID
- * is_overlay: OUT		If 1, port uses overlay surfaces, you need to set a colorkey
- * intra_unsigned: OUT		If 1, port uses unsigned values for intra-coded blocks
- */
-int GetPort
-(
-	Display *display,
-	unsigned int width,
-	unsigned int height,
-	unsigned int chroma_format,
-	const unsigned int *mc_types,
-	unsigned int num_mc_types,
-	XvPortID *port_id,
-	int *surface_type_id,
-	unsigned int *is_overlay,
-	unsigned int *intra_unsigned
-);
-
-unsigned int align(unsigned int value, unsigned int alignment);
-
-int timeval_subtract(struct timeval *result, struct timeval *x, struct timeval *y);
-
-#endif
diff --git a/src/gallium/state_trackers/xorg/xvmc/tests/xvmc_bench.c b/src/gallium/state_trackers/xorg/xvmc/tests/xvmc_bench.c
deleted file mode 100644
index bf94d856234..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/tests/xvmc_bench.c
+++ /dev/null
@@ -1,300 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-#include <error.h>
-#include <sys/time.h>
-#include "testlib.h"
-
-#define MACROBLOCK_WIDTH		16
-#define MACROBLOCK_HEIGHT		16
-#define BLOCKS_PER_MACROBLOCK		6
-
-#define DEFAULT_INPUT_WIDTH		720
-#define DEFAULT_INPUT_HEIGHT		480
-#define DEFAULT_REPS			100
-
-#define PIPELINE_STEP_MC		1
-#define PIPELINE_STEP_CSC		2
-#define PIPELINE_STEP_SWAP		4
-
-#define MB_TYPE_I			1
-#define MB_TYPE_P			2
-#define MB_TYPE_B			4
-
-struct Config
-{
-	unsigned int input_width;
-	unsigned int input_height;
-	unsigned int output_width;
-	unsigned int output_height;
-	unsigned int pipeline;
-	unsigned int mb_types;
-	unsigned int reps;
-};
-
-void ParseArgs(int argc, char **argv, struct Config *config);
-
-void ParseArgs(int argc, char **argv, struct Config *config)
-{
-	int fail = 0;
-	int i;
-
-	config->input_width = DEFAULT_INPUT_WIDTH;
-	config->input_height = DEFAULT_INPUT_HEIGHT;
-	config->output_width = 0;
-	config->output_height = 0;
-	config->pipeline = 0;
-	config->mb_types = 0;
-	config->reps = DEFAULT_REPS;
-
-	for (i = 1; i < argc && !fail; ++i)
-	{
-		if (!strcmp(argv[i], "-iw"))
-		{
-			if (sscanf(argv[++i], "%u", &config->input_width) != 1)
-				fail = 1;
-		}
-		else if (!strcmp(argv[i], "-ih"))
-		{
-			if (sscanf(argv[++i], "%u", &config->input_height) != 1)
-				fail = 1;
-		}
-		else if (!strcmp(argv[i], "-ow"))
-		{
-			if (sscanf(argv[++i], "%u", &config->output_width) != 1)
-				fail = 1;
-		}
-		else if (!strcmp(argv[i], "-oh"))
-		{
-			if (sscanf(argv[++i], "%u", &config->output_height) != 1)
-				fail = 1;
-		}
-		else if (!strcmp(argv[i], "-p"))
-		{
-			char *token = strtok(argv[++i], ",");
-
-			while (token && !fail)
-			{
-				if (!strcmp(token, "mc"))
-					config->pipeline |= PIPELINE_STEP_MC;
-				else if (!strcmp(token, "csc"))
-					config->pipeline |= PIPELINE_STEP_CSC;
-				else if (!strcmp(token, "swp"))
-					config->pipeline |= PIPELINE_STEP_SWAP;
-				else
-					fail = 1;
-
-				if (!fail)
-					token = strtok(NULL, ",");
-			}
-		}
-		else if (!strcmp(argv[i], "-mb"))
-		{
-			char *token = strtok(argv[++i], ",");
-
-			while (token && !fail)
-			{
-				if (strcmp(token, "i"))
-					config->mb_types |= MB_TYPE_I;
-				else if (strcmp(token, "p"))
-					config->mb_types |= MB_TYPE_P;
-				else if (strcmp(token, "b"))
-					config->mb_types |= MB_TYPE_B;
-				else
-					fail = 1;
-
-				if (!fail)
-					token = strtok(NULL, ",");
-			}
-		}
-		else if (!strcmp(argv[i], "-r"))
-		{
-			if (sscanf(argv[++i], "%u", &config->reps) != 1)
-				fail = 1;
-		}
-		else
-			fail = 1;
-	}
-
-	if (fail)
-		error
-		(
-			1, 0,
-			"Bad argument.\n"
-			"\n"
-			"Usage: %s [options]\n"
-			"\t-iw <width>\tInput width\n"
-			"\t-ih <height>\tInput height\n"
-			"\t-ow <width>\tOutput width\n"
-			"\t-oh <height>\tOutput height\n"
-			"\t-p <pipeline>\tPipeline to test\n"
-			"\t-mb <mb type>\tMacroBlock types to use\n"
-			"\t-r <reps>\tRepetitions\n\n"
-			"\tPipeline steps: mc,csc,swap\n"
-			"\tMB types: i,p,b\n",
-			argv[0]
-		);
-
-	if (config->output_width == 0)
-		config->output_width = config->input_width;
-	if (config->output_height == 0)
-		config->output_height = config->input_height;
-	if (!config->pipeline)
-		config->pipeline = PIPELINE_STEP_MC | PIPELINE_STEP_CSC | PIPELINE_STEP_SWAP;
-	if (!config->mb_types)
-		config->mb_types = MB_TYPE_I | MB_TYPE_P | MB_TYPE_B;
-}
-
-int main(int argc, char **argv)
-{
-	struct Config		config;
-	Display			*display;
-	Window			root, window;
-	const unsigned int	mc_types[2] = {XVMC_MOCOMP | XVMC_MPEG_2, XVMC_IDCT | XVMC_MPEG_2};
-	XvPortID		port_num;
-	int			surface_type_id;
-	unsigned int		is_overlay, intra_unsigned;
-	int			colorkey;
-	XvMCContext		context;
-	XvMCSurface		surface;
-	XvMCBlockArray		block_array;
-	XvMCMacroBlockArray	mb_array;
-	unsigned int		mbw, mbh;
-	unsigned int		mbx, mby;
-	unsigned int		reps;
-	struct timeval		start, stop, diff;
-	double			diff_secs;
-
-	ParseArgs(argc, argv, &config);
-
-	mbw = align(config.input_width, MACROBLOCK_WIDTH) / MACROBLOCK_WIDTH;
-	mbh = align(config.input_height, MACROBLOCK_HEIGHT) / MACROBLOCK_HEIGHT;
-
-	display = XOpenDisplay(NULL);
-
-	if (!GetPort
-	(
-		display,
-		config.input_width,
-		config.input_height,
-		XVMC_CHROMA_FORMAT_420,
-    		mc_types,
-    		2,
-    		&port_num,
-    		&surface_type_id,
-    		&is_overlay,
-    		&intra_unsigned
-	))
-	{
-		XCloseDisplay(display);
-		error(1, 0, "Error, unable to find a good port.\n");
-	}
-
-	if (is_overlay)
-	{
-		Atom xv_colorkey = XInternAtom(display, "XV_COLORKEY", 0);
-		XvGetPortAttribute(display, port_num, xv_colorkey, &colorkey);
-	}
-
-	root = XDefaultRootWindow(display);
-	window = XCreateSimpleWindow(display, root, 0, 0, config.output_width, config.output_height, 0, 0, colorkey);
-
-	assert(XvMCCreateContext(display, port_num, surface_type_id, config.input_width, config.input_height, XVMC_DIRECT, &context) == Success);
-	assert(XvMCCreateSurface(display, &context, &surface) == Success);
-	assert(XvMCCreateBlocks(display, &context, mbw * mbh * BLOCKS_PER_MACROBLOCK, &block_array) == Success);
-	assert(XvMCCreateMacroBlocks(display, &context, mbw * mbh, &mb_array) == Success);
-
-	for (mby = 0; mby < mbh; ++mby)
-		for (mbx = 0; mbx < mbw; ++mbx)
-		{
-			mb_array.macro_blocks[mby * mbw + mbx].x = mbx;
-			mb_array.macro_blocks[mby * mbw + mbx].y = mby;
-			mb_array.macro_blocks[mby * mbw + mbx].macroblock_type = XVMC_MB_TYPE_INTRA;
-			/*mb->motion_type = ;*/
-			/*mb->motion_vertical_field_select = ;*/
-			mb_array.macro_blocks[mby * mbw + mbx].dct_type = XVMC_DCT_TYPE_FRAME;
-			/*mb->PMV[0][0][0] = ;
-			mb->PMV[0][0][1] = ;
-			mb->PMV[0][1][0] = ;
-			mb->PMV[0][1][1] = ;
-			mb->PMV[1][0][0] = ;
-			mb->PMV[1][0][1] = ;
-			mb->PMV[1][1][0] = ;
-			mb->PMV[1][1][1] = ;*/
-			mb_array.macro_blocks[mby * mbw + mbx].index = (mby * mbw + mbx) * BLOCKS_PER_MACROBLOCK;
-			mb_array.macro_blocks[mby * mbw + mbx].coded_block_pattern = 0x3F;
-		}
-
-	XSelectInput(display, window, ExposureMask | KeyPressMask);
-	XMapWindow(display, window);
-	XSync(display, 0);
-
-	gettimeofday(&start, NULL);
-
-	for (reps = 0; reps < config.reps; ++reps)
-	{
-		if (config.pipeline & PIPELINE_STEP_MC)
-		{
-			assert(XvMCRenderSurface(display, &context, XVMC_FRAME_PICTURE, &surface, NULL, NULL, 0, mbw * mbh, 0, &mb_array, &block_array) == Success);
-			assert(XvMCFlushSurface(display, &surface) == Success);
-		}
-		if (config.pipeline & PIPELINE_STEP_CSC)
-			assert(XvMCPutSurface(display, &surface, window, 0, 0, config.input_width, config.input_height, 0, 0, config.output_width, config.output_height, XVMC_FRAME_PICTURE) == Success);
-	}
-
-	gettimeofday(&stop, NULL);
-
-	timeval_subtract(&diff, &stop, &start);
-	diff_secs = (double)diff.tv_sec + (double)diff.tv_usec / 1000000.0;
-
-	printf("XvMC Benchmark\n");
-	printf("Input: %u,%u\nOutput: %u,%u\n", config.input_width, config.input_height, config.output_width, config.output_height);
-	printf("Pipeline: ");
-	if (config.pipeline & PIPELINE_STEP_MC)
-		printf("|mc|");
-	if (config.pipeline & PIPELINE_STEP_CSC)
-		printf("|csc|");
-	if (config.pipeline & PIPELINE_STEP_SWAP)
-		printf("|swap|");
-	printf("\n");
-	printf("Reps: %u\n", config.reps);
-	printf("Total time: %.2lf (%.2lf reps / sec)\n", diff_secs, config.reps / diff_secs);
-
-	assert(XvMCDestroyBlocks(display, &block_array) == Success);
-	assert(XvMCDestroyMacroBlocks(display, &mb_array) == Success);
-	assert(XvMCDestroySurface(display, &surface) == Success);
-	assert(XvMCDestroyContext(display, &context) == Success);
-
-	XvUngrabPort(display, port_num, CurrentTime);
-	XDestroyWindow(display, window);
-	XCloseDisplay(display);
-
-	return 0;
-}
diff --git a/src/gallium/state_trackers/xorg/xvmc/xvmc_private.h b/src/gallium/state_trackers/xorg/xvmc/xvmc_private.h
deleted file mode 100644
index 42337631ca1..00000000000
--- a/src/gallium/state_trackers/xorg/xvmc/xvmc_private.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 xvmc_private_h
-#define xvmc_private_h
-
-#include <X11/Xlib.h>
-#include <X11/extensions/XvMClib.h>
-
-#define BLOCK_SIZE_SAMPLES 64
-#define BLOCK_SIZE_BYTES (BLOCK_SIZE_SAMPLES * 2)
-
-struct pipe_video_context;
-struct pipe_surface;
-struct pipe_fence_handle;
-
-typedef struct
-{
-	struct pipe_video_context *vpipe;
-	struct pipe_surface *backbuffer;
-} XvMCContextPrivate;
-
-typedef struct
-{
-	struct pipe_video_surface *pipe_vsfc;
-	struct pipe_fence_handle *render_fence;
-	struct pipe_fence_handle *disp_fence;
-	
-	/* Some XvMC functions take a surface but not a context,
-	   so we keep track of which context each surface belongs to. */
-	XvMCContext *context;
-} XvMCSurfacePrivate;
-
-#endif /* xvmc_private_h */
diff --git a/src/gallium/targets/Makefile.dri b/src/gallium/targets/Makefile.dri
index 6d9b81aa249..16477e34963 100644
--- a/src/gallium/targets/Makefile.dri
+++ b/src/gallium/targets/Makefile.dri
@@ -69,7 +69,7 @@ $(LIBNAME): $(OBJECTS) $(MESA_MODULES) $(PIPE_DRIVERS) Makefile \
 		$(OBJECTS) $(PIPE_DRIVERS) \
                 -Wl,--start-group $(MESA_MODULES) -Wl,--end-group \
                  $(DRI_LIB_DEPS) $(DRIVER_EXTRAS)
-	$(CC) -o $@.test $(TOP)/src/mesa/drivers/dri/common/dri_test.o $@.tmp $(DRI_LIB_DEPS)
+	$(CC) $(CFLAGS) -o $@.test $(TOP)/src/mesa/drivers/dri/common/dri_test.o $@.tmp $(DRI_LIB_DEPS)
 	@rm -f $@.test
 	mv -f $@.tmp $@
 
diff --git a/src/gallium/targets/SConscript.dri b/src/gallium/targets/SConscript.dri
index 210af13720a..28fbe02ab8d 100644
--- a/src/gallium/targets/SConscript.dri
+++ b/src/gallium/targets/SConscript.dri
@@ -65,6 +65,10 @@ COMMON_DRI_DRM_OBJECTS = [
 	dri_common_dri_util,
 ]
 
+drienv.AppendUnique(LIBS = [
+    'expat',
+])
+
 Export([
 	'drienv',
 	'COMMON_DRI_SW_OBJECTS',
diff --git a/src/gallium/targets/dri-swrast/SConscript b/src/gallium/targets/dri-swrast/SConscript
index 94ff99a0a90..77f44384d06 100644
--- a/src/gallium/targets/dri-swrast/SConscript
+++ b/src/gallium/targets/dri-swrast/SConscript
@@ -1,9 +1,5 @@
 Import('*')
 
-if not set(('softpipe', 'llvmpipe')).intersection(env['drivers']):
-    print 'warning: no supported pipe driver: skipping build of swrastg_dri.so'
-    Return()
-
 env = drienv.Clone()
 
 env.Append(CPPPATH = [
@@ -20,16 +16,14 @@ env.Prepend(LIBS = [
     COMMON_DRI_SW_OBJECTS
 ])
 
-if 'softpipe' in env['drivers']:
+if True:
     env.Append(CPPDEFINES = 'GALLIUM_SOFTPIPE')
     env.Prepend(LIBS = [softpipe])
 
-if 'llvmpipe' in env['drivers']:
-    env.Tool('llvm')
-    if 'LLVM_VERSION' in env:
-        env.Append(CPPDEFINES = 'GALLIUM_LLVMPIPE')
-        env.Tool('udis86')
-        env.Prepend(LIBS = [llvmpipe])
+if env['llvm']:
+    env.Append(CPPDEFINES = 'GALLIUM_LLVMPIPE')
+    env.Tool('udis86')
+    env.Prepend(LIBS = [llvmpipe])
 
 swrastg_sources = [
     'swrast_drm_api.c'
diff --git a/src/gallium/targets/dri-swrast/swrast_drm_api.c b/src/gallium/targets/dri-swrast/swrast_drm_api.c
index 99c25543a76..63b935bb07b 100644
--- a/src/gallium/targets/dri-swrast/swrast_drm_api.c
+++ b/src/gallium/targets/dri-swrast/swrast_drm_api.c
@@ -68,16 +68,16 @@ swrast_create_screen(struct sw_winsys *winsys)
 #if defined(GALLIUM_CELL)
    if (screen == NULL && strcmp(driver, "cell") == 0)
       screen = cell_create_screen( winsys );
-#elif defined(GALLIUM_LLVMPIPE)
+#endif
+
+#if defined(GALLIUM_LLVMPIPE)
    if (screen == NULL && strcmp(driver, "llvmpipe") == 0)
       screen = llvmpipe_create_screen( winsys );
-#elif defined(GALLIUM_SOFTPIPE)
+#endif
+
+#if defined(GALLIUM_SOFTPIPE)
    if (screen == NULL)
       screen = softpipe_create_screen( winsys );
-
-   (void) driver;
-#else
-   (void) driver;
 #endif
 
    return screen;
diff --git a/src/gallium/targets/graw-xlib/SConscript b/src/gallium/targets/graw-xlib/SConscript
index 24cea92f907..979252b22d7 100644
--- a/src/gallium/targets/graw-xlib/SConscript
+++ b/src/gallium/targets/graw-xlib/SConscript
@@ -6,10 +6,6 @@ Import('*')
 if env['platform'] != 'linux':
     Return()
 
-if not set(('softpipe', 'llvmpipe', 'cell')).intersection(env['drivers']):
-    print 'warning: no supported pipe driver: skipping build of xlib libGL.so'
-    Return()
-
 env = env.Clone()
 
 env.Prepend(LIBS = [
@@ -28,16 +24,14 @@ sources = [
     'graw_xlib.c',
 ]
 
-if 'softpipe' in env['drivers']:
+if True:
     env.Append(CPPDEFINES = 'GALLIUM_SOFTPIPE')
     env.Prepend(LIBS = [softpipe])
 
-if 'llvmpipe' in env['drivers']:
-    env.Tool('llvm')
-    if 'LLVM_VERSION' in env:
-        env.Append(CPPDEFINES = 'GALLIUM_LLVMPIPE')
-        env.Tool('udis86')
-        env.Prepend(LIBS = [llvmpipe])
+if env['llvm']:
+    env.Append(CPPDEFINES = 'GALLIUM_LLVMPIPE')
+    env.Tool('udis86')
+    env.Prepend(LIBS = [llvmpipe])
 
 # Need this for trace, identity drivers referenced by
 # gallium_wrap_screen().
diff --git a/src/gallium/targets/libgl-gdi/SConscript b/src/gallium/targets/libgl-gdi/SConscript
index 21b4eb2abee..2a55c7a5776 100644
--- a/src/gallium/targets/libgl-gdi/SConscript
+++ b/src/gallium/targets/libgl-gdi/SConscript
@@ -22,20 +22,14 @@ if env['platform'] == 'windows':
     sources = []
     drivers = []
 
-    if 'softpipe' in env['drivers']:
+    if True:
         sources = ['gdi_softpipe_winsys.c']
         drivers = [softpipe]
 
-    if 'llvmpipe' in env['drivers']:
-        env.Tool('llvm')
-        if 'LLVM_VERSION' in env:
-            sources = ['gdi_llvmpipe_winsys.c']
-            drivers = [llvmpipe]
+    if env['llvm']:
+        sources = ['gdi_llvmpipe_winsys.c']
+        drivers = [llvmpipe]
 
-    if not sources or not drivers:
-        print 'warning: softpipe or llvmpipe not selected, gdi winsys disabled'
-        Return()
-    
     if env['gcc']:
         sources += ['#src/gallium/state_trackers/wgl/opengl32.mingw.def']
     else:
diff --git a/src/gallium/targets/libgl-gdi/gdi_llvmpipe_winsys.c b/src/gallium/targets/libgl-gdi/gdi_llvmpipe_winsys.c
index 29316a1ce28..58c941a03b5 100644
--- a/src/gallium/targets/libgl-gdi/gdi_llvmpipe_winsys.c
+++ b/src/gallium/targets/libgl-gdi/gdi_llvmpipe_winsys.c
@@ -83,7 +83,7 @@ gdi_llvmpipe_present(struct pipe_screen *screen,
     * other structs such as this stw_winsys as well...
     */
    gdi_sw_display(llvmpipe_screen(screen)->winsys,
-                  llvmpipe_texture(surface->texture)->dt,
+                  llvmpipe_resource(surface->texture)->dt,
                   hDC);
 }
 
diff --git a/src/gallium/targets/libgl-gdi/gdi_softpipe_winsys.c b/src/gallium/targets/libgl-gdi/gdi_softpipe_winsys.c
index dfe60195d94..4ac507ff9cf 100644
--- a/src/gallium/targets/libgl-gdi/gdi_softpipe_winsys.c
+++ b/src/gallium/targets/libgl-gdi/gdi_softpipe_winsys.c
@@ -83,7 +83,7 @@ gdi_softpipe_present(struct pipe_screen *screen,
     * other structs such as this stw_winsys as well...
     */
    gdi_sw_display(softpipe_screen(screen)->winsys,
-                  softpipe_texture(surface->texture)->dt,
+                  softpipe_resource(surface->texture)->dt,
                   hDC);
 }
 
diff --git a/src/gallium/targets/libgl-xlib/SConscript b/src/gallium/targets/libgl-xlib/SConscript
index c1614d4a9f7..63e4531263a 100644
--- a/src/gallium/targets/libgl-xlib/SConscript
+++ b/src/gallium/targets/libgl-xlib/SConscript
@@ -14,10 +14,6 @@ if env['dri']:
     print 'warning: DRI enabled: skipping build of xlib libGL.so'
     Return()
 
-if not set(('softpipe', 'llvmpipe', 'cell')).intersection(env['drivers']):
-    print 'warning: no supported pipe driver: skipping build of xlib libGL.so'
-    Return()
-
 env = env.Clone()
 
 env.Append(CPPPATH = [
@@ -45,16 +41,14 @@ sources = [
 
 env.Tool('x11')
 
-if 'softpipe' in env['drivers']:
+if True:
     env.Append(CPPDEFINES = 'GALLIUM_SOFTPIPE')
     env.Prepend(LIBS = [softpipe])
 
-if 'llvmpipe' in env['drivers']:
-    env.Tool('llvm')
-    if 'LLVM_VERSION' in env:
-        env.Append(CPPDEFINES = 'GALLIUM_LLVMPIPE')
-        env.Tool('udis86')
-        env.Prepend(LIBS = [llvmpipe])
+if env['llvm']:
+    env.Append(CPPDEFINES = 'GALLIUM_LLVMPIPE')
+    env.Tool('udis86')
+    env.Prepend(LIBS = [llvmpipe])
     
 if 'cell' in env['drivers']:
     env.Append(CPPDEFINES = 'GALLIUM_CELL')
diff --git a/src/gallium/tests/python/retrace/README b/src/gallium/tests/python/retrace/README
new file mode 100644
index 00000000000..822cd114044
--- /dev/null
+++ b/src/gallium/tests/python/retrace/README
@@ -0,0 +1,17 @@
+This is an application written in python to replay the traces captured by the
+ trace pipe driver. 
+
+
+To use it follow the instructions in src/gallium/drivers/trace/README and
+src/gallium/state_trackers/python/README, and then do
+
+  python src/gallium/state_trackers/python/samples/retrace/interpreter.py filename.trace
+
+
+This is still work in progress:
+- not everything is captured/replayed
+  - surface/textures contents
+- any tiny error will result in a crash
+
+--
+Jose Fonseca <jrfonseca@tungstengraphics.com>
diff --git a/src/gallium/tests/python/retrace/format.py b/src/gallium/tests/python/retrace/format.py
new file mode 100755
index 00000000000..a4285bfe075
--- /dev/null
+++ b/src/gallium/tests/python/retrace/format.py
@@ -0,0 +1,173 @@
+#!/usr/bin/env python
+##########################################################################
+#
+# Copyright 2008 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.
+#
+##########################################################################
+
+
+import sys
+
+
+class Formatter:
+    '''Plain formatter'''
+
+    def __init__(self, stream):
+        self.stream = stream
+
+    def text(self, text):
+        self.stream.write(text)
+
+    def newline(self):
+        self.text('\n')
+
+    def function(self, name):
+        self.text(name)
+
+    def variable(self, name):
+        self.text(name)
+
+    def literal(self, value):
+        self.text(str(value))
+
+    def address(self, addr):
+        self.text(str(addr))
+
+
+class AnsiFormatter(Formatter):
+    '''Formatter for plain-text files which outputs ANSI escape codes. See
+    http://en.wikipedia.org/wiki/ANSI_escape_code for more information
+    concerning ANSI escape codes.
+    '''
+
+    _csi = '\33['
+
+    _normal = '0m'
+    _bold = '1m'
+    _italic = '3m'
+    _red = '31m'
+    _green = '32m'
+    _blue = '34m'
+
+    def _escape(self, code):
+        self.text(self._csi + code)
+
+    def function(self, name):
+        self._escape(self._bold)
+        Formatter.function(self, name)
+        self._escape(self._normal)
+
+    def variable(self, name):
+        self._escape(self._italic)
+        Formatter.variable(self, name)
+        self._escape(self._normal)
+
+    def literal(self, value):
+        self._escape(self._blue)
+        Formatter.literal(self, value)
+        self._escape(self._normal)
+
+    def address(self, value):
+        self._escape(self._green)
+        Formatter.address(self, value)
+        self._escape(self._normal)
+
+
+class WindowsConsoleFormatter(Formatter):
+    '''Formatter for the Windows Console. See 
+    http://code.activestate.com/recipes/496901/ for more information.
+    '''
+
+    STD_INPUT_HANDLE  = -10
+    STD_OUTPUT_HANDLE = -11
+    STD_ERROR_HANDLE  = -12
+
+    FOREGROUND_BLUE      = 0x01
+    FOREGROUND_GREEN     = 0x02
+    FOREGROUND_RED       = 0x04
+    FOREGROUND_INTENSITY = 0x08
+    BACKGROUND_BLUE      = 0x10
+    BACKGROUND_GREEN     = 0x20
+    BACKGROUND_RED       = 0x40
+    BACKGROUND_INTENSITY = 0x80
+
+    _normal = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
+    _bold = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY
+    _italic = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
+    _red = FOREGROUND_RED | FOREGROUND_INTENSITY
+    _green = FOREGROUND_GREEN | FOREGROUND_INTENSITY
+    _blue = FOREGROUND_BLUE | FOREGROUND_INTENSITY
+
+    def __init__(self, stream):
+        Formatter.__init__(self, stream)
+
+        if stream is sys.stdin:
+            nStdHandle = self.STD_INPUT_HANDLE
+        elif stream is sys.stdout:
+            nStdHandle = self.STD_OUTPUT_HANDLE
+        elif stream is sys.stderr:
+            nStdHandle = self.STD_ERROR_HANDLE
+        else:
+            nStdHandle = None
+
+        if nStdHandle:
+            import ctypes
+            self.handle = ctypes.windll.kernel32.GetStdHandle(nStdHandle)
+        else:
+            self.handle = None
+
+    def _attribute(self, attr):
+        if self.handle:
+            import ctypes
+            ctypes.windll.kernel32.SetConsoleTextAttribute(self.handle, attr)
+
+    def function(self, name):
+        self._attribute(self._bold)
+        Formatter.function(self, name)
+        self._attribute(self._normal)
+
+    def variable(self, name):
+        self._attribute(self._italic)
+        Formatter.variable(self, name)
+        self._attribute(self._normal)
+
+    def literal(self, value):
+        self._attribute(self._blue)
+        Formatter.literal(self, value)
+        self._attribute(self._normal)
+
+    def address(self, value):
+        self._attribute(self._green)
+        Formatter.address(self, value)
+        self._attribute(self._normal)
+
+
+def DefaultFormatter(stream):
+    if sys.platform in ('linux2', 'cygwin'):
+        return AnsiFormatter(stream)
+    elif sys.platform in ('win32',):
+        return WindowsConsoleFormatter(stream)
+    else:
+        return Formatter(stream)
+
diff --git a/src/gallium/tests/python/retrace/interpreter.py b/src/gallium/tests/python/retrace/interpreter.py
new file mode 100755
index 00000000000..47538d26192
--- /dev/null
+++ b/src/gallium/tests/python/retrace/interpreter.py
@@ -0,0 +1,735 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2008 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.
+# 
+##########################################################################
+
+
+import sys
+import struct
+
+import gallium
+import model
+import parse as parser
+
+
+try:
+    from struct import unpack_from
+except ImportError:
+    def unpack_from(fmt, buf, offset=0):
+        size = struct.calcsize(fmt)
+        return struct.unpack(fmt, buf[offset:offset + size])
+
+
+def make_image(ctx, surface, x=None, y=None, w=None, h=None):
+    if x is None:
+        x = 0
+    if y is None:
+        y = 0
+    if w is None:
+        w = surface.width - x
+    if h is None:
+        h = surface.height - y
+    data = ctx.surface_read_rgba8(surface, x, y, surface.width, surface.height)
+
+    import Image
+    outimage = Image.fromstring('RGBA', (w, h), data, "raw", 'RGBA', 0, 1)
+    return outimage
+
+def save_image(ctx, filename, surface, x=None, y=None, w=None, h=None):
+    outimage = make_image(ctx, surface, x, y, w, h)
+    outimage.save(filename, "PNG")
+
+def show_image(ctx, surface, title, x=None, y=None, w=None, h=None):
+    outimage = make_image(ctx, surface, x, y, w, h)
+    
+    import Tkinter as tk
+    from PIL import Image, ImageTk
+    root = tk.Tk()
+    
+    root.title(title)
+    
+    image1 = ImageTk.PhotoImage(outimage)
+    w = image1.width()
+    h = image1.height()
+    x = 100
+    y = 100
+    root.geometry("%dx%d+%d+%d" % (w, h, x, y))
+    panel1 = tk.Label(root, image=image1)
+    panel1.pack(side='top', fill='both', expand='yes')
+    panel1.image = image1
+    root.mainloop()
+
+
+class Struct:
+    """C-like struct"""
+
+    # A basic Python class can pass as a C-like structure
+    pass
+
+
+struct_factories = {
+    "pipe_blend_color": gallium.BlendColor,
+    "pipe_blend_state": gallium.Blend,
+    #"pipe_clip_state": gallium.Clip,
+    #"pipe_buffer": gallium.Buffer,
+    "pipe_depth_state": gallium.Depth,
+    "pipe_stencil_state": gallium.Stencil,
+    "pipe_alpha_state": gallium.Alpha,
+    "pipe_depth_stencil_alpha_state": gallium.DepthStencilAlpha,
+    #"pipe_framebuffer_state": gallium.Framebuffer,
+    "pipe_poly_stipple": gallium.PolyStipple,
+    "pipe_rasterizer_state": gallium.Rasterizer,
+    "pipe_sampler_state": gallium.Sampler,
+    "pipe_scissor_state": gallium.Scissor,
+    #"pipe_shader_state": gallium.Shader,
+    #"pipe_vertex_buffer": gallium.VertexBuffer,
+    "pipe_vertex_element": gallium.VertexElement,
+    "pipe_viewport_state": gallium.Viewport,
+    #"pipe_texture": gallium.Texture,
+    'pipe_subresource': gallium.pipe_subresource,
+    'pipe_box': gallium.pipe_box,
+}
+
+
+member_array_factories = {
+    #"pipe_rasterizer_state": {"sprite_coord_mode": gallium.ByteArray},                          
+    "pipe_poly_stipple": {"stipple": gallium.UnsignedArray},                          
+    "pipe_viewport_state": {"scale": gallium.FloatArray, "translate": gallium.FloatArray},                          
+    #"pipe_clip_state": {"ucp": gallium.FloatArray},
+    "pipe_depth_stencil_alpha_state": {"stencil": gallium.StencilArray},
+    "pipe_blend_color": {"color": gallium.FloatArray},
+    "pipe_sampler_state": {"border_color": gallium.FloatArray},              
+}
+
+
+class Translator(model.Visitor):
+    """Translate model arguments into regular Python objects"""
+
+    def __init__(self, interpreter):
+        self.interpreter = interpreter
+        self.result = None
+
+    def visit(self, node):
+        self.result = None
+        node.visit(self)
+        return self.result
+        
+    def visit_literal(self, node):
+        self.result = node.value
+    
+    def visit_named_constant(self, node):
+        # lookup the named constant in the gallium module
+        self.result = getattr(gallium, node.name)
+    
+    def visit_array(self, node):
+        array = []
+        for element in node.elements:
+            array.append(self.visit(element))
+        self.result = array
+    
+    def visit_struct(self, node):
+        struct_factory = struct_factories.get(node.name, Struct)
+        struct = struct_factory()
+        for member_name, member_node in node.members:
+            member_value = self.visit(member_node)
+            try:
+                array_factory = member_array_factories[node.name][member_name]
+            except KeyError:
+                pass
+            else:
+                assert isinstance(member_value, list)
+                array = array_factory(len(member_value))
+                for i in range(len(member_value)):
+                    array[i] = member_value[i]
+                member_value = array
+            #print node.name, member_name, member_value
+            assert isinstance(struct, Struct) or hasattr(struct, member_name)
+            setattr(struct, member_name, member_value)
+        self.result = struct
+    
+    def visit_pointer(self, node):
+        self.result = self.interpreter.lookup_object(node.address)
+
+
+class Object:
+    
+    def __init__(self, interpreter, real):
+        self.interpreter = interpreter
+        self.real = real
+        
+
+class Global(Object):
+
+    def __init__(self, interpreter, real):
+        self.interpreter = interpreter
+        self.real = real
+        
+    def pipe_screen_create(self):
+        real = gallium.Device()
+        return Screen(self.interpreter, real)
+    
+    def pipe_context_create(self, screen):
+        context = screen.real.context_create()
+        return Context(self.interpreter, context)
+
+    
+class Transfer:
+
+    def __init__(self, resource, usage, subresource, box):
+        self.resource = resource
+        self.usage = usage
+        self.subresource = subresource
+        self.box = box
+
+
+class Screen(Object):
+    
+    def __init__(self, interpreter, real):
+        Object.__init__(self, interpreter, real)
+        self.context = self.real.context_create()
+
+    def destroy(self):
+        pass
+
+    def get_name(self):
+        pass
+    
+    def get_vendor(self):
+        pass
+    
+    def get_param(self, param):
+        pass
+    
+    def get_paramf(self, param):
+        pass
+    
+    def context_create(self):
+        context = self.real.context_create()
+        return Context(self.interpreter, context)
+    
+    def is_format_supported(self, format, target, bind, geom_flags):
+        return self.real.is_format_supported(format, target, bind, geom_flags)
+    
+    def resource_create(self, templat):
+        return self.real.resource_create(
+            format = templat.format,
+            width = templat.width,
+            height = templat.height,
+            depth = templat.depth,
+            last_level = templat.last_level,
+            target = templat.target,
+            bind = templat.bind,
+        )
+
+    def texture_destroy(self, texture):
+        self.interpreter.unregister_object(texture)
+
+    def texture_release(self, surface):
+        pass
+
+    def get_tex_surface(self, texture, face, level, zslice, usage):
+        if texture is None:
+            return None
+        return texture.get_surface(face, level, zslice)
+    
+    def tex_surface_destroy(self, surface):
+        self.interpreter.unregister_object(surface)
+
+    def tex_surface_release(self, surface):
+        pass
+
+    def user_buffer_create(self, data, size, usage):
+        bind = usage
+        # We don't really care to distinguish between user and regular buffers
+        buffer = self.real.buffer_create(size, bind)
+        assert size == len(data)
+        self.context.buffer_write(buffer, data)
+        return buffer
+    
+    def buffer_create(self, alignment, usage, size):
+        return self.real.buffer_create(size, alignment, usage)
+    
+    def buffer_destroy(self, buffer):
+        pass
+    
+    def fence_finish(self, fence, flags):
+        pass
+    
+    def fence_reference(self, dst, src):
+        pass
+    
+    def flush_frontbuffer(self, surface):
+        pass
+
+
+class Context(Object):
+    
+    def __init__(self, interpreter, real):
+        Object.__init__(self, interpreter, real)
+        self.cbufs = []
+        self.zsbuf = None
+        self.vbufs = []
+        self.velems = []
+        self.dirty = False
+
+    def destroy(self):
+        pass
+    
+    def create_blend_state(self, state):
+        if isinstance(state, str):
+            state = gallium.Blend(state)
+            sys.stdout.write('\t%s\n' % state)
+        return state
+
+    def bind_blend_state(self, state):
+        if state is not None:
+            self.real.set_blend(state)
+
+    def delete_blend_state(self, state):
+        pass
+    
+    def create_sampler_state(self, state):
+        return state
+
+    def delete_sampler_state(self, state):
+        pass
+
+    def bind_vertex_sampler_states(self, num_states, states):
+        for i in range(num_states):
+            self.real.set_vertex_sampler(i, states[i])
+        
+    def bind_fragment_sampler_states(self, num_states, states):
+        for i in range(num_states):
+            self.real.set_fragment_sampler(i, states[i])
+        
+    def create_rasterizer_state(self, state):
+        return state
+
+    def bind_rasterizer_state(self, state):
+        if state is not None:
+            self.real.set_rasterizer(state)
+        
+    def delete_rasterizer_state(self, state):
+        pass
+    
+    def create_depth_stencil_alpha_state(self, state):
+        return state
+
+    def bind_depth_stencil_alpha_state(self, state):
+        if state is not None:
+            self.real.set_depth_stencil_alpha(state)
+            
+    def delete_depth_stencil_alpha_state(self, state):
+        pass
+
+    def create_fs_state(self, state):
+        tokens = str(state.tokens)
+        shader = gallium.Shader(tokens)
+        return shader
+
+    create_vs_state = create_fs_state
+    
+    def bind_fs_state(self, state):
+        self.real.set_fragment_shader(state)
+        
+    def bind_vs_state(self, state):
+        self.real.set_vertex_shader(state)
+
+    def delete_fs_state(self, state):
+        pass
+
+    delete_vs_state = delete_fs_state
+
+    def set_blend_color(self, state):
+        self.real.set_blend_color(state)
+
+    def set_stencil_ref(self, state):
+        self.real.set_stencil_ref(state)
+
+    def set_clip_state(self, state):
+        _state = gallium.Clip()
+        _state.nr = state.nr
+        if state.nr:
+            # FIXME
+            ucp = gallium.FloatArray(gallium.PIPE_MAX_CLIP_PLANES*4)
+            for i in range(len(state.ucp)):
+                for j in range(len(state.ucp[i])):
+                    ucp[i*4 + j] = state.ucp[i][j]
+            _state.ucp = ucp
+        self.real.set_clip(_state)
+
+    def dump_constant_buffer(self, buffer):
+        if not self.interpreter.verbosity(2):
+            return
+
+        data = buffer.read()
+        format = '4f'
+        index = 0
+        for offset in range(0, len(data), struct.calcsize(format)):
+            x, y, z, w = unpack_from(format, data, offset)
+            sys.stdout.write('\tCONST[%2u] = {%10.4f, %10.4f, %10.4f, %10.4f}\n' % (index, x, y, z, w))
+            index += 1
+        sys.stdout.flush()
+
+    def set_constant_buffer(self, shader, index, buffer):
+        if buffer is not None:
+            self.real.set_constant_buffer(shader, index, buffer)
+
+            self.dump_constant_buffer(buffer)
+
+    def set_framebuffer_state(self, state):
+        _state = gallium.Framebuffer()
+        _state.width = state.width
+        _state.height = state.height
+        _state.nr_cbufs = state.nr_cbufs
+        for i in range(len(state.cbufs)):
+            _state.set_cbuf(i, state.cbufs[i])
+        _state.set_zsbuf(state.zsbuf)    
+        self.real.set_framebuffer(_state)
+        
+        self.cbufs = state.cbufs
+        self.zsbuf = state.zsbuf
+
+    def set_polygon_stipple(self, state):
+        self.real.set_polygon_stipple(state)
+
+    def set_scissor_state(self, state):
+        self.real.set_scissor(state)
+
+    def set_viewport_state(self, state):
+        self.real.set_viewport(state)
+
+    def create_sampler_view(self, texture, templ):
+        return self.real.create_sampler_view(texture,
+                       format = templ.format,
+                       first_level = templ.first_level,
+                       last_level = templ.last_level,
+                       swizzle_r = templ.swizzle_r,
+                       swizzle_g = templ.swizzle_r,
+                       swizzle_b = templ.swizzle_g,
+                       swizzle_a = templ.swizzle_a)
+
+    def set_fragment_sampler_views(self, num, views):
+        for i in range(num):
+            self.real.set_fragment_sampler_view(i, views[i])
+
+    def set_vertex_sampler_views(self, num, views):
+        for i in range(num):
+            self.real.set_vertex_sampler_view(i, views[i])
+
+    def set_vertex_buffers(self, num_buffers, buffers):
+        self.vbufs = buffers[0:num_buffers]
+        for i in range(num_buffers):
+            vbuf = buffers[i]
+            self.real.set_vertex_buffer(
+                i,
+                stride = vbuf.stride,
+                max_index = vbuf.max_index,
+                buffer_offset = vbuf.buffer_offset,
+                buffer = vbuf.buffer,
+            )
+            
+    def create_vertex_elements_state(self, num_elements, elements):
+        return elements[0:num_elements]
+
+    def bind_vertex_elements_state(self, state):
+        elements = state
+        num_elements = len(elements)
+        self.velems = elements
+        for i in range(num_elements):
+            self.real.set_vertex_element(i, elements[i])
+        self.real.set_vertex_elements(num_elements)
+
+    def delete_vertex_elements_state(self, state):
+        pass
+
+    def dump_vertices(self, start, count):
+        if not self.interpreter.verbosity(2):
+            return
+
+        for index in range(start, start + count):
+            if index >= start + 16:
+                sys.stdout.write('\t...\n')
+                break
+            sys.stdout.write('\t{\n')
+            for velem in self.velems:
+                vbuf = self.vbufs[velem.vertex_buffer_index]
+
+                offset = vbuf.buffer_offset + velem.src_offset + vbuf.stride*index
+                format = {
+                    gallium.PIPE_FORMAT_R32_FLOAT: 'f',
+                    gallium.PIPE_FORMAT_R32G32_FLOAT: '2f',
+                    gallium.PIPE_FORMAT_R32G32B32_FLOAT: '3f',
+                    gallium.PIPE_FORMAT_R32G32B32A32_FLOAT: '4f',
+                    gallium.PIPE_FORMAT_A8R8G8B8_UNORM: '4B',
+                    gallium.PIPE_FORMAT_R8G8B8A8_UNORM: '4B',
+                    gallium.PIPE_FORMAT_R16G16B16_SNORM: '3h',
+                }[velem.src_format]
+
+                data = vbuf.buffer.read()
+                values = unpack_from(format, data, offset)
+                sys.stdout.write('\t\t{' + ', '.join(map(str, values)) + '},\n')
+            sys.stdout.write('\t},\n')
+        sys.stdout.flush()
+
+    def dump_indices(self, ibuf, isize, start, count):
+        if not self.interpreter.verbosity(2):
+            return
+
+        format = {
+            1: 'B',
+            2: 'H',
+            4: 'I',
+        }[isize]
+
+        assert struct.calcsize(format) == isize
+
+        data = ibuf.read()
+        maxindex, minindex = 0, 0xffffffff
+
+        sys.stdout.write('\t{\n')
+        for i in range(start, start + count):
+            if i >= start + 16 and not self.interpreter.verbosity(3):
+                sys.stdout.write('\t...\n')
+                break
+            offset = i*isize
+            index, = unpack_from(format, data, offset)
+            sys.stdout.write('\t\t%u,\n' % index)
+            minindex = min(minindex, index)
+            maxindex = max(maxindex, index)
+        sys.stdout.write('\t},\n')
+        sys.stdout.flush()
+
+        return minindex, maxindex
+
+    def draw_arrays(self, mode, start, count):
+        self.dump_vertices(start, count)
+            
+        self.real.draw_arrays(mode, start, count)
+        self._set_dirty()
+    
+    def draw_elements(self, indexBuffer, indexSize, mode, start, count):
+        if self.interpreter.verbosity(2):
+            minindex, maxindex = self.dump_indices(indexBuffer, indexSize, start, count)
+            self.dump_vertices(minindex, maxindex - minindex)
+
+        self.real.draw_elements(indexBuffer, indexSize, mode, start, count)
+        self._set_dirty()
+        
+    def draw_range_elements(self, indexBuffer, indexSize, minIndex, maxIndex, mode, start, count):
+        if self.interpreter.verbosity(2):
+            minindex, maxindex = self.dump_indices(indexBuffer, indexSize, start, count)
+            minindex = min(minindex, minIndex)
+            maxindex = min(maxindex, maxIndex)
+            self.dump_vertices(minindex, maxindex - minindex)
+
+        self.real.draw_range_elements(indexBuffer, indexSize, minIndex, maxIndex, mode, start, count)
+        self._set_dirty()
+        
+    def surface_copy(self, dest, destx, desty, src, srcx, srcy, width, height):
+        if dest is not None and src is not None:
+            if self.interpreter.options.all:
+                self.interpreter.present(self.real, src, 'surface_copy_src', srcx, srcy, width, height)
+            self.real.surface_copy(dest, destx, desty, src, srcx, srcy, width, height)
+            if dest in self.cbufs:
+                self._set_dirty()
+                flags = gallium.PIPE_FLUSH_FRAME
+            else:
+                flags = 0
+            self.flush(flags)
+            if self.interpreter.options.all:
+                self.interpreter.present(self.real, dest, 'surface_copy_dest', destx, desty, width, height)
+
+    def is_resource_referenced(self, texture, face, level):
+        #return self.real.is_resource_referenced(format, texture, face, level)
+        pass
+    
+    def buffer_write(self, buffer, data, size, offset=0):
+        assert size == len(data)
+        self.buffer_write(buffer, data)
+
+    def surface_write(self, surface, data, stride, size):
+        if surface is None:
+            return
+#        assert surface.nblocksy * stride == size 
+        surface.put_tile_raw(0, 0, surface.width, surface.height, data, stride)
+
+    def get_transfer(self, texture, sr, usage, box):
+        if texture is None:
+            return None
+        transfer = Transfer(texture, sr, usage, box)
+        if transfer and usage & gallium.PIPE_TRANSFER_READ:
+            if self.interpreter.options.all:
+                surface = texture.get_surface(sr.face, sr.level, box.z)
+                self.interpreter.present(self.real, transfer.surface, 'transf_read', box.x, box.y, box.w, box.h)
+        return transfer
+    
+    def tex_transfer_destroy(self, transfer):
+        self.interpreter.unregister_object(transfer)
+
+    def transfer_write(self, transfer, data, size):
+        if transfer is None:
+            return
+        self.real.transfer_inline_write(resource, sr, usage, box, data, stride, slice_stride)
+        self.transfertransfer.surface.put_tile_raw(transfer.x, transfer.y, transfer.w, transfer.h, data, transfer.stride)
+        if self.interpreter.options.all:
+            box = transfer.box
+            surface = transfer.resource.get_surface(sr.face, sr.level, box.z)
+            self.interpreter.present(self.real, transfer.surface, 'transf_write', box.x, box.y, box.w, box.h)
+
+    def transfer_inline_write(self, resource, sr, usage, box, stride, slice_stride, data):
+        self.real.transfer_inline_write(resource, sr, usage, box, data, stride, slice_stride)
+
+    def _set_dirty(self):
+        if self.interpreter.options.step:
+            self._present()
+        else:
+            self.dirty = True
+
+    def flush(self, flags):
+        self.real.flush(flags)
+        if self.dirty:
+            if flags & gallium.PIPE_FLUSH_FRAME:
+                self._present()
+            self.dirty = False
+        return None
+
+    def clear(self, buffers, rgba, depth, stencil):
+        _rgba = gallium.FloatArray(4)
+        for i in range(4):
+            _rgba[i] = rgba[i]
+        self.real.clear(buffers, _rgba, depth, stencil)
+        
+    def _present(self):
+        self.real.flush()
+    
+        if self.cbufs and self.cbufs[0]:
+            self.interpreter.present(self.real, self.cbufs[0], "cbuf")
+        if self.zsbuf:
+            if self.interpreter.options.all:
+                self.interpreter.present(self.real, self.zsbuf, "zsbuf")
+    
+
+class Interpreter(parser.TraceDumper):
+    
+    ignore_calls = set((
+            ('pipe_screen', 'is_format_supported'),
+            ('pipe_screen', 'get_param'),
+            ('pipe_screen', 'get_paramf'),
+    ))
+
+    def __init__(self, stream, options):
+        parser.TraceDumper.__init__(self, stream)
+        self.options = options
+        self.objects = {}
+        self.result = None
+        self.globl = Global(self, None)
+        self.call_no = None
+
+    def register_object(self, address, object):
+        self.objects[address] = object
+        
+    def unregister_object(self, object):
+        # FIXME:
+        pass
+
+    def lookup_object(self, address):
+        return self.objects[address]
+    
+    def interpret(self, trace):
+        for call in trace.calls:
+            self.interpret_call(call)
+
+    def handle_call(self, call):
+        if self.options.stop and call.no > self.options.stop:
+            sys.exit(0)
+
+        if (call.klass, call.method) in self.ignore_calls:
+            return
+
+        self.call_no = call.no
+
+        if self.verbosity(1):
+            parser.TraceDumper.handle_call(self, call)
+            sys.stdout.flush()
+        
+        args = [(str(name), self.interpret_arg(arg)) for name, arg in call.args] 
+        
+        if call.klass:
+            name, obj = args[0]
+            args = args[1:]
+        else:
+            obj = self.globl
+            
+        method = getattr(obj, call.method)
+        ret = method(**dict(args))
+        
+        if call.ret and isinstance(call.ret, model.Pointer):
+            if ret is None:
+                sys.stderr.write('warning: NULL returned\n')
+            self.register_object(call.ret.address, ret)
+
+        self.call_no = None
+
+    def interpret_arg(self, node):
+        translator = Translator(self)
+        return translator.visit(node)
+
+    def verbosity(self, level):
+        return self.options.verbosity >= level
+
+    def present(self, ctx, surface, description, x=None, y=None, w=None, h=None):
+        if self.call_no < self.options.start:
+            return
+
+        if self.options.images:
+            filename = '%04u_%s.png' % (self.call_no, description)
+            save_image(ctx, filename, surface, x, y, w, h)
+        else:
+            title = '%u. %s' % (self.call_no, description)
+            show_image(ctx, surface, title, x, y, w, h)
+    
+
+class Main(parser.Main):
+
+    def get_optparser(self):
+        optparser = parser.Main.get_optparser(self)
+        optparser.add_option("-q", "--quiet", action="store_const", const=0, dest="verbosity", help="no messages")
+        optparser.add_option("-v", "--verbose", action="count", dest="verbosity", default=1, help="increase verbosity level")
+        optparser.add_option("-i", "--images", action="store_true", dest="images", default=False, help="save images instead of showing them")
+        optparser.add_option("-a", "--all", action="store_true", dest="all", default=False, help="show depth, stencil, and transfers")
+        optparser.add_option("-s", "--step", action="store_true", dest="step", default=False, help="step trhough every draw")
+        optparser.add_option("-f", "--from", action="store", type="int", dest="start", default=0, help="from call no")
+        optparser.add_option("-t", "--to", action="store", type="int", dest="stop", default=0, help="until call no")
+        return optparser
+
+    def process_arg(self, stream, options):
+        parser = Interpreter(stream, options)
+        parser.parse()
+
+
+if __name__ == '__main__':
+    Main().main()
diff --git a/src/gallium/tests/python/retrace/model.py b/src/gallium/tests/python/retrace/model.py
new file mode 100755
index 00000000000..d4a079fb1e5
--- /dev/null
+++ b/src/gallium/tests/python/retrace/model.py
@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2008 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.
+# 
+##########################################################################
+
+
+'''Trace data model.'''
+
+
+import sys
+import string
+import format
+
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from StringIO import StringIO
+
+
+class Node:
+    
+    def visit(self, visitor):
+        raise NotImplementedError
+
+    def __str__(self):
+        stream = StringIO()
+        formatter = format.DefaultFormatter(stream)
+        pretty_printer = PrettyPrinter(formatter)
+        self.visit(pretty_printer)
+        return stream.getvalue()
+
+
+class Literal(Node):
+    
+    def __init__(self, value):
+        self.value = value
+
+    def visit(self, visitor):
+        visitor.visit_literal(self)
+
+
+class NamedConstant(Node):
+    
+    def __init__(self, name):
+        self.name = name
+
+    def visit(self, visitor):
+        visitor.visit_named_constant(self)
+    
+
+class Array(Node):
+    
+    def __init__(self, elements):
+        self.elements = elements
+
+    def visit(self, visitor):
+        visitor.visit_array(self)
+
+
+class Struct(Node):
+    
+    def __init__(self, name, members):
+        self.name = name
+        self.members = members        
+
+    def visit(self, visitor):
+        visitor.visit_struct(self)
+
+        
+class Pointer(Node):
+    
+    def __init__(self, address):
+        self.address = address
+
+    def visit(self, visitor):
+        visitor.visit_pointer(self)
+
+
+class Call:
+    
+    def __init__(self, no, klass, method, args, ret):
+        self.no = no
+        self.klass = klass
+        self.method = method
+        self.args = args
+        self.ret = ret
+        
+    def visit(self, visitor):
+        visitor.visit_call(self)
+
+
+class Trace:
+    
+    def __init__(self, calls):
+        self.calls = calls
+        
+    def visit(self, visitor):
+        visitor.visit_trace(self)
+    
+    
+class Visitor:
+    
+    def visit_literal(self, node):
+        raise NotImplementedError
+    
+    def visit_named_constant(self, node):
+        raise NotImplementedError
+    
+    def visit_array(self, node):
+        raise NotImplementedError
+    
+    def visit_struct(self, node):
+        raise NotImplementedError
+    
+    def visit_pointer(self, node):
+        raise NotImplementedError
+    
+    def visit_call(self, node):
+        raise NotImplementedError
+    
+    def visit_trace(self, node):
+        raise NotImplementedError
+
+
+class PrettyPrinter:
+
+    def __init__(self, formatter):
+        self.formatter = formatter
+    
+    def visit_literal(self, node):
+        if isinstance(node.value, basestring):
+            if len(node.value) >= 4096 or node.value.strip(string.printable):
+                self.formatter.text('...')
+                return
+
+            self.formatter.literal('"' + node.value + '"')
+            return
+
+        self.formatter.literal(repr(node.value))
+    
+    def visit_named_constant(self, node):
+        self.formatter.literal(node.name)
+    
+    def visit_array(self, node):
+        self.formatter.text('{')
+        sep = ''
+        for value in node.elements:
+            self.formatter.text(sep)
+            value.visit(self) 
+            sep = ', '
+        self.formatter.text('}')
+    
+    def visit_struct(self, node):
+        self.formatter.text('{')
+        sep = ''
+        for name, value in node.members:
+            self.formatter.text(sep)
+            self.formatter.variable(name)
+            self.formatter.text(' = ')
+            value.visit(self) 
+            sep = ', '
+        self.formatter.text('}')
+    
+    def visit_pointer(self, node):
+        self.formatter.address(node.address)
+    
+    def visit_call(self, node):
+        self.formatter.text('%s ' % node.no)
+        if node.klass is not None:
+            self.formatter.function(node.klass + '::' + node.method)
+        else:
+            self.formatter.function(node.method)
+        self.formatter.text('(')
+        sep = ''
+        for name, value in node.args:
+            self.formatter.text(sep)
+            self.formatter.variable(name)
+            self.formatter.text(' = ')
+            value.visit(self) 
+            sep = ', '
+        self.formatter.text(')')
+        if node.ret is not None:
+            self.formatter.text(' = ')
+            node.ret.visit(self)
+    
+    def visit_trace(self, node):
+        for call in node.calls:
+            call.visit(self)
+            self.formatter.newline()
+
diff --git a/src/gallium/tests/python/retrace/parse.py b/src/gallium/tests/python/retrace/parse.py
new file mode 100755
index 00000000000..b08d3686715
--- /dev/null
+++ b/src/gallium/tests/python/retrace/parse.py
@@ -0,0 +1,392 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2008 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.
+# 
+##########################################################################
+
+
+import sys
+import xml.parsers.expat
+import binascii
+import optparse
+
+from model import *
+
+
+ELEMENT_START, ELEMENT_END, CHARACTER_DATA, EOF = range(4)
+
+
+class XmlToken:
+
+    def __init__(self, type, name_or_data, attrs = None, line = None, column = None):
+        assert type in (ELEMENT_START, ELEMENT_END, CHARACTER_DATA, EOF)
+        self.type = type
+        self.name_or_data = name_or_data
+        self.attrs = attrs
+        self.line = line
+        self.column = column
+
+    def __str__(self):
+        if self.type == ELEMENT_START:
+            return '<' + self.name_or_data + ' ...>'
+        if self.type == ELEMENT_END:
+            return '</' + self.name_or_data + '>'
+        if self.type == CHARACTER_DATA:
+            return self.name_or_data
+        if self.type == EOF:
+            return 'end of file'
+        assert 0
+
+
+class XmlTokenizer:
+    """Expat based XML tokenizer."""
+
+    def __init__(self, fp, skip_ws = True):
+        self.fp = fp
+        self.tokens = []
+        self.index = 0
+        self.final = False
+        self.skip_ws = skip_ws
+        
+        self.character_pos = 0, 0
+        self.character_data = ''
+        
+        self.parser = xml.parsers.expat.ParserCreate()
+        self.parser.StartElementHandler  = self.handle_element_start
+        self.parser.EndElementHandler    = self.handle_element_end
+        self.parser.CharacterDataHandler = self.handle_character_data
+    
+    def handle_element_start(self, name, attributes):
+        self.finish_character_data()
+        line, column = self.pos()
+        token = XmlToken(ELEMENT_START, name, attributes, line, column)
+        self.tokens.append(token)
+    
+    def handle_element_end(self, name):
+        self.finish_character_data()
+        line, column = self.pos()
+        token = XmlToken(ELEMENT_END, name, None, line, column)
+        self.tokens.append(token)
+
+    def handle_character_data(self, data):
+        if not self.character_data:
+            self.character_pos = self.pos()
+        self.character_data += data
+    
+    def finish_character_data(self):
+        if self.character_data:
+            if not self.skip_ws or not self.character_data.isspace(): 
+                line, column = self.character_pos
+                token = XmlToken(CHARACTER_DATA, self.character_data, None, line, column)
+                self.tokens.append(token)
+            self.character_data = ''
+    
+    def next(self):
+        size = 16*1024
+        while self.index >= len(self.tokens) and not self.final:
+            self.tokens = []
+            self.index = 0
+            data = self.fp.read(size)
+            self.final = len(data) < size
+            data = data.rstrip('\0')
+            try:
+                self.parser.Parse(data, self.final)
+            except xml.parsers.expat.ExpatError, e:
+                #if e.code == xml.parsers.expat.errors.XML_ERROR_NO_ELEMENTS:
+                if e.code == 3:
+                    pass
+                else:
+                    raise e
+        if self.index >= len(self.tokens):
+            line, column = self.pos()
+            token = XmlToken(EOF, None, None, line, column)
+        else:
+            token = self.tokens[self.index]
+            self.index += 1
+        return token
+
+    def pos(self):
+        return self.parser.CurrentLineNumber, self.parser.CurrentColumnNumber
+
+
+class TokenMismatch(Exception):
+
+    def __init__(self, expected, found):
+        self.expected = expected
+        self.found = found
+
+    def __str__(self):
+        return '%u:%u: %s expected, %s found' % (self.found.line, self.found.column, str(self.expected), str(self.found))
+
+
+
+class XmlParser:
+    """Base XML document parser."""
+
+    def __init__(self, fp):
+        self.tokenizer = XmlTokenizer(fp)
+        self.consume()
+    
+    def consume(self):
+        self.token = self.tokenizer.next()
+
+    def match_element_start(self, name):
+        return self.token.type == ELEMENT_START and self.token.name_or_data == name
+    
+    def match_element_end(self, name):
+        return self.token.type == ELEMENT_END and self.token.name_or_data == name
+
+    def element_start(self, name):
+        while self.token.type == CHARACTER_DATA:
+            self.consume()
+        if self.token.type != ELEMENT_START:
+            raise TokenMismatch(XmlToken(ELEMENT_START, name), self.token)
+        if self.token.name_or_data != name:
+            raise TokenMismatch(XmlToken(ELEMENT_START, name), self.token)
+        attrs = self.token.attrs
+        self.consume()
+        return attrs
+    
+    def element_end(self, name):
+        while self.token.type == CHARACTER_DATA:
+            self.consume()
+        if self.token.type != ELEMENT_END:
+            raise TokenMismatch(XmlToken(ELEMENT_END, name), self.token)
+        if self.token.name_or_data != name:
+            raise TokenMismatch(XmlToken(ELEMENT_END, name), self.token)
+        self.consume()
+
+    def character_data(self, strip = True):
+        data = ''
+        while self.token.type == CHARACTER_DATA:
+            data += self.token.name_or_data
+            self.consume()
+        if strip:
+            data = data.strip()
+        return data
+
+
+class TraceParser(XmlParser):
+
+    def __init__(self, fp):
+        XmlParser.__init__(self, fp)
+        self.last_call_no = 0
+    
+    def parse(self):
+        self.element_start('trace')
+        while self.token.type not in (ELEMENT_END, EOF):
+            call = self.parse_call()
+            self.handle_call(call)
+        if self.token.type != EOF:
+            self.element_end('trace')
+
+    def parse_call(self):
+        attrs = self.element_start('call')
+        try:
+            no = int(attrs['no'])
+        except KeyError:
+            self.last_call_no += 1
+            no = self.last_call_no
+        else:
+            self.last_call_no = no
+        klass = attrs['class']
+        method = attrs['method']
+        args = []
+        ret = None
+        while self.token.type == ELEMENT_START:
+            if self.token.name_or_data == 'arg':
+                arg = self.parse_arg()
+                args.append(arg)
+            elif self.token.name_or_data == 'ret':
+                ret = self.parse_ret()
+            elif self.token.name_or_data == 'call':
+                # ignore nested function calls
+                self.parse_call()
+            else:
+                raise TokenMismatch("<arg ...> or <ret ...>", self.token)
+        self.element_end('call')
+        
+        return Call(no, klass, method, args, ret)
+
+    def parse_arg(self):
+        attrs = self.element_start('arg')
+        name = attrs['name']
+        value = self.parse_value()
+        self.element_end('arg')
+
+        return name, value
+
+    def parse_ret(self):
+        attrs = self.element_start('ret')
+        value = self.parse_value()
+        self.element_end('ret')
+
+        return value
+
+    def parse_value(self):
+        expected_tokens = ('null', 'bool', 'int', 'uint', 'float', 'string', 'enum', 'array', 'struct', 'ptr', 'bytes')
+        if self.token.type == ELEMENT_START:
+            if self.token.name_or_data in expected_tokens:
+                method = getattr(self, 'parse_' +  self.token.name_or_data)
+                return method()
+        raise TokenMismatch(" or " .join(expected_tokens), self.token)
+
+    def parse_null(self):
+        self.element_start('null')
+        self.element_end('null')
+        return Literal(None)
+        
+    def parse_bool(self):
+        self.element_start('bool')
+        value = int(self.character_data())
+        self.element_end('bool')
+        return Literal(value)
+        
+    def parse_int(self):
+        self.element_start('int')
+        value = int(self.character_data())
+        self.element_end('int')
+        return Literal(value)
+        
+    def parse_uint(self):
+        self.element_start('uint')
+        value = int(self.character_data())
+        self.element_end('uint')
+        return Literal(value)
+        
+    def parse_float(self):
+        self.element_start('float')
+        value = float(self.character_data())
+        self.element_end('float')
+        return Literal(value)
+        
+    def parse_enum(self):
+        self.element_start('enum')
+        name = self.character_data()
+        self.element_end('enum')
+        return NamedConstant(name)
+        
+    def parse_string(self):
+        self.element_start('string')
+        value = self.character_data()
+        self.element_end('string')
+        return Literal(value)
+        
+    def parse_bytes(self):
+        self.element_start('bytes')
+        value = binascii.a2b_hex(self.character_data())
+        self.element_end('bytes')
+        return Literal(value)
+        
+    def parse_array(self):
+        self.element_start('array')
+        elems = []
+        while self.token.type != ELEMENT_END:
+            elems.append(self.parse_elem())
+        self.element_end('array')
+        return Array(elems)
+
+    def parse_elem(self):
+        self.element_start('elem')
+        value = self.parse_value()
+        self.element_end('elem')
+        return value
+
+    def parse_struct(self):
+        attrs = self.element_start('struct')
+        name = attrs['name']
+        members = []
+        while self.token.type != ELEMENT_END:
+            members.append(self.parse_member())
+        self.element_end('struct')
+        return Struct(name, members)
+
+    def parse_member(self):
+        attrs = self.element_start('member')
+        name = attrs['name']
+        value = self.parse_value()
+        self.element_end('member')
+
+        return name, value
+
+    def parse_ptr(self):
+        self.element_start('ptr')
+        address = self.character_data()
+        self.element_end('ptr')
+
+        return Pointer(address)
+
+    def handle_call(self, call):
+        pass
+    
+    
+class TraceDumper(TraceParser):
+    
+    def __init__(self, fp):
+        TraceParser.__init__(self, fp)
+        self.formatter = format.DefaultFormatter(sys.stdout)
+        self.pretty_printer = PrettyPrinter(self.formatter)
+
+    def handle_call(self, call):
+        call.visit(self.pretty_printer)
+        self.formatter.newline()
+        
+
+class Main:
+    '''Common main class for all retrace command line utilities.''' 
+
+    def __init__(self):
+        pass
+
+    def main(self):
+        optparser = self.get_optparser()
+        (options, args) = optparser.parse_args(sys.argv[1:])
+    
+        if args:
+            for arg in args:
+                if arg.endswith('.gz'):
+                    from gzip import GzipFile
+                    stream = GzipFile(arg, 'rt')
+                elif arg.endswith('.bz2'):
+                    from bz2 import BZ2File
+                    stream = BZ2File(arg, 'rU')
+                else:
+                    stream = open(arg, 'rt')
+                self.process_arg(stream, options)
+        else:
+            self.process_arg(stream, options)
+
+    def get_optparser(self):
+        optparser = optparse.OptionParser(
+            usage="\n\t%prog [options] [traces] ...")
+        return optparser
+
+    def process_arg(self, stream, options):
+        parser = TraceDumper(stream)
+        parser.parse()
+
+
+if __name__ == '__main__':
+    Main().main()
diff --git a/src/gallium/tests/python/retrace/parser.py b/src/gallium/tests/python/retrace/parser.py
new file mode 100755
index 00000000000..bd47c9a6b06
--- /dev/null
+++ b/src/gallium/tests/python/retrace/parser.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2008 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.
+# 
+##########################################################################
+
+
+from parse import *
+
+
+if __name__ == '__main__':
+    Main().main()
diff --git a/src/gallium/tests/python/samples/gs.py b/src/gallium/tests/python/samples/gs.py
new file mode 100644
index 00000000000..936c0b3f33a
--- /dev/null
+++ b/src/gallium/tests/python/samples/gs.py
@@ -0,0 +1,254 @@
+#!/usr/bin/env python
+##########################################################################
+#
+# Copyright 2009 VMware
+# 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.
+#
+##########################################################################
+
+
+from gallium import *
+
+
+def make_image(surface):
+    data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
+
+    import Image
+    outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
+    return outimage
+
+def save_image(filename, surface):
+    outimage = make_image(surface)
+    outimage.save(filename, "PNG")
+
+def show_image(surface):
+    outimage = make_image(surface)
+
+    import Tkinter as tk
+    from PIL import Image, ImageTk
+    root = tk.Tk()
+
+    root.title('background image')
+
+    image1 = ImageTk.PhotoImage(outimage)
+    w = image1.width()
+    h = image1.height()
+    x = 100
+    y = 100
+    root.geometry("%dx%d+%d+%d" % (w, h, x, y))
+    panel1 = tk.Label(root, image=image1)
+    panel1.pack(side='top', fill='both', expand='yes')
+    panel1.image = image1
+    root.mainloop()
+
+
+def test(dev):
+    ctx = dev.context_create()
+
+    width = 255
+    height = 255
+    minz = 0.0
+    maxz = 1.0
+
+    # disabled blending/masking
+    blend = Blend()
+    blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
+    blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
+    blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
+    blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
+    blend.rt[0].colormask = PIPE_MASK_RGBA
+    ctx.set_blend(blend)
+
+    # depth/stencil/alpha
+    depth_stencil_alpha = DepthStencilAlpha()
+    depth_stencil_alpha.depth.enabled = 1
+    depth_stencil_alpha.depth.writemask = 1
+    depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
+    ctx.set_depth_stencil_alpha(depth_stencil_alpha)
+
+    # rasterizer
+    rasterizer = Rasterizer()
+    rasterizer.front_winding = PIPE_WINDING_CW
+    rasterizer.cull_mode = PIPE_WINDING_NONE
+    rasterizer.scissor = 1
+    ctx.set_rasterizer(rasterizer)
+
+    # viewport
+    viewport = Viewport()
+    scale = FloatArray(4)
+    scale[0] = width / 2.0
+    scale[1] = -height / 2.0
+    scale[2] = (maxz - minz) / 2.0
+    scale[3] = 1.0
+    viewport.scale = scale
+    translate = FloatArray(4)
+    translate[0] = width / 2.0
+    translate[1] = height / 2.0
+    translate[2] = (maxz - minz) / 2.0
+    translate[3] = 0.0
+    viewport.translate = translate
+    ctx.set_viewport(viewport)
+
+    # samplers
+    sampler = Sampler()
+    sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
+    sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+    sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+    sampler.normalized_coords = 1
+    ctx.set_sampler(0, sampler)
+
+    # scissor
+    scissor = Scissor()
+    scissor.minx = 0
+    scissor.miny = 0
+    scissor.maxx = width
+    scissor.maxy = height
+    ctx.set_scissor(scissor)
+
+    clip = Clip()
+    clip.nr = 0
+    ctx.set_clip(clip)
+
+    # framebuffer
+    cbuf = dev.resource_create(
+        PIPE_FORMAT_B8G8R8X8_UNORM,
+        width, height,
+        bind=PIPE_BIND_RENDER_TARGET,
+    ).get_surface()
+    zbuf = dev.resource_create(
+        PIPE_FORMAT_Z32_UNORM,
+        width, height,
+        bind=PIPE_BIND_DEPTH_STENCIL,
+    ).get_surface()
+    fb = Framebuffer()
+    fb.width = width
+    fb.height = height
+    fb.nr_cbufs = 1
+    fb.set_cbuf(0, cbuf)
+    fb.set_zsbuf(zbuf)
+    ctx.set_framebuffer(fb)
+    rgba = FloatArray(4);
+    rgba[0] = 0.0
+    rgba[1] = 0.0
+    rgba[2] = 0.0
+    rgba[3] = 0.0
+    ctx.clear(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTHSTENCIL, rgba, 1.0, 0xff)
+
+    # vertex shader
+    vs = Shader('''
+        VERT
+        DCL IN[0], POSITION, CONSTANT
+        DCL IN[1], COLOR, CONSTANT
+        DCL OUT[0], POSITION, CONSTANT
+        DCL OUT[1], COLOR, CONSTANT
+        0:MOV OUT[0], IN[0]
+        1:MOV OUT[1], IN[1]
+        2:END
+    ''')
+    ctx.set_vertex_shader(vs)
+
+    gs = Shader('''
+        GEOM
+        PROPERTY GS_INPUT_PRIMITIVE TRIANGLES
+        PROPERTY GS_OUTPUT_PRIMITIVE TRIANGLE_STRIP
+        DCL IN[][0], POSITION, CONSTANT
+        DCL IN[][1], COLOR, CONSTANT
+        DCL OUT[0], POSITION, CONSTANT
+        DCL OUT[1], COLOR, CONSTANT
+        0:MOV OUT[0], IN[0][0]
+        1:MOV OUT[1], IN[0][1]
+        2:EMIT
+        3:MOV OUT[0], IN[1][0]
+        4:MOV OUT[1], IN[1][1]
+        5:EMIT
+        6:MOV OUT[0], IN[2][0]
+        7:MOV OUT[1], IN[2][1]
+        8:EMIT
+        9:ENDPRIM
+        10:END
+    ''')
+    ctx.set_geometry_shader(gs)
+
+    # fragment shader
+    fs = Shader('''
+        FRAG
+        DCL IN[0], COLOR, LINEAR
+        DCL OUT[0], COLOR, CONSTANT
+        0:MOV OUT[0], IN[0]
+        1:END
+    ''')
+    ctx.set_fragment_shader(fs)
+
+    nverts = 3
+    nattrs = 2
+    verts = FloatArray(nverts * nattrs * 4)
+
+    verts[ 0] =   0.0 # x1
+    verts[ 1] =   0.8 # y1
+    verts[ 2] =   0.2 # z1
+    verts[ 3] =   1.0 # w1
+    verts[ 4] =   1.0 # r1
+    verts[ 5] =   0.0 # g1
+    verts[ 6] =   0.0 # b1
+    verts[ 7] =   1.0 # a1
+    verts[ 8] =  -0.8 # x2
+    verts[ 9] =  -0.8 # y2
+    verts[10] =   0.5 # z2
+    verts[11] =   1.0 # w2
+    verts[12] =   0.0 # r2
+    verts[13] =   1.0 # g2
+    verts[14] =   0.0 # b2
+    verts[15] =   1.0 # a2
+    verts[16] =   0.8 # x3
+    verts[17] =  -0.8 # y3
+    verts[18] =   0.8 # z3
+    verts[19] =   1.0 # w3
+    verts[20] =   0.0 # r3
+    verts[21] =   0.0 # g3
+    verts[22] =   1.0 # b3
+    verts[23] =   1.0 # a3
+
+    ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
+                      nverts,
+                      nattrs,
+                      verts)
+
+    ctx.flush()
+
+    show_image(cbuf)
+    #show_image(zbuf)
+    #save_image('cbuf.png', cbuf)
+    #save_image('zbuf.png', zbuf)
+
+
+
+def main():
+    dev = Device()
+    test(dev)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/tests/python/samples/tri.py b/src/gallium/tests/python/samples/tri.py
new file mode 100644
index 00000000000..fed929d4200
--- /dev/null
+++ b/src/gallium/tests/python/samples/tri.py
@@ -0,0 +1,233 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2008 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.
+# 
+##########################################################################
+
+
+from gallium import *
+
+
+def make_image(ctx, surface):
+    data = ctx.surface_read_rgba8(surface, 0, 0, surface.width, surface.height)
+
+    import Image
+    outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
+    return outimage
+
+def save_image(ctx, surface, filename):
+    outimage = make_image(ctx, surface)
+    outimage.save(filename, "PNG")
+
+def show_image(ctx, surface):
+    outimage = make_image(ctx, surface)
+    
+    import Tkinter as tk
+    from PIL import Image, ImageTk
+    root = tk.Tk()
+    
+    root.title('background image')
+    
+    image1 = ImageTk.PhotoImage(outimage)
+    w = image1.width()
+    h = image1.height()
+    x = 100
+    y = 100
+    root.geometry("%dx%d+%d+%d" % (w, h, x, y))
+    panel1 = tk.Label(root, image=image1)
+    panel1.pack(side='top', fill='both', expand='yes')
+    panel1.image = image1
+    root.mainloop()
+
+
+def test(dev):
+    ctx = dev.context_create()
+
+    width = 255
+    height = 255
+    minz = 0.0
+    maxz = 1.0
+
+    # disabled blending/masking
+    blend = Blend()
+    blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
+    blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
+    blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
+    blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
+    blend.rt[0].colormask = PIPE_MASK_RGBA
+    ctx.set_blend(blend)
+
+    # depth/stencil/alpha
+    depth_stencil_alpha = DepthStencilAlpha()
+    depth_stencil_alpha.depth.enabled = 1
+    depth_stencil_alpha.depth.writemask = 1
+    depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
+    ctx.set_depth_stencil_alpha(depth_stencil_alpha)
+
+    # rasterizer
+    rasterizer = Rasterizer()
+    rasterizer.front_winding = PIPE_WINDING_CW
+    rasterizer.cull_mode = PIPE_WINDING_NONE
+    rasterizer.scissor = 1
+    ctx.set_rasterizer(rasterizer)
+
+    # viewport
+    viewport = Viewport()
+    scale = FloatArray(4)
+    scale[0] = width / 2.0
+    scale[1] = -height / 2.0
+    scale[2] = (maxz - minz) / 2.0
+    scale[3] = 1.0
+    viewport.scale = scale
+    translate = FloatArray(4)
+    translate[0] = width / 2.0
+    translate[1] = height / 2.0
+    translate[2] = (maxz - minz) / 2.0
+    translate[3] = 0.0
+    viewport.translate = translate
+    ctx.set_viewport(viewport)
+
+    # samplers
+    sampler = Sampler()
+    sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
+    sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+    sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+    sampler.normalized_coords = 1
+    ctx.set_fragment_sampler(0, sampler)
+
+    # scissor
+    scissor = Scissor()
+    scissor.minx = 0
+    scissor.miny = 0
+    scissor.maxx = width
+    scissor.maxy = height
+    ctx.set_scissor(scissor)
+
+    # clip
+    clip = Clip()
+    clip.nr = 0
+    ctx.set_clip(clip)
+
+    # framebuffer
+    cbuf = dev.resource_create(
+        PIPE_FORMAT_B8G8R8X8_UNORM, 
+        width, height,
+        bind=PIPE_BIND_RENDER_TARGET,
+    ).get_surface()
+    zbuf = dev.resource_create(
+        PIPE_FORMAT_Z32_UNORM,
+        width, height,
+        bind=PIPE_BIND_DEPTH_STENCIL,
+    ).get_surface()
+    fb = Framebuffer()
+    fb.width = width
+    fb.height = height
+    fb.nr_cbufs = 1
+    fb.set_cbuf(0, cbuf)
+    fb.set_zsbuf(zbuf)
+    ctx.set_framebuffer(fb)
+    rgba = FloatArray(4);
+    rgba[0] = 0.0
+    rgba[1] = 0.0
+    rgba[2] = 0.0
+    rgba[3] = 0.0
+    ctx.clear(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTHSTENCIL, rgba, 1.0, 0xff)
+    
+    # vertex shader
+    vs = Shader('''
+        VERT
+        DCL IN[0], POSITION, CONSTANT
+        DCL IN[1], COLOR, CONSTANT
+        DCL OUT[0], POSITION, CONSTANT
+        DCL OUT[1], COLOR, CONSTANT
+        0:MOV OUT[0], IN[0]
+        1:MOV OUT[1], IN[1]
+        2:END
+    ''')
+    ctx.set_vertex_shader(vs)
+
+    # fragment shader
+    fs = Shader('''
+        FRAG
+        DCL IN[0], COLOR, LINEAR
+        DCL OUT[0], COLOR, CONSTANT
+        0:MOV OUT[0], IN[0]
+        1:END
+    ''')
+    ctx.set_fragment_shader(fs)
+
+    nverts = 3
+    nattrs = 2
+    verts = FloatArray(nverts * nattrs * 4)
+
+    verts[ 0] =   0.0 # x1
+    verts[ 1] =   0.8 # y1
+    verts[ 2] =   0.2 # z1
+    verts[ 3] =   1.0 # w1
+    verts[ 4] =   1.0 # r1
+    verts[ 5] =   0.0 # g1
+    verts[ 6] =   0.0 # b1
+    verts[ 7] =   1.0 # a1
+    verts[ 8] =  -0.8 # x2
+    verts[ 9] =  -0.8 # y2
+    verts[10] =   0.5 # z2
+    verts[11] =   1.0 # w2
+    verts[12] =   0.0 # r2
+    verts[13] =   1.0 # g2
+    verts[14] =   0.0 # b2
+    verts[15] =   1.0 # a2
+    verts[16] =   0.8 # x3
+    verts[17] =  -0.8 # y3
+    verts[18] =   0.8 # z3
+    verts[19] =   1.0 # w3
+    verts[20] =   0.0 # r3
+    verts[21] =   0.0 # g3
+    verts[22] =   1.0 # b3
+    verts[23] =   1.0 # a3
+
+    ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
+                      nverts, 
+                      nattrs, 
+                      verts)
+
+    ctx.flush()
+    
+    show_image(ctx, cbuf)
+    show_image(ctx, zbuf)
+    save_image(ctx, cbuf, 'cbuf.png')
+    save_image(ctx, zbuf, 'zbuf.png')
+
+
+
+def main():
+    dev = Device()
+    test(dev)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/tests/python/tests/.gitignore b/src/gallium/tests/python/tests/.gitignore
new file mode 100644
index 00000000000..0dbbaeea16b
--- /dev/null
+++ b/src/gallium/tests/python/tests/.gitignore
@@ -0,0 +1,3 @@
+*.txt
+*.tsv
+*.dot
diff --git a/src/gallium/tests/python/tests/base.py b/src/gallium/tests/python/tests/base.py
new file mode 100755
index 00000000000..d8cf84db363
--- /dev/null
+++ b/src/gallium/tests/python/tests/base.py
@@ -0,0 +1,399 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2009 VMware, Inc.
+# Copyright 2008 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 VMWARE 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.
+# 
+##########################################################################
+
+
+"""Base classes for tests.
+
+Loosely inspired on Python's unittest module.
+"""
+
+
+import os.path
+import sys
+
+from gallium import *
+
+
+# Enumerate all pixel formats
+formats = {}
+for name, value in globals().items():
+    if name.startswith("PIPE_FORMAT_") and isinstance(value, int) and name not in ("PIPE_FORMAT_NONE", "PIPE_FORMAT_COUNT"):
+        formats[value] = name
+
+def make_image(width, height, rgba):
+    import Image
+    outimage = Image.new(
+        mode='RGB',
+        size=(width, height),
+        color=(0,0,0))
+    outpixels = outimage.load()
+    for y in range(0, height):
+        for x in range(0, width):
+            offset = (y*width + x)*4
+            r, g, b, a = [int(min(max(rgba[offset + ch], 0.0), 1.0)*255) for ch in range(4)]
+            outpixels[x, y] = r, g, b
+    return outimage
+
+def save_image(width, height, rgba, filename):
+    outimage = make_image(width, height, rgba)
+    outimage.save(filename, "PNG")
+
+def show_image(width, height, **rgbas):
+    import Tkinter as tk
+    from PIL import Image, ImageTk
+
+    root = tk.Tk()
+    
+    x = 64
+    y = 64
+    
+    labels = rgbas.keys()
+    labels.sort() 
+    for i in range(len(labels)):
+        label = labels[i]
+        outimage = make_image(width, height, rgbas[label])
+        
+        if i:
+            window = tk.Toplevel(root)
+        else:
+            window = root    
+        window.title(label)
+        image1 = ImageTk.PhotoImage(outimage)
+        w = image1.width()
+        h = image1.height()
+        window.geometry("%dx%d+%d+%d" % (w, h, x, y))
+        panel1 = tk.Label(window, image=image1)
+        panel1.pack(side='top', fill='both', expand='yes')
+        panel1.image = image1
+        x += w + 2
+    
+    root.mainloop()
+
+
+class TestFailure(Exception):
+
+    pass
+
+class TestSkip(Exception):
+    
+    pass
+
+
+class Test:
+
+    def __init__(self):
+        pass
+
+    def _run(self, result):
+        raise NotImplementedError
+    
+    def run(self):
+        result = TestResult()
+        self._run(result)
+        result.report()
+
+    def assert_rgba(self, ctx, surface, x, y, w, h, expected_rgba, pixel_tol=4.0/256, surface_tol=0.85):
+        total = h*w
+        different = ctx.surface_compare_rgba(surface, x, y, w, h, expected_rgba, tol=pixel_tol)
+        if different:
+            sys.stderr.write("%u out of %u pixels differ\n" % (different, total))
+
+        if float(total - different)/float(total) < surface_tol:
+            if 0:
+                rgba = FloatArray(h*w*4)
+                ctx.surface_read_rgba(surface, x, y, w, h, rgba)
+                show_image(w, h, Result=rgba, Expected=expected_rgba)
+                save_image(w, h, rgba, "result.png")
+                save_image(w, h, expected_rgba, "expected.png")
+            #sys.exit(0)
+            
+            raise TestFailure
+
+
+class TestCase(Test):
+    
+    tags = ()
+
+    def __init__(self, dev, **kargs):
+        Test.__init__(self)
+        self.dev = dev
+        self.__dict__.update(kargs)
+
+    def description(self):
+        descriptions = []
+        for tag in self.tags:
+            value = self.get(tag)
+            if value is not None and value != '':
+                descriptions.append(tag + '=' + str(value))
+        return ' '.join(descriptions)
+
+    def get(self, tag):
+        try:
+            method = getattr(self, '_get_' + tag)
+        except AttributeError:
+            return getattr(self, tag, None)
+        else:
+            return method()
+
+    def _get_target(self):
+        return {
+            PIPE_TEXTURE_1D: "1d", 
+            PIPE_TEXTURE_2D: "2d", 
+            PIPE_TEXTURE_3D: "3d", 
+            PIPE_TEXTURE_CUBE: "cube",
+        }[self.target]
+
+    def _get_format(self):
+        name = formats[self.format]
+        if name.startswith('PIPE_FORMAT_'):
+            name  = name[12:]
+        name = name.lower()
+        return name
+
+    def _get_face(self):
+        if self.target == PIPE_TEXTURE_CUBE:
+            return {
+                PIPE_TEX_FACE_POS_X: "+x",
+                PIPE_TEX_FACE_NEG_X: "-x",
+                PIPE_TEX_FACE_POS_Y: "+y",
+                PIPE_TEX_FACE_NEG_Y: "-y", 
+                PIPE_TEX_FACE_POS_Z: "+z", 
+                PIPE_TEX_FACE_NEG_Z: "-z",
+            }[self.face]
+        else:
+            return ''
+
+    def test(self):
+        raise NotImplementedError
+    
+    def _run(self, result):
+        result.test_start(self)
+        try:
+            self.test()
+        except KeyboardInterrupt:
+            raise
+        except TestSkip:
+            result.test_skipped(self)
+        except TestFailure:
+            result.test_failed(self)
+        else:
+            result.test_passed(self)
+
+
+class TestSuite(Test):
+    
+    def __init__(self, tests = None):
+        Test.__init__(self)
+        if tests is None:
+            self.tests = []
+        else:
+            self.tests = tests
+
+    def add_test(self, test):
+        self.tests.append(test) 
+    
+    def _run(self, result):
+        for test in self.tests:
+            test._run(result)
+
+
+class TestResult:
+    
+    def __init__(self):
+        self.tests = 0
+        self.passed = 0
+        self.skipped = 0
+        self.failed = 0
+
+        self.names = ['result']
+        self.types = ['pass skip fail']
+        self.rows = []
+    
+    def test_start(self, test):
+        sys.stdout.write("Running %s...\n" % test.description())
+        sys.stdout.flush()
+        self.tests += 1
+    
+    def test_passed(self, test):
+        sys.stdout.write("PASS\n")
+        sys.stdout.flush()
+        self.passed += 1
+        self.log_result(test, 'pass')
+            
+    def test_skipped(self, test):
+        sys.stdout.write("SKIP\n")
+        sys.stdout.flush()
+        self.skipped += 1
+        self.log_result(test, 'skip')
+        
+    def test_failed(self, test):
+        sys.stdout.write("FAIL\n")
+        sys.stdout.flush()
+        self.failed += 1
+        self.log_result(test, 'fail')
+
+    def log_result(self, test, result):
+        row = ['']*len(self.names)
+
+        # add result
+        assert self.names[0] == 'result'
+        assert result in ('pass', 'skip', 'fail')
+        row[0] = result
+
+        # add tags
+        for tag in test.tags:
+            value = test.get(tag)
+
+            # infer type
+            if value is None:
+                continue
+            elif isinstance(value, (int, float)):
+                value = str(value)
+                type = 'c' # continous
+            elif isinstance(value, basestring):
+                type = 'd' # discrete
+            else:
+                assert False
+                value = str(value)
+                type = 'd' # discrete
+
+            # insert value
+            try:
+                col = self.names.index(tag, 1)
+            except ValueError:
+                self.names.append(tag)
+                self.types.append(type)
+                row.append(value)
+            else:
+                row[col] = value
+                assert self.types[col] == type
+        
+        self.rows.append(row)
+
+    def report(self):
+        sys.stdout.write("%u tests, %u passed, %u skipped, %u failed\n\n" % (self.tests, self.passed, self.skipped, self.failed))
+        sys.stdout.flush()
+
+        name, ext = os.path.splitext(os.path.basename(sys.argv[0]))
+
+        tree = self.report_tree(name)
+        self.report_junit(name, stdout=tree)
+
+    def report_tree(self, name):
+        filename = name + '.tsv'
+        stream = file(filename, 'wt')
+
+        # header
+        stream.write('\t'.join(self.names) + '\n')
+        stream.write('\t'.join(self.types) + '\n')
+        stream.write('class\n')
+
+        # rows
+        for row in self.rows:
+            if row[0] == 'skip':
+                continue
+            row += ['']*(len(self.names) - len(row))
+            stream.write('\t'.join(row) + '\n')
+
+        stream.close()
+
+        # See http://www.ailab.si/orange/doc/ofb/c_otherclass.htm
+        try:
+            import orange
+            import orngTree
+        except ImportError:
+            sys.stderr.write('Install Orange from http://www.ailab.si/orange/ for a classification tree.\n')
+            return None
+
+        data = orange.ExampleTable(filename)
+
+        tree = orngTree.TreeLearner(data, sameMajorityPruning=1, mForPruning=2)
+
+        orngTree.printTxt(tree, maxDepth=4)
+
+        text_tree = orngTree.dumpTree(tree)
+
+        file(name + '.txt', 'wt').write(text_tree)
+
+        orngTree.printDot(tree, fileName=name+'.dot', nodeShape='ellipse', leafShape='box')
+
+        return text_tree
+    
+    def report_junit(self, name, stdout=None, stderr=None):
+        """Write test results in ANT's junit XML format, to use with Hudson CI.
+
+        See also:
+        - http://fisheye.hudson-ci.org/browse/Hudson/trunk/hudson/main/core/src/test/resources/hudson/tasks/junit
+        - http://www.junit.org/node/399
+        - http://wiki.apache.org/ant/Proposals/EnhancedTestReports
+        """
+
+        stream = file(name + '.xml', 'wt')
+
+        stream.write('<?xml version="1.0" encoding="UTF-8" ?>\n')
+        stream.write('<testsuite name="%s">\n' % self.escape_xml(name))
+        stream.write('  <properties>\n')
+        stream.write('  </properties>\n')
+
+        names = self.names[1:]
+
+        for row in self.rows:
+
+            test_name = ' '.join(['%s=%s' % pair for pair in zip(self.names[1:], row[1:])])
+
+            stream.write('  <testcase name="%s">\n' % (self.escape_xml(test_name)))
+
+            result = row[0]
+            if result == 'pass':
+                pass
+            elif result == 'skip':
+                stream.write('    <skipped/>\n')
+            else:
+                stream.write('    <failure/>\n')
+            
+            stream.write('  </testcase>\n')
+
+        if stdout:
+            stream.write('  <system-out>%s</system-out>\n' % self.escape_xml(stdout))
+        if stderr:
+            stream.write('  <system-err>%s</system-err>\n' % self.escape_xml(stderr))
+
+        stream.write('</testsuite>\n')
+
+        stream.close()
+
+    def escape_xml(self, s):
+        '''Escape a XML string.'''
+        s = s.replace('&', '&amp;')
+        s = s.replace('<', '&lt;')
+        s = s.replace('>', '&gt;')
+        s = s.replace('"', '&quot;')
+        s = s.replace("'", '&apos;')
+        return s
+
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/.gitignore b/src/gallium/tests/python/tests/regress/fragment-shader/.gitignore
new file mode 100644
index 00000000000..e33609d251c
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/.gitignore
@@ -0,0 +1 @@
+*.png
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-abs.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-abs.sh
new file mode 100644
index 00000000000..103d7497f48
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-abs.sh
@@ -0,0 +1,13 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { -0.5, -0.4, -0.6, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+ABS OUT[0], TEMP[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-add.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-add.sh
new file mode 100644
index 00000000000..bcb94205963
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-add.sh
@@ -0,0 +1,8 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+ADD OUT[0], IN[0], IN[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-cb-1d.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-cb-1d.sh
new file mode 100644
index 00000000000..85fb9ea4e7f
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-cb-1d.sh
@@ -0,0 +1,13 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+DCL CONST[1]
+DCL CONST[3]
+DCL TEMP[0..1]
+
+ADD TEMP[0], IN[0], CONST[1]
+RCP TEMP[1], CONST[3].xxxx
+MUL OUT[0], TEMP[0], TEMP[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-cb-2d.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-cb-2d.sh
new file mode 100644
index 00000000000..f70a5146f4e
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-cb-2d.sh
@@ -0,0 +1,9 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+DCL CONST[1][1..2]
+
+MAD OUT[0], IN[0], CONST[1][2], CONST[1][1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-dp3.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-dp3.sh
new file mode 100644
index 00000000000..b5281975d4a
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-dp3.sh
@@ -0,0 +1,8 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DP3 OUT[0], IN[0], IN[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-dp4.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-dp4.sh
new file mode 100644
index 00000000000..d59df76e70b
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-dp4.sh
@@ -0,0 +1,8 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DP4 OUT[0], IN[0].xyzx, IN[0].xyzx
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-dst.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-dst.sh
new file mode 100644
index 00000000000..fbb20fa9f62
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-dst.sh
@@ -0,0 +1,8 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DST OUT[0], IN[0], IN[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-ex2.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-ex2.sh
new file mode 100644
index 00000000000..b511288f4b6
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-ex2.sh
@@ -0,0 +1,11 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+EX2 TEMP[0], IN[0].xxxx
+MUL OUT[0], TEMP[0], IN[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-flr.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-flr.sh
new file mode 100644
index 00000000000..99a2f96103a
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-flr.sh
@@ -0,0 +1,15 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 2.5, 4.0,  2.0, 1.0 }
+IMM FLT32 { 0.4, 0.25, 0.5, 1.0 }
+
+MUL TEMP[0], IN[0], IMM[0]
+FLR TEMP[0], TEMP[0]
+MUL OUT[0], TEMP[0], IMM[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-frc.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-frc.sh
new file mode 100644
index 00000000000..a54c2623b0a
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-frc.sh
@@ -0,0 +1,13 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 2.7, 3.1, 4.5, 1.0 }
+
+MUL TEMP[0], IN[0], IMM[0]
+FRC OUT[0], TEMP[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-lg2.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-lg2.sh
new file mode 100644
index 00000000000..5f5b4be1092
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-lg2.sh
@@ -0,0 +1,15 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
+IMM FLT32 { 0.5, 0.0, 0.0, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+LG2 TEMP[0].x, TEMP[0].xxxx
+ADD OUT[0], TEMP[0], IMM[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-lit.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-lit.sh
new file mode 100644
index 00000000000..6323c4712dc
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-lit.sh
@@ -0,0 +1,8 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+LIT OUT[0], IN[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-lrp.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-lrp.sh
new file mode 100644
index 00000000000..740809d22e0
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-lrp.sh
@@ -0,0 +1,11 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+ABS TEMP[0], IN[0]
+LRP OUT[0], TEMP[0], IN[0].xxxx, IN[0].yyyy
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-mad.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-mad.sh
new file mode 100644
index 00000000000..413b9dc3916
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-mad.sh
@@ -0,0 +1,11 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+IMM FLT32 { 0.5, 0.4, 0.6, 1.0 }
+IMM FLT32 { 0.5, 0.4, 0.6, 0.0 }
+
+MAD OUT[0], IN[0], IMM[0], IMM[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-max.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-max.sh
new file mode 100644
index 00000000000..b69f2132612
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-max.sh
@@ -0,0 +1,10 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+IMM FLT32 { 0.4, 0.4, 0.4, 0.0 }
+
+MAX OUT[0], IN[0], IMM[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-min.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-min.sh
new file mode 100644
index 00000000000..df284f49e71
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-min.sh
@@ -0,0 +1,10 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+IMM FLT32 { 0.6, 0.6, 0.6, 1.0 }
+
+MIN OUT[0], IN[0], IMM[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-mov.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-mov.sh
new file mode 100644
index 00000000000..64af72f381b
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-mov.sh
@@ -0,0 +1,8 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+MOV OUT[0], IN[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-mul.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-mul.sh
new file mode 100644
index 00000000000..bdd0b0026b9
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-mul.sh
@@ -0,0 +1,10 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+IMM FLT32 { 0.5, 0.6, 0.7, 1.0 }
+
+MUL OUT[0], IN[0], IMM[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-rcp.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-rcp.sh
new file mode 100644
index 00000000000..f4b611b26ab
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-rcp.sh
@@ -0,0 +1,15 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
+IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+RCP TEMP[0].x, TEMP[0].xxxx
+SUB OUT[0], TEMP[0], IMM[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-rsq.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-rsq.sh
new file mode 100644
index 00000000000..d1e9b0b53be
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-rsq.sh
@@ -0,0 +1,15 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
+IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+RSQ TEMP[0].x, TEMP[0].xxxx
+SUB OUT[0], TEMP[0], IMM[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-sge.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-sge.sh
new file mode 100644
index 00000000000..1f33fac4727
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-sge.sh
@@ -0,0 +1,13 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 0.6, 0.6, 0.6, 0.0 }
+
+SGE TEMP[0], IN[0], IMM[0]
+MUL OUT[0], IN[0], TEMP[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-slt.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-slt.sh
new file mode 100644
index 00000000000..d58b7886a12
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-slt.sh
@@ -0,0 +1,13 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 0.6, 0.6, 0.6, 0.0 }
+
+SLT TEMP[0], IN[0], IMM[0]
+MUL OUT[0], IN[0], TEMP[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-abs.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-abs.sh
new file mode 100644
index 00000000000..ecd19248c64
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-abs.sh
@@ -0,0 +1,13 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { -0.3, -0.5, -0.4, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+MOV OUT[0], |TEMP[0]|
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-absneg.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-absneg.sh
new file mode 100644
index 00000000000..c2d99ddd15b
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-absneg.sh
@@ -0,0 +1,15 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { -0.2, -0.3, -0.4, 0.0 }
+IMM FLT32 { -1.0, -1.0, -1.0, -1.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+MOV TEMP[0], -|TEMP[0]|
+MUL OUT[0], TEMP[0], IMM[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-neg.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-neg.sh
new file mode 100644
index 00000000000..a08ab6d2dcb
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-neg.sh
@@ -0,0 +1,11 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+DCL TEMP[0]
+
+SUB TEMP[0], IN[0], IN[0].yzxw
+MOV OUT[0], -TEMP[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-swz.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-swz.sh
new file mode 100644
index 00000000000..6110647d979
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-swz.sh
@@ -0,0 +1,8 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+MOV OUT[0], IN[0].yxzw
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-sub.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-sub.sh
new file mode 100644
index 00000000000..673fca139aa
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-sub.sh
@@ -0,0 +1,8 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+SUB OUT[0], IN[0], IN[0].yzxw
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/frag-xpd.sh b/src/gallium/tests/python/tests/regress/fragment-shader/frag-xpd.sh
new file mode 100644
index 00000000000..6ec8b1184cc
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/frag-xpd.sh
@@ -0,0 +1,8 @@
+FRAG
+
+DCL IN[0], COLOR, LINEAR
+DCL OUT[0], COLOR
+
+XPD OUT[0], IN[0], IN[0].yzxw
+
+END
diff --git a/src/gallium/tests/python/tests/regress/fragment-shader/fragment-shader.py b/src/gallium/tests/python/tests/regress/fragment-shader/fragment-shader.py
new file mode 100644
index 00000000000..ef65a9c5a1b
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/fragment-shader/fragment-shader.py
@@ -0,0 +1,257 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2009 VMware, Inc.
+# 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 VMWARE 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.
+# 
+##########################################################################
+
+import struct
+
+from gallium import *
+
+def make_image(surface):
+    data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
+
+    import Image
+    outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
+    return outimage
+
+def save_image(filename, surface):
+    outimage = make_image(surface)
+    outimage.save(filename, "PNG")
+
+def test(dev, name):
+    ctx = dev.context_create()
+
+    width = 320
+    height = 320
+    minz = 0.0
+    maxz = 1.0
+
+    # disabled blending/masking
+    blend = Blend()
+    blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
+    blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
+    blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
+    blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
+    blend.rt[0].colormask = PIPE_MASK_RGBA
+    ctx.set_blend(blend)
+
+    # depth/stencil/alpha
+    depth_stencil_alpha = DepthStencilAlpha()
+    depth_stencil_alpha.depth.enabled = 0
+    depth_stencil_alpha.depth.writemask = 1
+    depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
+    ctx.set_depth_stencil_alpha(depth_stencil_alpha)
+
+    # rasterizer
+    rasterizer = Rasterizer()
+    rasterizer.front_winding = PIPE_WINDING_CW
+    rasterizer.cull_mode = PIPE_WINDING_NONE
+    rasterizer.scissor = 1
+    ctx.set_rasterizer(rasterizer)
+
+    # viewport
+    viewport = Viewport()
+    scale = FloatArray(4)
+    scale[0] = width / 2.0
+    scale[1] = -height / 2.0
+    scale[2] = (maxz - minz) / 2.0
+    scale[3] = 1.0
+    viewport.scale = scale
+    translate = FloatArray(4)
+    translate[0] = width / 2.0
+    translate[1] = height / 2.0
+    translate[2] = (maxz - minz) / 2.0
+    translate[3] = 0.0
+    viewport.translate = translate
+    ctx.set_viewport(viewport)
+
+    # samplers
+    sampler = Sampler()
+    sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
+    sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+    sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+    sampler.normalized_coords = 1
+    ctx.set_fragment_sampler(0, sampler)
+
+    # scissor
+    scissor = Scissor()
+    scissor.minx = 0
+    scissor.miny = 0
+    scissor.maxx = width
+    scissor.maxy = height
+    ctx.set_scissor(scissor)
+
+    clip = Clip()
+    clip.nr = 0
+    ctx.set_clip(clip)
+
+    # framebuffer
+    cbuf = dev.resource_create(
+        PIPE_FORMAT_B8G8R8X8_UNORM,
+        width, height,
+        bind=PIPE_BIND_RENDER_TARGET,
+    ).get_surface()
+    fb = Framebuffer()
+    fb.width = width
+    fb.height = height
+    fb.nr_cbufs = 1
+    fb.set_cbuf(0, cbuf)
+    ctx.set_framebuffer(fb)
+    rgba = FloatArray(4);
+    rgba[0] = 0.5
+    rgba[1] = 0.5
+    rgba[2] = 0.5
+    rgba[3] = 0.5
+    ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
+
+    # vertex shader
+    vs = Shader('''
+        VERT
+        DCL IN[0], POSITION
+        DCL IN[1], COLOR
+        DCL OUT[0], POSITION
+        DCL OUT[1], COLOR
+        MOV OUT[0], IN[0]
+        MOV OUT[1], IN[1]
+        END
+    ''')
+    ctx.set_vertex_shader(vs)
+
+    # fragment shader
+    fs = Shader(file('frag-' + name + '.sh', 'rt').read())
+    ctx.set_fragment_shader(fs)
+
+    constbuf0 = dev.buffer_create(64,
+                                  (PIPE_BUFFER_USAGE_CONSTANT |
+                                   PIPE_BUFFER_USAGE_GPU_READ |
+                                   PIPE_BUFFER_USAGE_CPU_WRITE),
+                                  4 * 4 * 4)
+
+    cbdata = ''
+    cbdata += struct.pack('4f', 0.4, 0.0, 0.0, 1.0)
+    cbdata += struct.pack('4f', 1.0, 1.0, 1.0, 1.0)
+    cbdata += struct.pack('4f', 2.0, 2.0, 2.0, 2.0)
+    cbdata += struct.pack('4f', 4.0, 8.0, 16.0, 32.0)
+
+    constbuf0.write(cbdata, 0)
+
+    ctx.set_constant_buffer(PIPE_SHADER_FRAGMENT,
+                            0,
+                            constbuf0)
+
+    constbuf1 = dev.buffer_create(64,
+                                  (PIPE_BUFFER_USAGE_CONSTANT |
+                                   PIPE_BUFFER_USAGE_GPU_READ |
+                                   PIPE_BUFFER_USAGE_CPU_WRITE),
+                                  4 * 4 * 4)
+
+    cbdata = ''
+    cbdata += struct.pack('4f', 0.1, 0.1, 0.1, 0.1)
+    cbdata += struct.pack('4f', 0.25, 0.25, 0.25, 0.25)
+    cbdata += struct.pack('4f', 0.5, 0.5, 0.5, 0.5)
+    cbdata += struct.pack('4f', 0.75, 0.75, 0.75, 0.75)
+
+    constbuf1.write(cbdata, 0)
+
+    ctx.set_constant_buffer(PIPE_SHADER_FRAGMENT,
+                            1,
+                            constbuf1)
+
+    xy = [
+        -0.8, -0.8,
+         0.8, -0.8,
+         0.0,  0.8,
+    ]
+    color = [
+        1.0, 0.0, 0.0,
+        0.0, 1.0, 0.0,
+        0.0, 0.0, 1.0,
+    ]
+
+    nverts = 3
+    nattrs = 2
+    verts = FloatArray(nverts * nattrs * 4)
+
+    for i in range(0, nverts):
+        verts[i * nattrs * 4 + 0] = xy[i * 2 + 0] # x
+        verts[i * nattrs * 4 + 1] = xy[i * 2 + 1] # y
+        verts[i * nattrs * 4 + 2] = 0.5 # z
+        verts[i * nattrs * 4 + 3] = 1.0 # w
+        verts[i * nattrs * 4 + 4] = color[i * 3 + 0] # r
+        verts[i * nattrs * 4 + 5] = color[i * 3 + 1] # g
+        verts[i * nattrs * 4 + 6] = color[i * 3 + 2] # b
+        verts[i * nattrs * 4 + 7] = 1.0 # a
+
+    ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
+                      nverts,
+                      nattrs,
+                      verts)
+
+    ctx.flush()
+
+    save_image('frag-' + name + '.png', cbuf)
+
+def main():
+    tests = [
+        'abs',
+        'add',
+        'cb-1d',
+        'cb-2d',
+        'dp3',
+        'dp4',
+        'dst',
+        'ex2',
+        'flr',
+        'frc',
+        'lg2',
+        'lit',
+        'lrp',
+        'mad',
+        'max',
+        'min',
+        'mov',
+        'mul',
+        'rcp',
+        'rsq',
+        'sge',
+        'slt',
+        'srcmod-abs',
+        'srcmod-absneg',
+        'srcmod-neg',
+        'srcmod-swz',
+        'sub',
+        'xpd',
+    ]
+
+    dev = Device()
+    for t in tests:
+        test(dev, t)
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/.gitignore b/src/gallium/tests/python/tests/regress/vertex-shader/.gitignore
new file mode 100644
index 00000000000..e33609d251c
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/.gitignore
@@ -0,0 +1 @@
+*.png
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-abs.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-abs.sh
new file mode 100644
index 00000000000..79c9ca69fb1
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-abs.sh
@@ -0,0 +1,15 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+DCL TEMP[0]
+
+IMM FLT32 { 0.2, 0.2, 0.0, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+ABS OUT[0], TEMP[0]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-add.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-add.sh
new file mode 100644
index 00000000000..ca97ad05df0
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-add.sh
@@ -0,0 +1,13 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+IMM FLT32 { 0.2, -0.1, 0.0, 0.0 }
+
+ADD OUT[0], IN[0], IMM[0]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-arl.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-arl.sh
new file mode 100644
index 00000000000..321140e89e8
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-arl.sh
@@ -0,0 +1,23 @@
+VERT
+
+DCL IN[0], POSITION
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+DCL ADDR[0]
+
+IMM FLT32 { 3.0, 1.0, 1.0, 1.0 }
+IMM FLT32 { 1.0, 0.0, 0.0, 1.0 }
+IMM FLT32 { 0.0, 1.0, 0.0, 1.0 }
+IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
+IMM FLT32 { 1.0, 1.0, 0.0, 1.0 }
+IMM FLT32 { 0.0, 1.0, 1.0, 1.0 }
+
+MOV OUT[0], IN[0]
+MUL TEMP[0], IN[0], IMM[0]
+ARL ADDR[0].x, TEMP[0]
+MOV OUT[1], IMM[ADDR[0].x + 3]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-arr.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-arr.sh
new file mode 100644
index 00000000000..d60ea46b367
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-arr.sh
@@ -0,0 +1,23 @@
+VERT
+
+DCL IN[0], POSITION
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+DCL ADDR[0]
+
+IMM FLT32 { 3.0, 1.0, 1.0, 1.0 }
+IMM FLT32 { 1.0, 0.0, 0.0, 1.0 }
+IMM FLT32 { 0.0, 1.0, 0.0, 1.0 }
+IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
+IMM FLT32 { 1.0, 1.0, 0.0, 1.0 }
+IMM FLT32 { 0.0, 1.0, 1.0, 1.0 }
+
+MOV OUT[0], IN[0]
+MUL TEMP[0], IN[0], IMM[0]
+ARR ADDR[0].x, TEMP[0]
+MOV OUT[1], IMM[ADDR[0].x + 3]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-cb-1d.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-cb-1d.sh
new file mode 100644
index 00000000000..b41fe5dd38f
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-cb-1d.sh
@@ -0,0 +1,16 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+DCL CONST[1]
+DCL CONST[3]
+DCL TEMP[0..1]
+
+MOV OUT[0], IN[0]
+ADD TEMP[0], IN[1], CONST[1]
+RCP TEMP[1], CONST[3].xxxx
+MUL OUT[1], TEMP[0], TEMP[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-cb-2d.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-cb-2d.sh
new file mode 100644
index 00000000000..45f5e6b7299
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-cb-2d.sh
@@ -0,0 +1,12 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+DCL CONST[1][1..2]
+
+MOV OUT[0], IN[0]
+MAD OUT[1], IN[1], CONST[1][2], CONST[1][1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-dp3.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-dp3.sh
new file mode 100644
index 00000000000..caff622fe61
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-dp3.sh
@@ -0,0 +1,16 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+DCL TEMP[0]
+
+IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
+
+DP3 TEMP[0].xy, IN[0], IN[0]
+MOV TEMP[0].zw, IMM[0]
+MUL OUT[0], IN[0], TEMP[0]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-dp4.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-dp4.sh
new file mode 100644
index 00000000000..3dd2fd1c2f7
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-dp4.sh
@@ -0,0 +1,16 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+DCL TEMP[0]
+
+IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
+
+DP4 TEMP[0].xy, IN[0], IN[0]
+MOV TEMP[0].zw, IMM[0]
+MUL OUT[0], IN[0], TEMP[0]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-dst.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-dst.sh
new file mode 100644
index 00000000000..da9cc18dfc0
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-dst.sh
@@ -0,0 +1,11 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+MOV OUT[0], IN[0]
+DST OUT[1], IN[1], IN[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-ex2.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-ex2.sh
new file mode 100644
index 00000000000..4637227e5c4
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-ex2.sh
@@ -0,0 +1,18 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0..1]
+
+IMM FLT32 { 0.3, 0.3, 0.3, 1.0 }
+
+EX2 TEMP[0], IN[0]
+EX2 TEMP[1], IN[1].yyyy
+MUL TEMP[0], TEMP[0], IMM[0]
+MOV OUT[0], IN[0]
+MUL OUT[1], TEMP[0], TEMP[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-flr.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-flr.sh
new file mode 100644
index 00000000000..aa80d6e394c
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-flr.sh
@@ -0,0 +1,23 @@
+VERT
+
+DCL IN[0], POSITION
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+DCL ADDR[0]
+
+IMM FLT32 { 3.0, 1.0, 1.0, 1.0 }
+IMM FLT32 { 1.0, 0.0, 0.0, 1.0 }
+IMM FLT32 { 0.0, 1.0, 0.0, 1.0 }
+IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
+IMM FLT32 { 1.0, 1.0, 0.0, 1.0 }
+IMM FLT32 { 0.0, 1.0, 1.0, 1.0 }
+
+MOV OUT[0], IN[0]
+MUL TEMP[0], IN[0], IMM[0]
+FLR ADDR[0].x, TEMP[0]
+MOV OUT[1], IMM[ADDR[0].x + 3]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-frc.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-frc.sh
new file mode 100644
index 00000000000..64d1a494e13
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-frc.sh
@@ -0,0 +1,15 @@
+VERT
+
+DCL IN[0], POSITION
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 2.7, 3.1, 4.5, 1.0 }
+
+MUL TEMP[0], IN[0].xyxw, IMM[0]
+MOV OUT[0], IN[0]
+FRC OUT[1], TEMP[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-lg2.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-lg2.sh
new file mode 100644
index 00000000000..5cf16fd1aa8
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-lg2.sh
@@ -0,0 +1,18 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
+IMM FLT32 { 0.5, 0.0, 0.0, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+LG2 TEMP[0].x, TEMP[0].xxxx
+ADD OUT[0], TEMP[0], IMM[1]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-lit.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-lit.sh
new file mode 100644
index 00000000000..a4a752d4d23
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-lit.sh
@@ -0,0 +1,11 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+MOV OUT[0], IN[0]
+LIT OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-lrp.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-lrp.sh
new file mode 100644
index 00000000000..4bb5f3ec3f4
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-lrp.sh
@@ -0,0 +1,14 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+ABS TEMP[0], IN[0]
+MOV OUT[0], IN[0]
+LRP OUT[1], TEMP[0], IN[1].xxxx, IN[1].yyyy
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-mad.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-mad.sh
new file mode 100644
index 00000000000..daaa941f15f
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-mad.sh
@@ -0,0 +1,14 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+IMM FLT32 { 0.5, 1.0, 1.0, 1.0 }
+IMM FLT32 { 0.5, 0.0, 0.0, 0.0 }
+
+MAD OUT[0], IN[0], IMM[0], IMM[1]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-max.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-max.sh
new file mode 100644
index 00000000000..af279ec7f4a
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-max.sh
@@ -0,0 +1,13 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+IMM FLT32 { 0.5, 0.5, 0.5, 0.0 }
+
+MOV OUT[0], IN[0]
+MAX OUT[1], IN[1], IMM[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-min.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-min.sh
new file mode 100644
index 00000000000..46d886c55b8
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-min.sh
@@ -0,0 +1,13 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+IMM FLT32 { 0.5, 0.5, 0.5, 0.0 }
+
+MOV OUT[0], IN[0]
+MIN OUT[1], IN[1], IMM[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-mov.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-mov.sh
new file mode 100644
index 00000000000..0ef91637e03
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-mov.sh
@@ -0,0 +1,11 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+MOV OUT[0], IN[0]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-mul.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-mul.sh
new file mode 100644
index 00000000000..d34f6cd6e3c
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-mul.sh
@@ -0,0 +1,13 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+IMM FLT32 { 0.6, 0.6, 1.0, 1.0 }
+
+MUL OUT[0], IN[0], IMM[0]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-rcp.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-rcp.sh
new file mode 100644
index 00000000000..cfb3ec37dc2
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-rcp.sh
@@ -0,0 +1,18 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
+IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+RCP TEMP[0].x, TEMP[0].xxxx
+SUB OUT[0], TEMP[0], IMM[1]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-rsq.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-rsq.sh
new file mode 100644
index 00000000000..faf1e6e7d41
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-rsq.sh
@@ -0,0 +1,18 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
+IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+RSQ TEMP[0].x, TEMP[0].xxxx
+SUB OUT[0], TEMP[0], IMM[1]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-sge.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-sge.sh
new file mode 100644
index 00000000000..6de1d071ef4
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-sge.sh
@@ -0,0 +1,16 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { -0.1, -0.1, 1.0, 0.0 }
+
+SGE TEMP[0], IN[0], IMM[0]
+MOV OUT[0], IN[0]
+MUL OUT[1], IN[1], TEMP[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-slt.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-slt.sh
new file mode 100644
index 00000000000..9a524229845
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-slt.sh
@@ -0,0 +1,16 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+DCL TEMP[0]
+
+IMM FLT32 { 0.6, 0.6, 0.0, 0.0 }
+
+SLT TEMP[0], IN[0], IMM[0]
+MOV OUT[0], IN[0]
+MUL OUT[1], IN[1], TEMP[0]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-abs.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-abs.sh
new file mode 100644
index 00000000000..dc87ce4ae70
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-abs.sh
@@ -0,0 +1,15 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+DCL TEMP[0]
+
+IMM FLT32 { 0.1, 0.1, 0.0, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+MOV OUT[0], |TEMP[0]|
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-absneg.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-absneg.sh
new file mode 100644
index 00000000000..d82eb08fd30
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-absneg.sh
@@ -0,0 +1,16 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+DCL TEMP[0]
+
+IMM FLT32 { -0.2, -0.2, 0.0, 0.0 }
+
+ADD TEMP[0], IN[0], IMM[0]
+MOV OUT[0].xy, -|TEMP[0]|
+MOV OUT[0].zw, IN[0]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-neg.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-neg.sh
new file mode 100644
index 00000000000..e39bebcd9f1
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-neg.sh
@@ -0,0 +1,12 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+MOV OUT[0].xy, -IN[0]
+MOV OUT[0].zw, IN[0]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-swz.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-swz.sh
new file mode 100644
index 00000000000..6f20552f212
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-srcmod-swz.sh
@@ -0,0 +1,11 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+MOV OUT[0], IN[0].yxzw
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-sub.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-sub.sh
new file mode 100644
index 00000000000..0f9678b8a3e
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-sub.sh
@@ -0,0 +1,13 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+IMM FLT32 { 0.1, 0.1, 0.0, 0.0 }
+
+SUB OUT[0], IN[0], IMM[0]
+MOV OUT[1], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vert-xpd.sh b/src/gallium/tests/python/tests/regress/vertex-shader/vert-xpd.sh
new file mode 100644
index 00000000000..39d42ae2a0d
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vert-xpd.sh
@@ -0,0 +1,11 @@
+VERT
+
+DCL IN[0], POSITION
+DCL IN[1], COLOR
+DCL OUT[0], POSITION
+DCL OUT[1], COLOR
+
+MOV OUT[0], IN[0]
+XPD OUT[1], IN[0], IN[1]
+
+END
diff --git a/src/gallium/tests/python/tests/regress/vertex-shader/vertex-shader.py b/src/gallium/tests/python/tests/regress/vertex-shader/vertex-shader.py
new file mode 100644
index 00000000000..05e40dbd5f1
--- /dev/null
+++ b/src/gallium/tests/python/tests/regress/vertex-shader/vertex-shader.py
@@ -0,0 +1,287 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2009 VMware, Inc.
+# 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 VMWARE 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.
+# 
+##########################################################################
+
+
+import struct
+
+from gallium import *
+
+def make_image(surface):
+    data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
+
+    import Image
+    outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
+    return outimage
+
+def save_image(filename, surface):
+    outimage = make_image(surface)
+    outimage.save(filename, "PNG")
+
+def test(dev, name):
+    ctx = dev.context_create()
+
+    width = 320
+    height = 320
+    minz = 0.0
+    maxz = 1.0
+
+    # disabled blending/masking
+    blend = Blend()
+    blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
+    blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
+    blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
+    blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
+    blend.rt[0].colormask = PIPE_MASK_RGBA
+    ctx.set_blend(blend)
+
+    # depth/stencil/alpha
+    depth_stencil_alpha = DepthStencilAlpha()
+    depth_stencil_alpha.depth.enabled = 0
+    depth_stencil_alpha.depth.writemask = 1
+    depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
+    ctx.set_depth_stencil_alpha(depth_stencil_alpha)
+
+    # rasterizer
+    rasterizer = Rasterizer()
+    rasterizer.front_winding = PIPE_WINDING_CW
+    rasterizer.cull_mode = PIPE_WINDING_NONE
+    rasterizer.scissor = 1
+    ctx.set_rasterizer(rasterizer)
+
+    # viewport
+    viewport = Viewport()
+    scale = FloatArray(4)
+    scale[0] = width / 2.0
+    scale[1] = -height / 2.0
+    scale[2] = (maxz - minz) / 2.0
+    scale[3] = 1.0
+    viewport.scale = scale
+    translate = FloatArray(4)
+    translate[0] = width / 2.0
+    translate[1] = height / 2.0
+    translate[2] = (maxz - minz) / 2.0
+    translate[3] = 0.0
+    viewport.translate = translate
+    ctx.set_viewport(viewport)
+
+    # samplers
+    sampler = Sampler()
+    sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+    sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
+    sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+    sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+    sampler.normalized_coords = 1
+    ctx.set_fragment_sampler(0, sampler)
+
+    # scissor
+    scissor = Scissor()
+    scissor.minx = 0
+    scissor.miny = 0
+    scissor.maxx = width
+    scissor.maxy = height
+    ctx.set_scissor(scissor)
+
+    clip = Clip()
+    clip.nr = 0
+    ctx.set_clip(clip)
+
+    # framebuffer
+    cbuf = dev.resource_create(
+        PIPE_FORMAT_B8G8R8X8_UNORM,
+        width, height,
+        bind=PIPE_BIND_RENDER_TARGET,
+    ).get_surface()
+    fb = Framebuffer()
+    fb.width = width
+    fb.height = height
+    fb.nr_cbufs = 1
+    fb.set_cbuf(0, cbuf)
+    ctx.set_framebuffer(fb)
+    rgba = FloatArray(4);
+    rgba[0] = 0.5
+    rgba[1] = 0.5
+    rgba[2] = 0.5
+    rgba[3] = 0.5
+    ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
+
+    # vertex shader
+    vs = Shader(file('vert-' + name + '.sh', 'rt').read())
+    ctx.set_vertex_shader(vs)
+
+    # fragment shader
+    fs = Shader('''
+        FRAG
+        DCL IN[0], COLOR, LINEAR
+        DCL OUT[0], COLOR, CONSTANT
+        0:MOV OUT[0], IN[0]
+        1:END
+    ''')
+    ctx.set_fragment_shader(fs)
+
+    constbuf0 = dev.buffer_create(64,
+                                  (PIPE_BUFFER_USAGE_CONSTANT |
+                                   PIPE_BUFFER_USAGE_GPU_READ |
+                                   PIPE_BUFFER_USAGE_CPU_WRITE),
+                                  4 * 4 * 4)
+
+    cbdata = ''
+    cbdata += struct.pack('4f', 0.4, 0.0, 0.0, 1.0)
+    cbdata += struct.pack('4f', 1.0, 1.0, 1.0, 1.0)
+    cbdata += struct.pack('4f', 2.0, 2.0, 2.0, 2.0)
+    cbdata += struct.pack('4f', 4.0, 8.0, 16.0, 32.0)
+
+    constbuf0.write(cbdata, 0)
+
+    ctx.set_constant_buffer(PIPE_SHADER_VERTEX,
+                            0,
+                            constbuf0)
+
+    constbuf1 = dev.buffer_create(64,
+                                  (PIPE_BUFFER_USAGE_CONSTANT |
+                                   PIPE_BUFFER_USAGE_GPU_READ |
+                                   PIPE_BUFFER_USAGE_CPU_WRITE),
+                                  4 * 4 * 4)
+
+    cbdata = ''
+    cbdata += struct.pack('4f', 0.1, 0.1, 0.1, 0.1)
+    cbdata += struct.pack('4f', 0.25, 0.25, 0.25, 0.25)
+    cbdata += struct.pack('4f', 0.5, 0.5, 0.5, 0.5)
+    cbdata += struct.pack('4f', 0.75, 0.75, 0.75, 0.75)
+
+    constbuf1.write(cbdata, 0)
+
+    ctx.set_constant_buffer(PIPE_SHADER_VERTEX,
+                            1,
+                            constbuf1)
+
+    xy = [
+         0.0,  0.8,
+        -0.2,  0.4,
+         0.2,  0.4,
+        -0.4,  0.0,
+         0.0,  0.0,
+         0.4,  0.0,
+        -0.6, -0.4,
+        -0.2, -0.4,
+         0.2, -0.4,
+         0.6, -0.4,
+        -0.8, -0.8,
+        -0.4, -0.8,
+         0.0, -0.8,
+         0.4, -0.8,
+         0.8, -0.8,
+    ]
+    color = [
+        1.0, 0.0, 0.0,
+        0.0, 1.0, 0.0,
+        0.0, 0.0, 1.0,
+    ]
+    tri = [
+         1,  2,  0,
+         3,  4,  1,
+         4,  2,  1,
+         4,  5,  2,
+         6,  7,  3,
+         7,  4,  3,
+         7,  8,  4,
+         8,  5,  4,
+         8,  9,  5,
+        10, 11,  6,
+        11,  7,  6,
+        11, 12,  7,
+        12,  8,  7,
+        12, 13,  8,
+        13,  9,  8,
+        13, 14,  9,
+    ]
+
+    nverts = 16 * 3
+    nattrs = 2
+    verts = FloatArray(nverts * nattrs * 4)
+
+    for i in range(0, nverts):
+        verts[i * nattrs * 4 + 0] = xy[tri[i] * 2 + 0] # x
+        verts[i * nattrs * 4 + 1] = xy[tri[i] * 2 + 1] # y
+        verts[i * nattrs * 4 + 2] = 0.5 # z
+        verts[i * nattrs * 4 + 3] = 1.0 # w
+        verts[i * nattrs * 4 + 4] = color[(i % 3) * 3 + 0] # r
+        verts[i * nattrs * 4 + 5] = color[(i % 3) * 3 + 1] # g
+        verts[i * nattrs * 4 + 6] = color[(i % 3) * 3 + 2] # b
+        verts[i * nattrs * 4 + 7] = 1.0 # a
+
+    ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
+                      nverts,
+                      nattrs,
+                      verts)
+
+    ctx.flush()
+
+    save_image('vert-' + name + '.png', cbuf)
+
+def main():
+    tests = [
+        'abs',
+        'add',
+        'arl',
+        'arr',
+        'cb-1d',
+        'cb-2d',
+        'dp3',
+        'dp4',
+        'dst',
+        'ex2',
+        'flr',
+        'frc',
+        'lg2',
+        'lit',
+        'lrp',
+        'mad',
+        'max',
+        'min',
+        'mov',
+        'mul',
+        'rcp',
+        'rsq',
+        'sge',
+        'slt',
+        'srcmod-abs',
+        'srcmod-absneg',
+        'srcmod-neg',
+        'srcmod-swz',
+        'sub',
+        'xpd',
+    ]
+
+    dev = Device()
+    for t in tests:
+        test(dev, t)
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/tests/python/tests/surface_copy.py b/src/gallium/tests/python/tests/surface_copy.py
new file mode 100755
index 00000000000..8d841644035
--- /dev/null
+++ b/src/gallium/tests/python/tests/surface_copy.py
@@ -0,0 +1,200 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2009 VMware, Inc.
+# 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 VMWARE 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.
+# 
+##########################################################################
+
+
+import os
+import random
+
+from gallium import *
+from base import *
+
+
+def lods(*dims):
+    size = max(dims)
+    lods = 0
+    while size:
+        lods += 1
+        size >>= 1
+    return lods
+
+
+class TextureTest(TestCase):
+    
+    tags = (
+        'target',
+        'format',
+        'width',
+        'height',
+        'depth',
+        'last_level',
+        'face',
+        'level',
+        'zslice',
+    )
+
+    def test(self):
+        dev = self.dev
+        ctx = self.ctx
+        
+        target = self.target
+        format = self.format
+        width = self.width
+        height = self.height
+        depth = self.depth
+        last_level = self.last_level
+        face = self.face
+        level = self.level
+        zslice = self.zslice
+        
+        bind = PIPE_BIND_SAMPLER_VIEW
+        geom_flags = 0
+        if not dev.is_format_supported(format, target, bind, geom_flags):
+            raise TestSkip
+
+        if not dev.is_format_supported(format, target, bind, geom_flags):
+            raise TestSkip
+
+        #  textures
+        dst_texture = dev.resource_create(
+            target = target,
+            format = format, 
+            width = width, 
+            height = height,
+            depth = depth, 
+            last_level = last_level,
+            bind = bind,
+        )
+
+        dst_surface = dst_texture.get_surface(face = face, level = level, zslice = zslice)
+        
+        src_texture = dev.resource_create(
+            target = target,
+            format = format, 
+            width = dst_surface.width, 
+            height = dst_surface.height,
+            depth = 1, 
+            last_level = 0,
+            bind = PIPE_BIND_SAMPLER_VIEW,
+        )
+
+        src_surface = src_texture.get_surface()
+        
+        w = dst_surface.width
+        h = dst_surface.height
+
+        stride = util_format_get_stride(format, w)
+        size = util_format_get_nblocksy(format, h) * stride
+        src_raw = os.urandom(size)
+
+        ctx.surface_write_raw(src_surface, 0, 0, w, h, src_raw, stride)
+
+        ctx.surface_copy(dst_surface, 0, 0, 
+                         src_surface, 0, 0, w, h)
+    
+        dst_raw = ctx.surface_read_raw(dst_surface, 0, 0, w, h)
+
+        if dst_raw != src_raw:
+            raise TestFailure
+
+
+def main():
+    dev = Device()
+    ctx = dev.context_create()
+    suite = TestSuite()
+    
+    targets = [
+        PIPE_TEXTURE_2D,
+        PIPE_TEXTURE_CUBE,
+        PIPE_TEXTURE_3D,
+    ]
+    
+    sizes = [64, 32, 16, 8, 4, 2, 1]
+    #sizes = [1020, 508, 252, 62, 30, 14, 6, 3]
+    #sizes = [64]
+    #sizes = [63]
+    
+    faces = [
+        PIPE_TEX_FACE_POS_X,
+        PIPE_TEX_FACE_NEG_X,
+        PIPE_TEX_FACE_POS_Y,
+        PIPE_TEX_FACE_NEG_Y, 
+        PIPE_TEX_FACE_POS_Z, 
+        PIPE_TEX_FACE_NEG_Z,
+    ]
+
+    try:
+        n = int(sys.argv[1])
+    except:
+        n = 10000
+    
+    for i in range(n):
+        format = random.choice(formats.keys())
+        if not util_format_is_depth_or_stencil(format):
+            is_depth_or_stencil = util_format_is_depth_or_stencil(format)
+
+            if is_depth_or_stencil:
+                target = PIPE_TEXTURE_2D
+            else:
+                target = random.choice(targets)
+            
+            size = random.choice(sizes)
+
+            if target == PIPE_TEXTURE_3D:
+                depth = size
+            else:
+                depth = 1
+
+            if target == PIPE_TEXTURE_CUBE:
+                face = random.choice(faces)
+            else:
+                face = PIPE_TEX_FACE_POS_X
+
+            levels = lods(size)
+            last_level = random.randint(0, levels - 1)
+            level = random.randint(0, last_level)
+            zslice = random.randint(0, max(depth >> level, 1) - 1)
+
+            test = TextureTest(
+                dev = dev,
+                ctx = ctx,
+                target = target,
+                format = format, 
+                width = size,
+                height = size,
+                depth = depth,
+                last_level = last_level,
+                face = face,
+                level = level,
+                zslice = zslice,
+            )
+            suite.add_test(test)
+    suite.run()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/tests/python/tests/texture_blit.py b/src/gallium/tests/python/tests/texture_blit.py
new file mode 100755
index 00000000000..77f006ea04e
--- /dev/null
+++ b/src/gallium/tests/python/tests/texture_blit.py
@@ -0,0 +1,636 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2009 VMware, Inc.
+# Copyright 2008 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 VMWARE 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.
+# 
+##########################################################################
+
+
+import random
+
+from gallium import *
+from base import *
+
+
+def lods(*dims):
+    size = max(dims)
+    lods = 0
+    while size:
+        lods += 1
+        size >>= 1
+    return lods
+
+
+def minify(dims, level = 1):
+    return [max(dim>>level, 1) for dim in dims]
+
+
+def tex_coords(texture, face, level, zslice):
+    st = [ 
+        [0.0, 0.0], 
+        [1.0, 0.0], 
+        [1.0, 1.0], 
+        [0.0, 1.0],
+    ] 
+    
+    if texture.target == PIPE_TEXTURE_2D:
+        return [[s, t, 0.0] for s, t in st]
+    elif texture.target == PIPE_TEXTURE_3D:
+        depth = texture.get_depth(level)
+        if depth > 1:
+            r = float(zslice)/float(depth - 1)
+        else:
+            r = 0.0
+        return [[s, t, r] for s, t in st]
+    elif texture.target == PIPE_TEXTURE_CUBE:
+        result = []
+        for s, t in st:
+            # See http://developer.nvidia.com/object/cube_map_ogl_tutorial.html
+            sc = 2.0*s - 1.0
+            tc = 2.0*t - 1.0
+            if face == PIPE_TEX_FACE_POS_X:
+                rx = 1.0
+                ry = -tc
+                rz = -sc
+            if face == PIPE_TEX_FACE_NEG_X:
+                rx = -1.0
+                ry = -tc
+                rz = sc
+            if face == PIPE_TEX_FACE_POS_Y:
+                rx = sc
+                ry = 1.0
+                rz = tc
+            if face == PIPE_TEX_FACE_NEG_Y:
+                rx = sc
+                ry = -1.0
+                rz = -tc
+            if face == PIPE_TEX_FACE_POS_Z:
+                rx = sc
+                ry = -tc
+                rz = 1.0
+            if face == PIPE_TEX_FACE_NEG_Z:
+                rx = -sc
+                ry = -tc
+                rz = -1.0
+            result.append([rx, ry, rz])
+        return result
+
+def is_pot(n):
+    return n & (n - 1) == 0
+      
+                
+class TextureColorSampleTest(TestCase):
+    
+    tags = (
+        'target',
+        'format',
+        'width',
+        'height',
+        'depth',
+        'last_level',
+        'face',
+        'level',
+        'zslice',
+    )
+
+    def test(self):
+        dev = self.dev
+        ctx = self.ctx
+        
+        target = self.target
+        format = self.format
+        width = self.width
+        height = self.height
+        depth = self.depth
+        last_level = self.last_level
+        face = self.face
+        level = self.level
+        zslice = self.zslice
+        minz = 0.0
+        maxz = 1.0
+        
+        bind = PIPE_BIND_SAMPLER_VIEW
+        geom_flags = 0
+        if width != height:
+            geom_flags |= PIPE_TEXTURE_GEOM_NON_SQUARE
+        if not is_pot(width) or not is_pot(height) or not is_pot(depth):
+            geom_flags |= PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO
+        
+        if not dev.is_format_supported(format, target, bind, geom_flags):
+            raise TestSkip
+        
+        # disabled blending/masking
+        blend = Blend()
+        blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
+        blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
+        blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
+        blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
+        blend.rt[0].colormask = PIPE_MASK_RGBA
+        ctx.set_blend(blend)
+    
+        # no-op depth/stencil/alpha
+        depth_stencil_alpha = DepthStencilAlpha()
+        ctx.set_depth_stencil_alpha(depth_stencil_alpha)
+    
+        # rasterizer
+        rasterizer = Rasterizer()
+        rasterizer.front_winding = PIPE_WINDING_CW
+        rasterizer.cull_mode = PIPE_WINDING_NONE
+        ctx.set_rasterizer(rasterizer)
+    
+        # samplers
+        sampler = Sampler()
+        sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+        sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+        sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+        sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST
+        sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+        sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+        sampler.normalized_coords = 1
+        sampler.min_lod = 0
+        sampler.max_lod = PIPE_MAX_TEXTURE_LEVELS - 1
+        ctx.set_fragment_sampler(0, sampler)
+    
+        #  texture 
+        texture = dev.resource_create(
+            target = target,
+            format = format, 
+            width = width, 
+            height = height,
+            depth = depth, 
+            last_level = last_level,
+            bind = bind,
+        )
+        
+        expected_rgba = FloatArray(height*width*4) 
+        surface = texture.get_surface(
+            face = face,
+            level = level,
+            zslice = zslice,
+        )
+        
+        ctx.surface_sample_rgba(surface, expected_rgba, True)
+        
+        ctx.set_fragment_sampler_texture(0, texture)
+
+        # viewport
+        viewport = Viewport()
+        scale = FloatArray(4)
+        scale[0] = width
+        scale[1] = height
+        scale[2] = (maxz - minz) / 2.0
+        scale[3] = 1.0
+        viewport.scale = scale
+        translate = FloatArray(4)
+        translate[0] = 0.0
+        translate[1] = 0.0
+        translate[2] = (maxz - minz) / 2.0
+        translate[3] = 0.0
+        viewport.translate = translate
+        ctx.set_viewport(viewport)
+
+        # scissor
+        scissor = Scissor()
+        scissor.minx = 0
+        scissor.miny = 0
+        scissor.maxx = width
+        scissor.maxy = height
+        ctx.set_scissor(scissor)
+
+        # clip
+        clip = Clip()
+        clip.nr = 0
+        ctx.set_clip(clip)
+
+        #  framebuffer 
+        cbuf_tex = dev.resource_create(
+            PIPE_FORMAT_B8G8R8A8_UNORM, 
+            width, 
+            height,
+            bind = PIPE_BIND_RENDER_TARGET,
+        )
+
+        cbuf = cbuf_tex.get_surface()
+        fb = Framebuffer()
+        fb.width = width
+        fb.height = height
+        fb.nr_cbufs = 1
+        fb.set_cbuf(0, cbuf)
+        ctx.set_framebuffer(fb)
+        rgba = FloatArray(4);
+        rgba[0] = 0.5
+        rgba[1] = 0.5
+        rgba[2] = 0.5
+        rgba[3] = 0.5
+        ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
+        del fb
+    
+        # vertex shader
+        vs = Shader('''
+            VERT
+            DCL IN[0], POSITION, CONSTANT
+            DCL IN[1], GENERIC, CONSTANT
+            DCL OUT[0], POSITION, CONSTANT
+            DCL OUT[1], GENERIC, CONSTANT
+            0:MOV OUT[0], IN[0]
+            1:MOV OUT[1], IN[1]
+            2:END
+        ''')
+        #vs.dump()
+        ctx.set_vertex_shader(vs)
+    
+        # fragment shader
+        op = {
+            PIPE_TEXTURE_1D: "1D", 
+            PIPE_TEXTURE_2D: "2D", 
+            PIPE_TEXTURE_3D: "3D", 
+            PIPE_TEXTURE_CUBE: "CUBE",
+        }[target]
+        fs = Shader('''
+            FRAG
+            DCL IN[0], GENERIC[0], LINEAR
+            DCL OUT[0], COLOR, CONSTANT
+            DCL SAMP[0], CONSTANT
+            0:TEX OUT[0], IN[0], SAMP[0], %s
+            1:END
+        ''' % op)
+        #fs.dump()
+        ctx.set_fragment_shader(fs)
+
+        nverts = 4
+        nattrs = 2
+        verts = FloatArray(nverts * nattrs * 4)
+    
+        x = 0
+        y = 0
+        w, h = minify((width, height), level)
+    
+        pos = [
+            [x, y],
+            [x+w, y],
+            [x+w, y+h],
+            [x, y+h],
+        ]
+    
+        tex = tex_coords(texture, face, level, zslice)
+    
+        for i in range(0, 4):
+            j = 8*i
+            verts[j + 0] = pos[i][0]/float(width) # x
+            verts[j + 1] = pos[i][1]/float(height) # y
+            verts[j + 2] = 0.0 # z
+            verts[j + 3] = 1.0 # w
+            verts[j + 4] = tex[i][0] # s
+            verts[j + 5] = tex[i][1] # r
+            verts[j + 6] = tex[i][2] # q
+            verts[j + 7] = 1.0
+    
+        ctx.draw_vertices(PIPE_PRIM_TRIANGLE_FAN,
+                          nverts, 
+                          nattrs, 
+                          verts)
+    
+        ctx.flush()
+    
+        cbuf = cbuf_tex.get_surface()
+        
+        self.assert_rgba(ctx, cbuf, x, y, w, h, expected_rgba, 4.0/256, 0.85)
+        
+
+class TextureDepthSampleTest(TestCase):
+    
+    tags = (
+        'target',
+        'format',
+        'width',
+        'height',
+        'depth',
+        'last_level',
+        'face',
+        'level',
+        'zslice',
+    )
+
+    def test(self):
+        dev = self.dev
+        ctx = self.ctx
+        
+        target = self.target
+        format = self.format
+        width = self.width
+        height = self.height
+        depth = self.depth
+        last_level = self.last_level
+        face = self.face
+        level = self.level
+        zslice = self.zslice
+        minz = 0.0
+        maxz = 1.0
+        
+        bind = PIPE_BIND_SAMPLER_VIEW
+        geom_flags = 0
+        if width != height:
+            geom_flags |= PIPE_TEXTURE_GEOM_NON_SQUARE
+        if not is_pot(width) or not is_pot(height) or not is_pot(depth):
+            geom_flags |= PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO
+        
+        if not dev.is_format_supported(format, target, bind, geom_flags):
+            raise TestSkip
+        
+        # disabled blending/masking
+        blend = Blend()
+        blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
+        blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
+        blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
+        blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
+        blend.rt[0].colormask = PIPE_MASK_RGBA
+        ctx.set_blend(blend)
+    
+        # depth/stencil/alpha
+        depth_stencil_alpha = DepthStencilAlpha()
+        depth_stencil_alpha.depth.enabled = 1
+        depth_stencil_alpha.depth.writemask = 1
+        depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
+        ctx.set_depth_stencil_alpha(depth_stencil_alpha)
+    
+        # rasterizer
+        rasterizer = Rasterizer()
+        rasterizer.front_winding = PIPE_WINDING_CW
+        rasterizer.cull_mode = PIPE_WINDING_NONE
+        ctx.set_rasterizer(rasterizer)
+    
+        # viewport
+        viewport = Viewport()
+        scale = FloatArray(4)
+        scale[0] = width
+        scale[1] = height
+        scale[2] = (maxz - minz) / 2.0
+        scale[3] = 1.0
+        viewport.scale = scale
+        translate = FloatArray(4)
+        translate[0] = 0.0
+        translate[1] = 0.0
+        translate[2] = (maxz - minz) / 2.0
+        translate[3] = 0.0
+        viewport.translate = translate
+        ctx.set_viewport(viewport)
+
+        # samplers
+        sampler = Sampler()
+        sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+        sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+        sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+        sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST
+        sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+        sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+        sampler.normalized_coords = 1
+        sampler.min_lod = 0
+        sampler.max_lod = PIPE_MAX_TEXTURE_LEVELS - 1
+        ctx.set_fragment_sampler(0, sampler)
+    
+        #  texture 
+        texture = dev.resource_create(
+            target = target,
+            format = format, 
+            width = width, 
+            height = height,
+            depth = depth, 
+            last_level = last_level,
+            bind = bind,
+        )
+        
+        expected_rgba = FloatArray(height*width*4) 
+        surface = texture.get_surface(
+            face = face,
+            level = level,
+            zslice = zslice,
+        )
+
+        ctx.surface_sample_rgba(surface, expected_rgba, True)
+        
+        ctx.set_fragment_sampler_texture(0, texture)
+
+        # scissor
+        scissor = Scissor()
+        scissor.minx = 0
+        scissor.miny = 0
+        scissor.maxx = width
+        scissor.maxy = height
+        ctx.set_scissor(scissor)
+
+        # clip
+        clip = Clip()
+        clip.nr = 0
+        ctx.set_clip(clip)
+
+        #  framebuffer 
+        cbuf_tex = dev.resource_create(
+            PIPE_FORMAT_B8G8R8A8_UNORM, 
+            width, 
+            height,
+            bind = PIPE_BIND_RENDER_TARGET,
+        )
+
+        zsbuf_tex = dev.resource_create(
+            PIPE_FORMAT_X8Z24_UNORM, 
+            width, 
+            height,
+            bind = PIPE_BIND_RENDER_TARGET,
+        )
+
+        cbuf = cbuf_tex.get_surface()
+        zsbuf = zsbuf_tex.get_surface()
+        fb = Framebuffer()
+        fb.width = width
+        fb.height = height
+        fb.nr_cbufs = 1
+        fb.set_cbuf(0, cbuf)
+        fb.set_zsbuf(zsbuf)
+        ctx.set_framebuffer(fb)
+        rgba = FloatArray(4);
+        rgba[0] = 0.5
+        rgba[1] = 0.5
+        rgba[2] = 0.5
+        rgba[3] = 0.5
+        ctx.clear(PIPE_CLEAR_DEPTHSTENCIL, rgba, 1.0, 0)
+        del fb
+    
+        # vertex shader
+        vs = Shader('''
+            VERT
+            DCL IN[0], POSITION, CONSTANT
+            DCL IN[1], GENERIC, CONSTANT
+            DCL OUT[0], POSITION, CONSTANT
+            DCL OUT[1], GENERIC, CONSTANT
+            0:MOV OUT[0], IN[0]
+            1:MOV OUT[1], IN[1]
+            2:END
+        ''')
+        #vs.dump()
+        ctx.set_vertex_shader(vs)
+    
+        # fragment shader
+        op = {
+            PIPE_TEXTURE_1D: "1D", 
+            PIPE_TEXTURE_2D: "2D", 
+            PIPE_TEXTURE_3D: "3D", 
+            PIPE_TEXTURE_CUBE: "CUBE",
+        }[target]
+        fs = Shader('''
+            FRAG
+            DCL IN[0], GENERIC[0], LINEAR
+            DCL SAMP[0], CONSTANT
+            DCL OUT[0].z, POSITION
+            0:TEX OUT[0].z, IN[0], SAMP[0], %s
+            1:END
+        ''' % op)
+        #fs.dump()
+        ctx.set_fragment_shader(fs)
+
+        nverts = 4
+        nattrs = 2
+        verts = FloatArray(nverts * nattrs * 4)
+    
+        x = 0
+        y = 0
+        w, h = minify((width, height), level)
+    
+        pos = [
+            [x, y],
+            [x+w, y],
+            [x+w, y+h],
+            [x, y+h],
+        ]
+    
+        tex = tex_coords(texture, face, level, zslice)
+    
+        for i in range(0, 4):
+            j = 8*i
+            verts[j + 0] = pos[i][0]/float(width) # x
+            verts[j + 1] = pos[i][1]/float(height) # y
+            verts[j + 2] = 0.0 # z
+            verts[j + 3] = 1.0 # w
+            verts[j + 4] = tex[i][0] # s
+            verts[j + 5] = tex[i][1] # r
+            verts[j + 6] = tex[i][2] # q
+            verts[j + 7] = 1.0
+    
+        ctx.draw_vertices(PIPE_PRIM_TRIANGLE_FAN,
+                          nverts, 
+                          nattrs, 
+                          verts)
+    
+        ctx.flush()
+    
+        zsbuf = zsbuf_tex.get_surface()
+        
+        self.assert_rgba(ctx, zsbuf, x, y, w, h, expected_rgba, 4.0/256, 0.85)
+        
+
+
+
+def main():
+    random.seed(0xdead3eef)
+
+    dev = Device()
+    ctx = dev.context_create()
+    suite = TestSuite()
+    
+    targets = [
+        PIPE_TEXTURE_2D,
+        PIPE_TEXTURE_CUBE,
+        PIPE_TEXTURE_3D,
+    ]
+    
+    #sizes = [64, 32, 16, 8, 4, 2, 1]
+    #sizes = [1020, 508, 252, 62, 30, 14, 6, 3]
+    sizes = [64]
+    #sizes = [63]
+    
+    faces = [
+        PIPE_TEX_FACE_POS_X,
+        PIPE_TEX_FACE_NEG_X,
+        PIPE_TEX_FACE_POS_Y,
+        PIPE_TEX_FACE_NEG_Y, 
+        PIPE_TEX_FACE_POS_Z, 
+        PIPE_TEX_FACE_NEG_Z,
+    ]
+
+    try:
+        n = int(sys.argv[1])
+    except:
+        n = 10000
+    
+    for i in range(n):
+        format = random.choice(formats.keys())
+        if not util_format_is_depth_or_stencil(format):
+            is_depth_or_stencil = util_format_is_depth_or_stencil(format)
+
+            if is_depth_or_stencil:
+                target = PIPE_TEXTURE_2D
+            else:
+                target = random.choice(targets)
+            
+            size = random.choice(sizes)
+
+            if target == PIPE_TEXTURE_3D:
+                depth = size
+            else:
+                depth = 1
+
+            if target == PIPE_TEXTURE_CUBE:
+                face = random.choice(faces)
+            else:
+                face = PIPE_TEX_FACE_POS_X
+
+            levels = lods(size)
+            last_level = random.randint(0, levels - 1)
+            level = random.randint(0, last_level)
+            zslice = random.randint(0, max(depth >> level, 1) - 1)
+
+            if is_depth_or_stencil:
+                klass = TextureDepthSampleTest
+            else:
+                klass = TextureColorSampleTest
+
+            test = klass(
+                dev = dev,
+                ctx = ctx,
+                target = target,
+                format = format, 
+                width = size,
+                height = size,
+                depth = depth,
+                last_level = last_level,
+                face = face,
+                level = level,
+                zslice = zslice,
+            )
+            suite.add_test(test)
+    suite.run()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/tests/python/tests/texture_render.py b/src/gallium/tests/python/tests/texture_render.py
new file mode 100755
index 00000000000..23f3d2a57de
--- /dev/null
+++ b/src/gallium/tests/python/tests/texture_render.py
@@ -0,0 +1,320 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2009 VMware, Inc.
+# 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 VMWARE 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.
+# 
+##########################################################################
+
+
+from gallium import *
+from base import *
+
+
+def lods(*dims):
+    size = max(dims)
+    lods = 0
+    while size:
+        lods += 1
+        size >>= 1
+    return lods
+
+
+class TextureTest(TestCase):
+    
+    tags = (
+        'target',
+        'format',
+        'width',
+        'height',
+        'depth',
+        'last_level',
+        'face',
+        'level',
+        'zslice',
+    )
+
+    def test(self):
+        dev = self.dev
+        
+        target = self.target
+        format = self.format
+        width = self.width
+        height = self.height
+        depth = self.depth
+        last_level = self.last_level
+        face = self.face
+        level = self.level
+        zslice = self.zslice
+        
+        #  textures
+        dst_texture = dev.resource_create(
+            target = target,
+            format = format, 
+            width = width, 
+            height = height,
+            depth = depth, 
+            last_level = last_level,
+            bind = PIPE_BIND_RENDER_TARGET,
+        )
+        if dst_texture is None:
+            raise TestSkip
+
+        dst_surface = dst_texture.get_surface(face = face, level = level, zslice = zslice)
+        
+        ref_texture = dev.resource_create(
+            target = target,
+            format = format, 
+            width = dst_surface.width, 
+            height = dst_surface.height,
+            depth = 1, 
+            last_level = 0,
+            bind = PIPE_BIND_SAMPLER_VIEW,
+        )
+
+        ref_surface = ref_texture.get_surface()
+        
+        src_texture = dev.resource_create(
+            target = target,
+            format = PIPE_FORMAT_B8G8R8A8_UNORM, 
+            width = dst_surface.width, 
+            height = dst_surface.height,
+            depth = 1, 
+            last_level = 0,
+            bind = PIPE_BIND_SAMPLER_VIEW,
+        )
+
+        src_surface = src_texture.get_surface()
+        
+        expected_rgba = FloatArray(height*width*4) 
+        ref_surface.sample_rgba(expected_rgba)
+
+        src_surface.put_tile_rgba(0, 0, src_surface.width, src_surface.height, expected_rgba)
+        
+        ctx = self.dev.context_create()
+    
+        # disabled blending/masking
+        blend = Blend()
+        blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
+        blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
+        blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
+        blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
+        blend.rt[0].colormask = PIPE_MASK_RGBA
+        ctx.set_blend(blend)
+    
+        # no-op depth/stencil/alpha
+        depth_stencil_alpha = DepthStencilAlpha()
+        ctx.set_depth_stencil_alpha(depth_stencil_alpha)
+    
+        # rasterizer
+        rasterizer = Rasterizer()
+        rasterizer.front_winding = PIPE_WINDING_CW
+        rasterizer.cull_mode = PIPE_WINDING_NONE
+        rasterizer.bypass_vs_clip_and_viewport = 1
+        ctx.set_rasterizer(rasterizer)
+    
+        # samplers
+        sampler = Sampler()
+        sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+        sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+        sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
+        sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST
+        sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+        sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
+        sampler.normalized_coords = 1
+        sampler.min_lod = 0
+        sampler.max_lod = PIPE_MAX_TEXTURE_LEVELS - 1
+        ctx.set_fragment_sampler(0, sampler)
+        ctx.set_fragment_sampler_texture(0, src_texture)
+
+        #  framebuffer 
+        cbuf_tex = dev.resource_create(
+            PIPE_FORMAT_B8G8R8A8_UNORM, 
+            width, 
+            height,
+            bind = PIPE_BIND_RENDER_TARGET,
+        )
+
+        fb = Framebuffer()
+        fb.width = dst_surface.width
+        fb.height = dst_surface.height
+        fb.nr_cbufs = 1
+        fb.set_cbuf(0, dst_surface)
+        ctx.set_framebuffer(fb)
+        rgba = FloatArray(4);
+        rgba[0] = 0.0
+        rgba[1] = 0.0
+        rgba[2] = 0.0
+        rgba[3] = 0.0
+        ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
+        del fb
+    
+        # vertex shader
+        vs = Shader('''
+            VERT
+            DCL IN[0], POSITION, CONSTANT
+            DCL IN[1], GENERIC, CONSTANT
+            DCL OUT[0], POSITION, CONSTANT
+            DCL OUT[1], GENERIC, CONSTANT
+            0:MOV OUT[0], IN[0]
+            1:MOV OUT[1], IN[1]
+            2:END
+        ''')
+        #vs.dump()
+        ctx.set_vertex_shader(vs)
+    
+        # fragment shader
+        fs = Shader('''
+            FRAG
+            DCL IN[0], GENERIC[0], LINEAR
+            DCL OUT[0], COLOR, CONSTANT
+            DCL SAMP[0], CONSTANT
+            0:TEX OUT[0], IN[0], SAMP[0], 2D
+            1:END
+        ''')
+        #fs.dump()
+        ctx.set_fragment_shader(fs)
+
+        nverts = 4
+        nattrs = 2
+        verts = FloatArray(nverts * nattrs * 4)
+    
+        x = 0
+        y = 0
+        w = dst_surface.width
+        h = dst_surface.height
+    
+        pos = [
+            [x, y],
+            [x+w, y],
+            [x+w, y+h],
+            [x, y+h],
+        ]
+    
+        tex = [
+            [0.0, 0.0], 
+            [1.0, 0.0], 
+            [1.0, 1.0], 
+            [0.0, 1.0],
+        ]
+    
+        for i in range(0, 4):
+            j = 8*i
+            verts[j + 0] = pos[i][0] # x
+            verts[j + 1] = pos[i][1] # y
+            verts[j + 2] = 0.0 # z
+            verts[j + 3] = 1.0 # w
+            verts[j + 4] = tex[i][0] # s
+            verts[j + 5] = tex[i][1] # r
+            verts[j + 6] = 0.0
+            verts[j + 7] = 1.0
+    
+        ctx.draw_vertices(PIPE_PRIM_TRIANGLE_FAN,
+                          nverts, 
+                          nattrs, 
+                          verts)
+    
+        ctx.flush()
+    
+        self.assert_rgba(dst_surface, x, y, w, h, expected_rgba, 4.0/256, 0.85)
+        
+
+
+def main():
+    dev = Device()
+    suite = TestSuite()
+    
+    targets = [
+        PIPE_TEXTURE_2D,
+        PIPE_TEXTURE_CUBE,
+        #PIPE_TEXTURE_3D,
+    ]
+    
+    formats = [
+        PIPE_FORMAT_B8G8R8A8_UNORM,
+        PIPE_FORMAT_B8G8R8X8_UNORM,
+        #PIPE_FORMAT_B8G8R8A8_SRGB,
+        PIPE_FORMAT_B5G6R5_UNORM,
+        PIPE_FORMAT_B5G5R5A1_UNORM,
+        PIPE_FORMAT_B4G4R4A4_UNORM,
+        #PIPE_FORMAT_Z32_UNORM,
+        #PIPE_FORMAT_S8_USCALED_Z24_UNORM,
+        #PIPE_FORMAT_X8Z24_UNORM,
+        #PIPE_FORMAT_Z16_UNORM,
+        #PIPE_FORMAT_S8_USCALED,
+        PIPE_FORMAT_A8_UNORM,
+        PIPE_FORMAT_L8_UNORM,
+        #PIPE_FORMAT_DXT1_RGB,
+        #PIPE_FORMAT_DXT1_RGBA,
+        #PIPE_FORMAT_DXT3_RGBA,
+        #PIPE_FORMAT_DXT5_RGBA,
+    ]
+    
+    sizes = [64, 32, 16, 8, 4, 2, 1]
+    #sizes = [1020, 508, 252, 62, 30, 14, 6, 3]
+    #sizes = [64]
+    #sizes = [63]
+    
+    faces = [
+        PIPE_TEX_FACE_POS_X,
+        PIPE_TEX_FACE_NEG_X,
+        PIPE_TEX_FACE_POS_Y,
+        PIPE_TEX_FACE_NEG_Y, 
+        PIPE_TEX_FACE_POS_Z, 
+        PIPE_TEX_FACE_NEG_Z,
+    ]
+
+    for target in targets:
+        for format in formats:
+            for size in sizes:
+                if target == PIPE_TEXTURE_3D:
+                    depth = size
+                else:
+                    depth = 1
+                for face in faces:
+                    if target != PIPE_TEXTURE_CUBE and face:
+                        continue
+                    levels = lods(size)
+                    for last_level in range(levels):
+                        for level in range(0, last_level + 1):
+                            zslice = 0
+                            while zslice < depth >> level:
+                                test = TextureTest(
+                                    dev = dev,
+                                    target = target,
+                                    format = format, 
+                                    width = size,
+                                    height = size,
+                                    depth = depth,
+                                    last_level = last_level,
+                                    face = face,
+                                    level = level,
+                                    zslice = zslice,
+                                )
+                                suite.add_test(test)
+                                zslice = (zslice + 1)*2 - 1
+    suite.run()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/tests/python/tests/texture_transfer.py b/src/gallium/tests/python/tests/texture_transfer.py
new file mode 100755
index 00000000000..4aa3d6c709b
--- /dev/null
+++ b/src/gallium/tests/python/tests/texture_transfer.py
@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2009 VMware, Inc.
+# Copyright 2008 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 VMWARE 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.
+# 
+##########################################################################
+
+
+import os
+import random
+
+from gallium import *
+from base import *
+
+
+def lods(*dims):
+    size = max(dims)
+    lods = 0
+    while size:
+        lods += 1
+        size >>= 1
+    return lods
+
+
+class TextureTest(TestCase):
+    
+    tags = (
+        'target',
+        'format',
+        'width',
+        'height',
+        'depth',
+        'last_level',
+        'face',
+        'level',
+        'zslice',
+    )
+
+    def test(self):
+        dev = self.dev
+        ctx = self.ctx
+        
+        target = self.target
+        format = self.format
+        width = self.width
+        height = self.height
+        depth = self.depth
+        last_level = self.last_level
+        face = self.face
+        level = self.level
+        zslice = self.zslice
+        
+        bind = PIPE_BIND_SAMPLER_VIEW
+        geom_flags = 0
+        if not dev.is_format_supported(format, target, bind, geom_flags):
+            raise TestSkip
+        
+        #  textures
+        texture = dev.resource_create(
+            target = target,
+            format = format, 
+            width = width, 
+            height = height,
+            depth = depth, 
+            last_level = last_level,
+            bind = bind,
+        )
+        
+        surface = texture.get_surface(face, level, zslice)
+        
+        stride = util_format_get_stride(format, surface.width)
+        size = util_format_get_nblocksy(format, surface.height) * stride
+
+        in_raw = os.urandom(size)
+
+        ctx.surface_write_raw(surface, 0, 0, surface.width, surface.height, in_raw, stride)
+
+        out_raw = ctx.surface_read_raw(surface, 0, 0, surface.width, surface.height)
+
+        if in_raw != out_raw:
+            raise TestFailure
+
+
+def main():
+    dev = Device()
+    ctx = dev.context_create()
+    suite = TestSuite()
+    
+    targets = [
+        PIPE_TEXTURE_2D,
+        PIPE_TEXTURE_CUBE,
+        PIPE_TEXTURE_3D,
+    ]
+    
+    sizes = [64, 32, 16, 8, 4, 2, 1]
+    #sizes = [1020, 508, 252, 62, 30, 14, 6, 3]
+    #sizes = [64]
+    #sizes = [63]
+    
+    faces = [
+        PIPE_TEX_FACE_POS_X,
+        PIPE_TEX_FACE_NEG_X,
+        PIPE_TEX_FACE_POS_Y,
+        PIPE_TEX_FACE_NEG_Y, 
+        PIPE_TEX_FACE_POS_Z, 
+        PIPE_TEX_FACE_NEG_Z,
+    ]
+
+    try:
+        n = int(sys.argv[1])
+    except:
+        n = 10000
+    
+    for i in range(n):
+        format = random.choice(formats.keys())
+        if not util_format_is_depth_or_stencil(format):
+            is_depth_or_stencil = util_format_is_depth_or_stencil(format)
+
+            if is_depth_or_stencil:
+                target = PIPE_TEXTURE_2D
+            else:
+                target = random.choice(targets)
+            
+            size = random.choice(sizes)
+
+            if target == PIPE_TEXTURE_3D:
+                depth = size
+            else:
+                depth = 1
+
+            if target == PIPE_TEXTURE_CUBE:
+                face = random.choice(faces)
+            else:
+                face = PIPE_TEX_FACE_POS_X
+
+            levels = lods(size)
+            last_level = random.randint(0, levels - 1)
+            level = random.randint(0, last_level)
+            zslice = random.randint(0, max(depth >> level, 1) - 1)
+
+            test = TextureTest(
+                dev = dev,
+                ctx = ctx,
+                target = target,
+                format = format, 
+                width = size,
+                height = size,
+                depth = depth,
+                last_level = last_level,
+                face = face,
+                level = level,
+                zslice = zslice,
+            )
+            suite.add_test(test)
+    suite.run()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/tests/python/tests/tree.py b/src/gallium/tests/python/tests/tree.py
new file mode 100755
index 00000000000..0c1bcda4cf2
--- /dev/null
+++ b/src/gallium/tests/python/tests/tree.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+# 
+# See also:
+#  http://www.ailab.si/orange/doc/ofb/c_otherclass.htm
+
+import os.path
+import sys
+
+import orange
+import orngTree
+
+for arg in sys.argv[1:]:
+    name, ext = os.path.splitext(arg)
+
+    data = orange.ExampleTable(arg)
+
+    tree = orngTree.TreeLearner(data, sameMajorityPruning=1, mForPruning=2)
+
+    orngTree.printTxt(tree)
+
+    file(name+'.txt', 'wt').write(orngTree.dumpTree(tree) + '\n')
+
+    orngTree.printDot(tree, fileName=name+'.dot', nodeShape='ellipse', leafShape='box')
diff --git a/src/gallium/tests/raw/SConscript b/src/gallium/tests/raw/SConscript
new file mode 100644
index 00000000000..073b97951e7
--- /dev/null
+++ b/src/gallium/tests/raw/SConscript
@@ -0,0 +1,17 @@
+Import('*')
+
+env = env.Clone()
+
+env.Prepend(LIBPATH = [graw.dir])
+env.Prepend(LIBS = [graw.name])
+
+progs = [
+    'clear'
+]
+
+for prog in progs:
+    env.Program(
+        target = prog,
+        source = prog + '.c',
+    )
+
diff --git a/src/gallium/tests/raw/clear.c b/src/gallium/tests/raw/clear.c
new file mode 100644
index 00000000000..706e3be3728
--- /dev/null
+++ b/src/gallium/tests/raw/clear.c
@@ -0,0 +1,95 @@
+/* Display a cleared blue window.  This demo has no dependencies on
+ * any utility code, just the graw interface and gallium.
+ */
+
+#include "state_tracker/graw.h"
+#include "pipe/p_screen.h"
+#include "pipe/p_context.h"
+#include "pipe/p_state.h"
+#include "pipe/p_defines.h"
+#include <unistd.h>             /* for sleep() */
+
+#include "util/u_debug.h"       /* debug_dump_surface_bmp() */
+
+enum pipe_format formats[] = {
+   PIPE_FORMAT_R8G8B8A8_UNORM,
+   PIPE_FORMAT_B8G8R8A8_UNORM,
+   PIPE_FORMAT_NONE
+};
+
+static const int WIDTH = 300;
+static const int HEIGHT = 300;
+
+int main( int argc, char *argv[] )
+{
+   struct pipe_screen *screen;
+   struct pipe_context *pipe;
+   struct pipe_surface *surf;
+   struct pipe_framebuffer_state fb;
+   struct pipe_texture *tex, templat;
+   void *window = NULL;
+   float clear_color[4] = {1,0,1,1};
+   int i;
+
+   screen = graw_init();
+   if (screen == NULL)
+      exit(1);
+
+   for (i = 0; 
+        window == NULL && formats[i] != PIPE_FORMAT_NONE;
+        i++) {
+      
+      window = graw_create_window(0,0,300,300, formats[i]);
+   }
+   
+   if (window == NULL)
+      exit(2);
+   
+   pipe = screen->context_create(screen, NULL);
+   if (pipe == NULL)
+      exit(3);
+
+   templat.target = PIPE_TEXTURE_2D;
+   templat.format = formats[i];
+   templat.width0 = WIDTH;
+   templat.height0 = HEIGHT;
+   templat.depth0 = 1;
+   templat.last_level = 0;
+   templat.nr_samples = 1;
+   templat.bind = (PIPE_BIND_RENDER_TARGET |
+                        PIPE_BIND_DISPLAY_TARGET);
+   
+   tex = screen->resource_create(screen,
+                                &templat);
+   if (tex == NULL)
+      exit(4);
+
+   surf = screen->get_tex_surface(screen, tex, 0, 0, 0,
+                                  PIPE_BIND_RENDER_TARGET |
+                                  PIPE_BIND_DISPLAY_TARGET);
+   if (surf == NULL)
+      exit(5);
+
+   memset(&fb, 0, sizeof fb);
+   fb.nr_cbufs = 1;
+   fb.width = WIDTH;
+   fb.height = HEIGHT;
+   fb.cbufs[0] = surf;
+
+   pipe->set_framebuffer_state(pipe, &fb);
+   pipe->clear(pipe, PIPE_CLEAR_COLOR, clear_color, 0, 0);
+   pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
+
+   /* At the moment, libgraw includes/makes available all the symbols
+    * from gallium/auxiliary, including these debug helpers.  Will
+    * eventually want to bless some of these paths, and lock the
+    * others down so they aren't accessible from test programs.
+    */
+   if (0)
+      debug_dump_surface_bmp(pipe, "result.bmp", surf);
+
+   screen->flush_frontbuffer(screen, surf, window);
+
+   sleep(100);
+   return 0;
+}
diff --git a/src/gallium/tests/trivial/.gitignore b/src/gallium/tests/trivial/.gitignore
new file mode 100644
index 00000000000..af6cdedbeba
--- /dev/null
+++ b/src/gallium/tests/trivial/.gitignore
@@ -0,0 +1,3 @@
+tri
+quad-tex
+result.bmp
diff --git a/src/gallium/tests/trivial/Makefile b/src/gallium/tests/trivial/Makefile
new file mode 100644
index 00000000000..c6eb7269c82
--- /dev/null
+++ b/src/gallium/tests/trivial/Makefile
@@ -0,0 +1,44 @@
+# progs/gallium/simple/Makefile
+
+TOP = ../../../..
+include $(TOP)/configs/current
+
+INCLUDES = \
+	-I. \
+	-I$(TOP)/src/gallium/include \
+	-I$(TOP)/src/gallium/auxiliary \
+	-I$(TOP)/src/gallium/drivers \
+	-I$(TOP)/src/gallium/winsys \
+	$(PROG_INCLUDES)
+
+LINKS = \
+	$(TOP)/src/gallium/drivers/trace/libtrace.a \
+	$(TOP)/src/gallium/winsys/sw/null/libws_null.a \
+	$(TOP)/src/gallium/drivers/softpipe/libsoftpipe.a \
+	$(GALLIUM_AUXILIARIES) \
+	$(PROG_LINKS)
+
+SOURCES = \
+	tri.c \
+	quad-tex.c
+
+OBJECTS = $(SOURCES:.c=.o)
+
+PROGS = $(OBJECTS:.o=)
+
+##### TARGETS #####
+
+default: $(PROGS)
+
+clean:
+	-rm -f $(PROGS)
+	-rm -f *.o
+	-rm -f result.bmp
+
+##### RULES #####
+
+$(OBJECTS): %.o: %.c
+	$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $(PROG_DEFINES) $< -o $@
+
+$(PROGS): %: %.o
+	$(CC) $(LDFLAGS) $< $(LINKS) -lm -lpthread -o $@
diff --git a/src/gallium/tests/trivial/quad-tex.c b/src/gallium/tests/trivial/quad-tex.c
new file mode 100644
index 00000000000..7ad157c5ac7
--- /dev/null
+++ b/src/gallium/tests/trivial/quad-tex.c
@@ -0,0 +1,346 @@
+/**************************************************************************
+ *
+ * Copyright © 2010 Jakob Bornecrantz
+ *
+ * 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, sublicense,
+ * 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 NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ *
+ **************************************************************************/
+
+
+#define USE_TRACE 0
+#define WIDTH 300
+#define HEIGHT 300
+#define NEAR 30
+#define FAR 1000
+#define FLIP 0
+
+/* pipe_*_state structs */
+#include "pipe/p_state.h"
+/* pipe_context */
+#include "pipe/p_context.h"
+/* pipe_screen */
+#include "pipe/p_screen.h"
+/* PIPE_* */
+#include "pipe/p_defines.h"
+/* TGSI_SEMANTIC_{POSITION|GENERIC} */
+#include "pipe/p_shader_tokens.h"
+/* pipe_buffer_* helpers */
+#include "util/u_inlines.h"
+
+/* constant state object helper */
+#include "cso_cache/cso_context.h"
+
+/* u_sampler_view_default_template */
+#include "util/u_sampler.h"
+/* debug_dump_surface_bmp */
+#include "util/u_debug.h"
+/* util_draw_vertex_buffer helper */
+#include "util/u_draw_quad.h"
+/* FREE & CALLOC_STRUCT */
+#include "util/u_memory.h"
+/* util_make_[fragment|vertex]_passthrough_shader */
+#include "util/u_simple_shaders.h"
+
+/* softpipe software driver */
+#include "softpipe/sp_public.h"
+
+/* null software winsys */
+#include "sw/null/null_sw_winsys.h"
+
+/* traceing support see src/gallium/drivers/trace/README for more info. */
+#if USE_TRACE
+#include "trace/tr_screen.h"
+#include "trace/tr_context.h"
+#endif
+
+struct program
+{
+	struct pipe_screen *screen;
+	struct pipe_context *pipe;
+	struct cso_context *cso;
+
+	struct pipe_blend_state blend;
+	struct pipe_depth_stencil_alpha_state depthstencil;
+	struct pipe_rasterizer_state rasterizer;
+	struct pipe_sampler_state sampler;
+	struct pipe_viewport_state viewport;
+	struct pipe_framebuffer_state framebuffer;
+	struct pipe_vertex_element velem[2];
+
+	void *vs;
+	void *fs;
+
+	float clear_color[4];
+
+	struct pipe_buffer *vbuf;
+	struct pipe_texture *target;
+	struct pipe_texture *tex;
+	struct pipe_sampler_view *view;
+};
+
+static void init_prog(struct program *p)
+{
+	/* create the software rasterizer */
+	p->screen = softpipe_create_screen(null_sw_create());
+#if USE_TRACE
+	p->screen = trace_screen_create(p->screen);
+#endif
+	p->pipe = p->screen->context_create(p->screen, NULL);
+	p->cso = cso_create_context(p->pipe);
+
+	/* set clear color */
+	p->clear_color[0] = 0.3;
+	p->clear_color[1] = 0.1;
+	p->clear_color[2] = 0.3;
+	p->clear_color[3] = 1.0;
+
+	/* vertex buffer */
+	{
+		float vertices[4][2][4] = {
+			{
+				{ 0.9f, 0.9f, 0.0f, 1.0f },
+				{ 1.0f, 1.0f, 0.0f, 1.0f }
+			},
+			{
+				{ -0.9f, 0.9f, 0.0f, 1.0f },
+				{  0.0f, 1.0f, 0.0f, 1.0f }
+			},
+			{
+				{ -0.9f, -0.9f, 0.0f, 1.0f },
+				{  0.0f,  0.0f, 1.0f, 1.0f }
+			},
+			{
+				{ 0.9f, -0.9f, 0.0f, 1.0f },
+				{ 1.0f,  0.0f, 1.0f, 1.0f }
+			}
+		};
+
+		p->vbuf = pipe_buffer_create(p->screen, 16, PIPE_BUFFER_USAGE_VERTEX, sizeof(vertices));
+		pipe_buffer_write(p->screen, p->vbuf, 0, sizeof(vertices), vertices);
+	}
+
+	/* render target texture */
+	{
+		struct pipe_texture tmplt;
+		memset(&tmplt, 0, sizeof(tmplt));
+		tmplt.target = PIPE_TEXTURE_2D;
+		tmplt.format = PIPE_FORMAT_B8G8R8A8_UNORM; /* All drivers support this */
+		tmplt.width0 = WIDTH;
+		tmplt.height0 = HEIGHT;
+		tmplt.depth0 = 1;
+		tmplt.last_level = 0;
+		tmplt.bind = PIPE_BIND_RENDER_TARGET;
+
+		p->target = p->screen->resource_create(p->screen, &tmplt);
+	}
+
+	/* sampler texture */
+	{
+		uint32_t *ptr;
+		struct pipe_transfer *t;
+		struct pipe_texture t_tmplt;
+		struct pipe_sampler_view v_tmplt;
+
+		memset(&t_tmplt, 0, sizeof(t_tmplt));
+		t_tmplt.target = PIPE_TEXTURE_2D;
+		t_tmplt.format = PIPE_FORMAT_B8G8R8A8_UNORM; /* All drivers support this */
+		t_tmplt.width0 = 2;
+		t_tmplt.height0 = 2;
+		t_tmplt.depth0 = 1;
+		t_tmplt.last_level = 0;
+		t_tmplt.bind = PIPE_BIND_RENDER_TARGET;
+
+		p->tex = p->screen->resource_create(p->screen, &t_tmplt);
+
+		t = p->pipe->get_tex_transfer(p->pipe, p->tex,
+		                              0, 0, 0, /* face, level, zslice */
+		                              PIPE_TRANSFER_WRITE,
+		                              0, 0, 2, 2); /* x, y, width, height */
+
+		ptr = p->pipe->transfer_map(p->pipe, t);
+		ptr[0] = 0xffff0000;
+		ptr[1] = 0xff0000ff;
+		ptr[2] = 0xff00ff00;
+		ptr[3] = 0xffffff00;
+		p->pipe->transfer_unmap(p->pipe, t);
+
+		p->pipe->tex_transfer_destroy(p->pipe, t);
+
+		u_sampler_view_default_template(&v_tmplt, p->tex, p->tex->format);
+
+		p->view = p->pipe->create_sampler_view(p->pipe, p->tex, &v_tmplt);
+	}
+
+	/* disabled blending/masking */
+	memset(&p->blend, 0, sizeof(p->blend));
+	p->blend.rt[0].colormask = PIPE_MASK_RGBA;
+
+	/* no-op depth/stencil/alpha */
+	memset(&p->depthstencil, 0, sizeof(p->depthstencil));
+
+	/* rasterizer */
+	memset(&p->rasterizer, 0, sizeof(p->rasterizer));
+	p->rasterizer.front_winding = PIPE_WINDING_CW;
+	p->rasterizer.cull_mode = PIPE_WINDING_NONE;
+	p->rasterizer.gl_rasterization_rules = 1;
+
+	/* sampler */
+	memset(&p->sampler, 0, sizeof(p->sampler));
+	p->sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+	p->sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+	p->sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
+	p->sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
+	p->sampler.min_img_filter = PIPE_TEX_MIPFILTER_LINEAR;
+	p->sampler.mag_img_filter = PIPE_TEX_MIPFILTER_LINEAR;
+	p->sampler.normalized_coords = 1;
+
+	/* drawing destination */
+	memset(&p->framebuffer, 0, sizeof(p->framebuffer));
+	p->framebuffer.width = WIDTH;
+	p->framebuffer.height = HEIGHT;
+	p->framebuffer.nr_cbufs = 1;
+	p->framebuffer.cbufs[0] = p->screen->get_tex_surface(p->screen, p->target, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
+
+	/* viewport, depth isn't really needed */
+	{
+		float x = 0;
+		float y = 0;
+		float z = FAR;
+		float half_width = (float)WIDTH / 2.0f;
+		float half_height = (float)HEIGHT / 2.0f;
+		float half_depth = ((float)FAR - (float)NEAR) / 2.0f;
+		float scale, bias;
+
+		if (FLIP) {
+			scale = -1.0f;
+			bias = (float)HEIGHT;
+		} else {
+			scale = 1.0f;
+			bias = 0.0f;
+		}
+
+		p->viewport.scale[0] = half_width;
+		p->viewport.scale[1] = half_height * scale;
+		p->viewport.scale[2] = half_depth;
+		p->viewport.scale[3] = 1.0f;
+
+		p->viewport.translate[0] = half_width + x;
+		p->viewport.translate[1] = (half_height + y) * scale + bias;
+		p->viewport.translate[2] = half_depth + z;
+		p->viewport.translate[3] = 0.0f;
+	}
+
+	/* vertex elements state */
+	memset(p->velem, 0, sizeof(p->velem));
+	p->velem[0].src_offset = 0 * 4 * sizeof(float); /* offset 0, first element */
+	p->velem[0].instance_divisor = 0;
+	p->velem[0].vertex_buffer_index = 0;
+	p->velem[0].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+
+	p->velem[1].src_offset = 1 * 4 * sizeof(float); /* offset 16, second element */
+	p->velem[1].instance_divisor = 0;
+	p->velem[1].vertex_buffer_index = 0;
+	p->velem[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+
+	/* vertex shader */
+	{
+		const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
+		                                TGSI_SEMANTIC_GENERIC };
+		const uint semantic_indexes[] = { 0, 0 };
+		p->vs = util_make_vertex_passthrough_shader(p->pipe, 2, semantic_names, semantic_indexes);
+	}
+
+	/* fragment shader */
+	p->fs = util_make_fragment_tex_shader(p->pipe, TGSI_TEXTURE_2D);
+}
+
+static void close_prog(struct program *p)
+{
+	/* unset bound textures as well */
+	cso_set_fragment_sampler_views(p->cso, 0, NULL);
+
+	/* unset all state */
+	cso_release_all(p->cso);
+
+	p->pipe->delete_vs_state(p->pipe, p->vs);
+	p->pipe->delete_fs_state(p->pipe, p->fs);
+
+	pipe_surface_reference(&p->framebuffer.cbufs[0], NULL);
+	pipe_sampler_view_reference(&p->view, NULL);
+	pipe_texture_reference(&p->target, NULL);
+	pipe_texture_reference(&p->tex, NULL);
+	pipe_buffer_reference(&p->vbuf, NULL);
+
+	cso_destroy_context(p->cso);
+	p->pipe->destroy(p->pipe);
+	p->screen->destroy(p->screen);
+
+	FREE(p);
+}
+
+static void draw(struct program *p)
+{
+	/* set the render target */
+	cso_set_framebuffer(p->cso, &p->framebuffer);
+
+	/* clear the render target */
+	p->pipe->clear(p->pipe, PIPE_CLEAR_COLOR, p->clear_color, 0, 0);
+
+	/* set misc state we care about */
+	cso_set_blend(p->cso, &p->blend);
+	cso_set_depth_stencil_alpha(p->cso, &p->depthstencil);
+	cso_set_rasterizer(p->cso, &p->rasterizer);
+	cso_set_viewport(p->cso, &p->viewport);
+
+	/* sampler */
+	cso_single_sampler(p->cso, 0, &p->sampler);
+	cso_single_sampler_done(p->cso);
+
+	/* texture sampler view */
+	cso_set_fragment_sampler_views(p->cso, 1, &p->view);
+
+	/* shaders */
+	cso_set_fragment_shader_handle(p->cso, p->fs);
+	cso_set_vertex_shader_handle(p->cso, p->vs);
+
+	/* vertex element data */
+	cso_set_vertex_elements(p->cso, 2, p->velem);
+
+	util_draw_vertex_buffer(p->pipe,
+	                        p->vbuf, 0,
+	                        PIPE_PRIM_QUADS,
+	                        4,  /* verts */
+	                        2); /* attribs/vert */
+
+	p->pipe->flush(p->pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
+
+	debug_dump_surface_bmp(p->pipe, "result.bmp", p->framebuffer.cbufs[0]);
+}
+
+int main(int argc, char** argv)
+{
+	struct program *p = CALLOC_STRUCT(program);
+
+	init_prog(p);
+	draw(p);
+	close_prog(p);
+
+	return 0;
+}
diff --git a/src/gallium/tests/trivial/tri.c b/src/gallium/tests/trivial/tri.c
new file mode 100644
index 00000000000..6286aefe319
--- /dev/null
+++ b/src/gallium/tests/trivial/tri.c
@@ -0,0 +1,278 @@
+/**************************************************************************
+ *
+ * Copyright © 2010 Jakob Bornecrantz
+ *
+ * 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, sublicense,
+ * 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 NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ *
+ **************************************************************************/
+
+
+#define USE_TRACE 0
+#define WIDTH 300
+#define HEIGHT 300
+#define NEAR 30
+#define FAR 1000
+#define FLIP 0
+
+/* pipe_*_state structs */
+#include "pipe/p_state.h"
+/* pipe_context */
+#include "pipe/p_context.h"
+/* pipe_screen */
+#include "pipe/p_screen.h"
+/* PIPE_* */
+#include "pipe/p_defines.h"
+/* TGSI_SEMANTIC_{POSITION|GENERIC} */
+#include "pipe/p_shader_tokens.h"
+/* pipe_buffer_* helpers */
+#include "util/u_inlines.h"
+
+/* constant state object helper */
+#include "cso_cache/cso_context.h"
+
+/* debug_dump_surface_bmp */
+#include "util/u_debug.h"
+/* util_draw_vertex_buffer helper */
+#include "util/u_draw_quad.h"
+/* FREE & CALLOC_STRUCT */
+#include "util/u_memory.h"
+/* util_make_[fragment|vertex]_passthrough_shader */
+#include "util/u_simple_shaders.h"
+
+/* softpipe software driver */
+#include "softpipe/sp_public.h"
+
+/* null software winsys */
+#include "sw/null/null_sw_winsys.h"
+
+/* traceing support see src/gallium/drivers/trace/README for more info. */
+#if USE_TRACE
+#include "trace/tr_screen.h"
+#include "trace/tr_context.h"
+#endif
+
+struct program
+{
+	struct pipe_screen *screen;
+	struct pipe_context *pipe;
+	struct cso_context *cso;
+
+	struct pipe_blend_state blend;
+	struct pipe_depth_stencil_alpha_state depthstencil;
+	struct pipe_rasterizer_state rasterizer;
+	struct pipe_viewport_state viewport;
+	struct pipe_framebuffer_state framebuffer;
+	struct pipe_vertex_element velem[2];
+
+	void *vs;
+	void *fs;
+
+	float clear_color[4];
+
+	struct pipe_buffer *vbuf;
+	struct pipe_texture *target;
+};
+
+static void init_prog(struct program *p)
+{
+	/* create the software rasterizer */
+	p->screen = softpipe_create_screen(null_sw_create());
+#if USE_TRACE
+	p->screen = trace_screen_create(p->screen);
+#endif
+	p->pipe = p->screen->context_create(p->screen, NULL);
+	p->cso = cso_create_context(p->pipe);
+
+	/* set clear color */
+	p->clear_color[0] = 0.3;
+	p->clear_color[1] = 0.1;
+	p->clear_color[2] = 0.3;
+	p->clear_color[3] = 1.0;
+
+	/* vertex buffer */
+	{
+		float vertices[4][2][4] = {
+			{
+				{ 0.0f, -0.9f, 0.0f, 1.0f },
+				{ 1.0f, 0.0f, 0.0f, 1.0f }
+			},
+			{
+				{ -0.9f, 0.9f, 0.0f, 1.0f },
+				{ 0.0f, 1.0f, 0.0f, 1.0f }
+			},
+			{
+				{ 0.9f, 0.9f, 0.0f, 1.0f },
+				{ 0.0f, 0.0f, 1.0f, 1.0f }
+			}
+		};
+
+		p->vbuf = pipe_buffer_create(p->screen, 16, PIPE_BUFFER_USAGE_VERTEX, sizeof(vertices));
+		pipe_buffer_write(p->screen, p->vbuf, 0, sizeof(vertices), vertices);
+	}
+
+	/* render target texture */
+	{
+		struct pipe_texture tmplt;
+		memset(&tmplt, 0, sizeof(tmplt));
+		tmplt.target = PIPE_TEXTURE_2D;
+		tmplt.format = PIPE_FORMAT_B8G8R8A8_UNORM; /* All drivers support this */
+		tmplt.width0 = WIDTH;
+		tmplt.height0 = HEIGHT;
+		tmplt.depth0 = 1;
+		tmplt.last_level = 0;
+		tmplt.bind = PIPE_BIND_RENDER_TARGET;
+
+		p->target = p->screen->resource_create(p->screen, &tmplt);
+	}
+
+	/* disabled blending/masking */
+	memset(&p->blend, 0, sizeof(p->blend));
+	p->blend.rt[0].colormask = PIPE_MASK_RGBA;
+
+	/* no-op depth/stencil/alpha */
+	memset(&p->depthstencil, 0, sizeof(p->depthstencil));
+
+	/* rasterizer */
+	memset(&p->rasterizer, 0, sizeof(p->rasterizer));
+	p->rasterizer.front_winding = PIPE_WINDING_CW;
+	p->rasterizer.cull_mode = PIPE_WINDING_NONE;
+	p->rasterizer.gl_rasterization_rules = 1;
+
+	/* drawing destination */
+	memset(&p->framebuffer, 0, sizeof(p->framebuffer));
+	p->framebuffer.width = WIDTH;
+	p->framebuffer.height = HEIGHT;
+	p->framebuffer.nr_cbufs = 1;
+	p->framebuffer.cbufs[0] = p->screen->get_tex_surface(p->screen, p->target, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
+
+	/* viewport, depth isn't really needed */
+	{
+		float x = 0;
+		float y = 0;
+		float z = FAR;
+		float half_width = (float)WIDTH / 2.0f;
+		float half_height = (float)HEIGHT / 2.0f;
+		float half_depth = ((float)FAR - (float)NEAR) / 2.0f;
+		float scale, bias;
+
+		if (FLIP) {
+			scale = -1.0f;
+			bias = (float)HEIGHT;
+		} else {
+			scale = 1.0f;
+			bias = 0.0f;
+		}
+
+		p->viewport.scale[0] = half_width;
+		p->viewport.scale[1] = half_height * scale;
+		p->viewport.scale[2] = half_depth;
+		p->viewport.scale[3] = 1.0f;
+
+		p->viewport.translate[0] = half_width + x;
+		p->viewport.translate[1] = (half_height + y) * scale + bias;
+		p->viewport.translate[2] = half_depth + z;
+		p->viewport.translate[3] = 0.0f;
+	}
+
+	/* vertex elements state */
+	memset(p->velem, 0, sizeof(p->velem));
+	p->velem[0].src_offset = 0 * 4 * sizeof(float); /* offset 0, first element */
+	p->velem[0].instance_divisor = 0;
+	p->velem[0].vertex_buffer_index = 0;
+	p->velem[0].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+
+	p->velem[1].src_offset = 1 * 4 * sizeof(float); /* offset 16, second element */
+	p->velem[1].instance_divisor = 0;
+	p->velem[1].vertex_buffer_index = 0;
+	p->velem[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+
+	/* vertex shader */
+	{
+			const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
+							TGSI_SEMANTIC_COLOR };
+			const uint semantic_indexes[] = { 0, 0 };
+			p->vs = util_make_vertex_passthrough_shader(p->pipe, 2, semantic_names, semantic_indexes);
+	}
+
+	/* fragment shader */
+	p->fs = util_make_fragment_passthrough_shader(p->pipe);
+}
+
+static void close_prog(struct program *p)
+{
+	/* unset all state */
+	cso_release_all(p->cso);
+
+	p->pipe->delete_vs_state(p->pipe, p->vs);
+	p->pipe->delete_fs_state(p->pipe, p->fs);
+
+	pipe_surface_reference(&p->framebuffer.cbufs[0], NULL);
+	pipe_texture_reference(&p->target, NULL);
+	pipe_buffer_reference(&p->vbuf, NULL);
+
+	cso_destroy_context(p->cso);
+	p->pipe->destroy(p->pipe);
+	p->screen->destroy(p->screen);
+
+	FREE(p);
+}
+
+static void draw(struct program *p)
+{
+	/* set the render target */
+	cso_set_framebuffer(p->cso, &p->framebuffer);
+
+	/* clear the render target */
+	p->pipe->clear(p->pipe, PIPE_CLEAR_COLOR, p->clear_color, 0, 0);
+
+	/* set misc state we care about */
+	cso_set_blend(p->cso, &p->blend);
+	cso_set_depth_stencil_alpha(p->cso, &p->depthstencil);
+	cso_set_rasterizer(p->cso, &p->rasterizer);
+	cso_set_viewport(p->cso, &p->viewport);
+
+	/* shaders */
+	cso_set_fragment_shader_handle(p->cso, p->fs);
+	cso_set_vertex_shader_handle(p->cso, p->vs);
+
+	/* vertex element data */
+	cso_set_vertex_elements(p->cso, 2, p->velem);
+
+	util_draw_vertex_buffer(p->pipe,
+	                        p->vbuf, 0,
+	                        PIPE_PRIM_TRIANGLES,
+	                        3,  /* verts */
+	                        2); /* attribs/vert */
+
+	p->pipe->flush(p->pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
+
+	debug_dump_surface_bmp(p->pipe, "result.bmp", p->framebuffer.cbufs[0]);
+}
+
+int main(int argc, char** argv)
+{
+	struct program *p = CALLOC_STRUCT(program);
+
+	init_prog(p);
+	draw(p);
+	close_prog(p);
+
+	return 0;
+}
diff --git a/src/gallium/tests/unit/Makefile b/src/gallium/tests/unit/Makefile
new file mode 100644
index 00000000000..018c3a73475
--- /dev/null
+++ b/src/gallium/tests/unit/Makefile
@@ -0,0 +1,45 @@
+# progs/gallium/simple/Makefile
+
+TOP = ../../../..
+include $(TOP)/configs/current
+
+INCLUDES = \
+	-I. \
+	-I$(TOP)/src/gallium/include \
+	-I$(TOP)/src/gallium/auxiliary \
+	-I$(TOP)/src/gallium/drivers \
+	-I$(TOP)/src/gallium/winsys \
+	$(PROG_INCLUDES)
+
+LINKS = \
+	$(TOP)/src/gallium/drivers/trace/libtrace.a \
+	$(TOP)/src/gallium/winsys/sw/null/libws_null.a \
+	$(TOP)/src/gallium/drivers/softpipe/libsoftpipe.a \
+	$(GALLIUM_AUXILIARIES) \
+	$(PROG_LINKS)
+
+SOURCES = \
+	pipe_barrier_test.c \
+	u_format_test.c \
+	u_half_test.c
+
+OBJECTS = $(SOURCES:.c=.o)
+
+PROGS = $(OBJECTS:.o=)
+
+##### TARGETS #####
+
+default: $(PROGS)
+
+clean:
+	-rm -f $(PROGS)
+	-rm -f *.o
+	-rm -f result.bmp
+
+##### RULES #####
+
+$(OBJECTS): %.o: %.c
+	$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $(PROG_DEFINES) $< -o $@
+
+$(PROGS): %: %.o
+	$(CC) $(LDFLAGS) $< $(LINKS) -lm -lpthread -ldl -o $@
diff --git a/src/gallium/tests/unit/SConscript b/src/gallium/tests/unit/SConscript
new file mode 100644
index 00000000000..364eb662077
--- /dev/null
+++ b/src/gallium/tests/unit/SConscript
@@ -0,0 +1,24 @@
+Import('*')
+
+env = env.Clone()
+
+env.Prepend(LIBS = [gallium])
+
+progs = [
+    'pipe_barrier_test',
+    'u_format_test',
+    'u_half_test'
+]
+
+for prog in progs:
+    prog = env.Program(
+        target = prog,
+        source = prog + '.c',
+    )
+    
+    env.InstallProgram(prog)
+
+    # http://www.scons.org/wiki/UnitTests
+    test_alias = env.Alias('unit', [prog], prog[0].abspath)
+    AlwaysBuild(test_alias)
+
diff --git a/src/gallium/drivers/llvmpipe/lp_buffer.h b/src/gallium/tests/unit/pipe_barrier_test.c
index d6b8184a0b9..f5d72b0abae 100644
--- a/src/gallium/drivers/llvmpipe/lp_buffer.h
+++ b/src/gallium/tests/unit/pipe_barrier_test.c
@@ -1,6 +1,6 @@
 /**************************************************************************
  *
- * Copyright 2009 VMware, Inc.
+ * Copyright 2009-2010 VMware, Inc.
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -25,31 +25,62 @@
  *
  **************************************************************************/
 
-#ifndef LP_BUFFER_H
-#define LP_BUFFER_H
 
-#include "pipe/p_compiler.h"
-#include "pipe/p_state.h"
+/*
+ *  Test case for pipe_barrier.
+ *
+ *  The test succeeds if no thread exits before all the other threads reach
+ *  the barrier.
+ */
 
 
-struct llvmpipe_buffer
-{
-   struct pipe_buffer base;
-   boolean userBuffer;  /** Is this a user-space buffer? */
-   void *data;
-};
+#include <stdio.h>
+
+#include "os/os_thread.h"
+#include "os/os_time.h"
+
 
+#define NUM_THREADS 10
 
-/** Cast wrapper */
-static INLINE struct llvmpipe_buffer *
-llvmpipe_buffer( struct pipe_buffer *buf )
+static pipe_thread threads[NUM_THREADS];
+static pipe_barrier barrier;
+static int thread_ids[NUM_THREADS];
+
+
+static PIPE_THREAD_ROUTINE(thread_function, thread_data)
 {
-   return (struct llvmpipe_buffer *)buf;
+   int thread_id = *((int *) thread_data);
+
+   printf("thread %d starting\n", thread_id);
+   os_time_sleep(thread_id * 1000 * 1000);
+   printf("thread %d before barrier\n", thread_id);
+   pipe_barrier_wait(&barrier);
+   printf("thread %d exiting\n", thread_id);
+
+   return NULL;
 }
 
 
-void
-llvmpipe_init_screen_buffer_funcs(struct pipe_screen *screen);
+int main()
+{
+   int i;
+
+   printf("pipe_barrier_test starting\n");
+
+   pipe_barrier_init(&barrier, NUM_THREADS);
+
+   for (i = 0; i < NUM_THREADS; i++) {
+      thread_ids[i] = i;
+      threads[i] = pipe_thread_create(thread_function, (void *) &thread_ids[i]);
+   }
 
+   for (i = 0; i < NUM_THREADS; i++ ) {
+      pipe_thread_wait(threads[i]);
+   }
 
-#endif /* LP_BUFFER_H */
+   pipe_barrier_destroy(&barrier);
+
+   printf("pipe_barrier_test exiting\n");
+
+   return 0;
+}
diff --git a/src/gallium/tests/unit/u_format_test.c b/src/gallium/tests/unit/u_format_test.c
new file mode 100644
index 00000000000..cfde6af75e0
--- /dev/null
+++ b/src/gallium/tests/unit/u_format_test.c
@@ -0,0 +1,708 @@
+/**************************************************************************
+ *
+ * Copyright 2009-2010 VMware, Inc.
+ * 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 VMWARE 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.
+ *
+ **************************************************************************/
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+
+#include "util/u_half.h"
+#include "util/u_format.h"
+#include "util/u_format_tests.h"
+#include "util/u_format_s3tc.h"
+
+
+static boolean
+compare_float(float x, float y)
+{
+   float error = y - x;
+
+   if (error < 0.0f)
+      error = -error;
+
+   if (error > FLT_EPSILON) {
+      return FALSE;
+   }
+
+   return TRUE;
+}
+
+
+static void
+print_packed(const struct util_format_description *format_desc,
+             const char *prefix,
+             const uint8_t *packed,
+             const char *suffix)
+{
+   unsigned i;
+   const char *sep = "";
+
+   printf("%s", prefix);
+   for (i = 0; i < format_desc->block.bits/8; ++i) {
+      printf("%s%02x", sep, packed[i]);
+      sep = " ";
+   }
+   printf("%s", suffix);
+}
+
+
+static void
+print_unpacked_rgba_doubl(const struct util_format_description *format_desc,
+                     const char *prefix,
+                     const double unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
+                     const char *suffix)
+{
+   unsigned i, j;
+   const char *sep = "";
+
+   printf("%s", prefix);
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         printf("%s{%f, %f, %f, %f}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
+         sep = ", ";
+      }
+      sep = ",\n";
+   }
+   printf("%s", suffix);
+}
+
+
+static void
+print_unpacked_rgba_float(const struct util_format_description *format_desc,
+                     const char *prefix,
+                     float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
+                     const char *suffix)
+{
+   unsigned i, j;
+   const char *sep = "";
+
+   printf("%s", prefix);
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         printf("%s{%f, %f, %f, %f}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
+         sep = ", ";
+      }
+      sep = ",\n";
+   }
+   printf("%s", suffix);
+}
+
+
+static void
+print_unpacked_rgba_8unorm(const struct util_format_description *format_desc,
+                      const char *prefix,
+                      uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
+                      const char *suffix)
+{
+   unsigned i, j;
+   const char *sep = "";
+
+   printf("%s", prefix);
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         printf("%s{0x%02x, 0x%02x, 0x%02x, 0x%02x}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
+         sep = ", ";
+      }
+   }
+   printf("%s", suffix);
+}
+
+
+static void
+print_unpacked_z_float(const struct util_format_description *format_desc,
+                       const char *prefix,
+                       float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH],
+                       const char *suffix)
+{
+   unsigned i, j;
+   const char *sep = "";
+
+   printf("%s", prefix);
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         printf("%s%f", sep, unpacked[i][j]);
+         sep = ", ";
+      }
+      sep = ",\n";
+   }
+   printf("%s", suffix);
+}
+
+
+static void
+print_unpacked_z_32unorm(const struct util_format_description *format_desc,
+                         const char *prefix,
+                         uint32_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH],
+                         const char *suffix)
+{
+   unsigned i, j;
+   const char *sep = "";
+
+   printf("%s", prefix);
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         printf("%s0x%08x", sep, unpacked[i][j]);
+         sep = ", ";
+      }
+   }
+   printf("%s", suffix);
+}
+
+
+static void
+print_unpacked_s_8uscaled(const struct util_format_description *format_desc,
+                          const char *prefix,
+                          uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH],
+                          const char *suffix)
+{
+   unsigned i, j;
+   const char *sep = "";
+
+   printf("%s", prefix);
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         printf("%s0x%02x", sep, unpacked[i][j]);
+         sep = ", ";
+      }
+   }
+   printf("%s", suffix);
+}
+
+
+static boolean
+test_format_fetch_rgba_float(const struct util_format_description *format_desc,
+                             const struct util_format_test_case *test)
+{
+   float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
+   unsigned i, j, k;
+   boolean success;
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         format_desc->fetch_rgba_float(unpacked[i][j], test->packed, j, i);
+         for (k = 0; k < 4; ++k) {
+            if (!compare_float(test->unpacked[i][j][k], unpacked[i][j][k])) {
+               success = FALSE;
+            }
+         }
+      }
+   }
+
+   if (!success) {
+      print_unpacked_rgba_float(format_desc, "FAILED: ", unpacked, " obtained\n");
+      print_unpacked_rgba_doubl(format_desc, "        ", test->unpacked, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+test_format_unpack_rgba_float(const struct util_format_description *format_desc,
+                              const struct util_format_test_case *test)
+{
+   float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
+   unsigned i, j, k;
+   boolean success;
+
+   format_desc->unpack_rgba_float(&unpacked[0][0][0], sizeof unpacked[0],
+                             test->packed, 0,
+                             format_desc->block.width, format_desc->block.height);
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         for (k = 0; k < 4; ++k) {
+            if (!compare_float(test->unpacked[i][j][k], unpacked[i][j][k])) {
+               success = FALSE;
+            }
+         }
+      }
+   }
+
+   if (!success) {
+      print_unpacked_rgba_float(format_desc, "FAILED: ", unpacked, " obtained\n");
+      print_unpacked_rgba_doubl(format_desc, "        ", test->unpacked, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+test_format_pack_rgba_float(const struct util_format_description *format_desc,
+                            const struct util_format_test_case *test)
+{
+   float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
+   uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
+   unsigned i, j, k;
+   boolean success;
+
+   if (test->format == PIPE_FORMAT_DXT1_RGBA) {
+      /*
+       * Skip S3TC as packed representation is not canonical.
+       *
+       * TODO: Do a round trip conversion.
+       */
+      return TRUE;
+   }
+
+   memset(packed, 0, sizeof packed);
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         for (k = 0; k < 4; ++k) {
+            unpacked[i][j][k] = (float) test->unpacked[i][j][k];
+         }
+      }
+   }
+
+   format_desc->pack_rgba_float(packed, 0,
+                           &unpacked[0][0][0], sizeof unpacked[0],
+                           format_desc->block.width, format_desc->block.height);
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.bits/8; ++i)
+      if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
+         success = FALSE;
+
+   if (!success) {
+      print_packed(format_desc, "FAILED: ", packed, " obtained\n");
+      print_packed(format_desc, "        ", test->packed, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+convert_float_to_8unorm(uint8_t *dst, const double *src)
+{
+   unsigned i;
+   boolean accurate = TRUE;
+
+   for (i = 0; i < UTIL_FORMAT_MAX_UNPACKED_HEIGHT*UTIL_FORMAT_MAX_UNPACKED_WIDTH*4; ++i) {
+      if (src[i] < 0.0) {
+         accurate = FALSE;
+         dst[i] = 0;
+      }
+      else if (src[i] > 1.0) {
+         accurate = FALSE;
+         dst[i] = 255;
+      }
+      else {
+         dst[i] = src[i] * 255.0;
+      }
+   }
+
+   return accurate;
+}
+
+
+static boolean
+test_format_unpack_rgba_8unorm(const struct util_format_description *format_desc,
+                               const struct util_format_test_case *test)
+{
+   uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
+   uint8_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
+   unsigned i, j, k;
+   boolean success;
+
+   format_desc->unpack_rgba_8unorm(&unpacked[0][0][0], sizeof unpacked[0],
+                              test->packed, 0,
+                              format_desc->block.width, format_desc->block.height);
+
+   convert_float_to_8unorm(&expected[0][0][0], &test->unpacked[0][0][0]);
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         for (k = 0; k < 4; ++k) {
+            if (expected[i][j][k] != unpacked[i][j][k]) {
+               success = FALSE;
+            }
+         }
+      }
+   }
+
+   if (!success) {
+      print_unpacked_rgba_8unorm(format_desc, "FAILED: ", unpacked, " obtained\n");
+      print_unpacked_rgba_8unorm(format_desc, "        ", expected, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+test_format_pack_rgba_8unorm(const struct util_format_description *format_desc,
+                             const struct util_format_test_case *test)
+{
+   uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
+   uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
+   unsigned i;
+   boolean success;
+
+   if (test->format == PIPE_FORMAT_DXT1_RGBA) {
+      /*
+       * Skip S3TC as packed representation is not canonical.
+       *
+       * TODO: Do a round trip conversion.
+       */
+      return TRUE;
+   }
+
+   if (!convert_float_to_8unorm(&unpacked[0][0][0], &test->unpacked[0][0][0])) {
+      /*
+       * Skip test cases which cannot be represented by four unorm bytes.
+       */
+      return TRUE;
+   }
+
+   memset(packed, 0, sizeof packed);
+
+   format_desc->pack_rgba_8unorm(packed, 0,
+                            &unpacked[0][0][0], sizeof unpacked[0],
+                            format_desc->block.width, format_desc->block.height);
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.bits/8; ++i)
+      if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
+         success = FALSE;
+
+   if (!success) {
+      print_packed(format_desc, "FAILED: ", packed, " obtained\n");
+      print_packed(format_desc, "        ", test->packed, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+test_format_unpack_z_float(const struct util_format_description *format_desc,
+                              const struct util_format_test_case *test)
+{
+   float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
+   unsigned i, j;
+   boolean success;
+
+   format_desc->unpack_z_float(&unpacked[0][0], sizeof unpacked[0],
+                               test->packed, 0,
+                               format_desc->block.width, format_desc->block.height);
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         if (!compare_float(test->unpacked[i][j][0], unpacked[i][j])) {
+            success = FALSE;
+         }
+      }
+   }
+
+   if (!success) {
+      print_unpacked_z_float(format_desc, "FAILED: ", unpacked, " obtained\n");
+      print_unpacked_rgba_doubl(format_desc, "        ", test->unpacked, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+test_format_pack_z_float(const struct util_format_description *format_desc,
+                            const struct util_format_test_case *test)
+{
+   float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH];
+   uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
+   unsigned i, j;
+   boolean success;
+
+   memset(packed, 0, sizeof packed);
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         unpacked[i][j] = (float) test->unpacked[i][j][0];
+         if (test->unpacked[i][j][1]) {
+            return TRUE;
+         }
+      }
+   }
+
+   format_desc->pack_z_float(packed, 0,
+                             &unpacked[0][0], sizeof unpacked[0],
+                             format_desc->block.width, format_desc->block.height);
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.bits/8; ++i)
+      if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
+         success = FALSE;
+
+   if (!success) {
+      print_packed(format_desc, "FAILED: ", packed, " obtained\n");
+      print_packed(format_desc, "        ", test->packed, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+test_format_unpack_z_32unorm(const struct util_format_description *format_desc,
+                               const struct util_format_test_case *test)
+{
+   uint32_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
+   uint32_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
+   unsigned i, j;
+   boolean success;
+
+   format_desc->unpack_z_32unorm(&unpacked[0][0], sizeof unpacked[0],
+                                 test->packed, 0,
+                                 format_desc->block.width, format_desc->block.height);
+
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         expected[i][j] = test->unpacked[i][j][0] * 0xffffffff;
+      }
+   }
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         if (expected[i][j] != unpacked[i][j]) {
+            success = FALSE;
+         }
+      }
+   }
+
+   if (!success) {
+      print_unpacked_z_32unorm(format_desc, "FAILED: ", unpacked, " obtained\n");
+      print_unpacked_z_32unorm(format_desc, "        ", expected, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+test_format_pack_z_32unorm(const struct util_format_description *format_desc,
+                             const struct util_format_test_case *test)
+{
+   uint32_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH];
+   uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
+   unsigned i, j;
+   boolean success;
+
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         unpacked[i][j] = test->unpacked[i][j][0] * 0xffffffff;
+         if (test->unpacked[i][j][1]) {
+            return TRUE;
+         }
+      }
+   }
+
+   memset(packed, 0, sizeof packed);
+
+   format_desc->pack_z_32unorm(packed, 0,
+                               &unpacked[0][0], sizeof unpacked[0],
+                               format_desc->block.width, format_desc->block.height);
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.bits/8; ++i)
+      if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
+         success = FALSE;
+
+   if (!success) {
+      print_packed(format_desc, "FAILED: ", packed, " obtained\n");
+      print_packed(format_desc, "        ", test->packed, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+test_format_unpack_s_8uscaled(const struct util_format_description *format_desc,
+                               const struct util_format_test_case *test)
+{
+   uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
+   uint8_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
+   unsigned i, j;
+   boolean success;
+
+   format_desc->unpack_s_8uscaled(&unpacked[0][0], sizeof unpacked[0],
+                                  test->packed, 0,
+                                  format_desc->block.width, format_desc->block.height);
+
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         expected[i][j] = test->unpacked[i][j][1];
+      }
+   }
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         if (expected[i][j] != unpacked[i][j]) {
+            success = FALSE;
+         }
+      }
+   }
+
+   if (!success) {
+      print_unpacked_s_8uscaled(format_desc, "FAILED: ", unpacked, " obtained\n");
+      print_unpacked_s_8uscaled(format_desc, "        ", expected, " expected\n");
+   }
+
+   return success;
+}
+
+
+static boolean
+test_format_pack_s_8uscaled(const struct util_format_description *format_desc,
+                             const struct util_format_test_case *test)
+{
+   uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH];
+   uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
+   unsigned i, j;
+   boolean success;
+
+   for (i = 0; i < format_desc->block.height; ++i) {
+      for (j = 0; j < format_desc->block.width; ++j) {
+         unpacked[i][j] = test->unpacked[i][j][1];
+         if (test->unpacked[i][j][0]) {
+            return TRUE;
+         }
+      }
+   }
+
+   memset(packed, 0, sizeof packed);
+
+   format_desc->pack_s_8uscaled(packed, 0,
+                                &unpacked[0][0], sizeof unpacked[0],
+                                format_desc->block.width, format_desc->block.height);
+
+   success = TRUE;
+   for (i = 0; i < format_desc->block.bits/8; ++i)
+      if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
+         success = FALSE;
+
+   if (!success) {
+      print_packed(format_desc, "FAILED: ", packed, " obtained\n");
+      print_packed(format_desc, "        ", test->packed, " expected\n");
+   }
+
+   return success;
+}
+
+
+typedef boolean
+(*test_func_t)(const struct util_format_description *format_desc,
+               const struct util_format_test_case *test);
+
+
+static boolean
+test_one_func(const struct util_format_description *format_desc,
+              test_func_t func,
+              const char *suffix)
+{
+   unsigned i;
+   bool success = TRUE;
+
+   printf("Testing util_format_%s_%s ...\n",
+          format_desc->short_name, suffix);
+
+   for (i = 0; i < util_format_nr_test_cases; ++i) {
+      const struct util_format_test_case *test = &util_format_test_cases[i];
+
+      if (test->format == format_desc->format) {
+         if (!func(format_desc, &util_format_test_cases[i])) {
+           success = FALSE;
+         }
+      }
+   }
+
+   return success;
+}
+
+
+static boolean
+test_all(void)
+{
+   enum pipe_format format;
+   bool success = TRUE;
+
+   for (format = 1; format < PIPE_FORMAT_COUNT; ++format) {
+      const struct util_format_description *format_desc;
+
+      format_desc = util_format_description(format);
+      if (!format_desc) {
+         continue;
+      }
+
+      if (format_desc->layout == UTIL_FORMAT_LAYOUT_S3TC &&
+          !util_format_s3tc_enabled) {
+         continue;
+      }
+
+#     define TEST_ONE_FUNC(name) \
+      if (format_desc->name) { \
+         if (!test_one_func(format_desc, &test_format_##name, #name)) { \
+           success = FALSE; \
+         } \
+      }
+
+      TEST_ONE_FUNC(fetch_rgba_float);
+      TEST_ONE_FUNC(pack_rgba_float);
+      TEST_ONE_FUNC(unpack_rgba_float);
+      TEST_ONE_FUNC(pack_rgba_8unorm);
+      TEST_ONE_FUNC(unpack_rgba_8unorm);
+
+      TEST_ONE_FUNC(unpack_z_32unorm);
+      TEST_ONE_FUNC(pack_z_32unorm);
+      TEST_ONE_FUNC(unpack_z_float);
+      TEST_ONE_FUNC(pack_z_float);
+      TEST_ONE_FUNC(unpack_s_8uscaled);
+      TEST_ONE_FUNC(pack_s_8uscaled);
+
+#     undef TEST_ONE_FUNC
+   }
+
+   return success;
+}
+
+
+int main(int argc, char **argv)
+{
+   boolean success;
+
+   util_format_s3tc_init();
+
+   success = test_all();
+
+   return success ? 0 : 1;
+}
diff --git a/src/gallium/tests/unit/u_half_test.c b/src/gallium/tests/unit/u_half_test.c
new file mode 100644
index 00000000000..00bda7f50a6
--- /dev/null
+++ b/src/gallium/tests/unit/u_half_test.c
@@ -0,0 +1,32 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+
+#include "util/u_math.h"
+#include "util/u_half.h"
+
+int
+main(int argc, char **argv)
+{
+   unsigned i;
+   unsigned roundtrip_fails = 0;
+   for(i = 0; i < 1 << 16; ++i)
+   {
+      uint16_t h = (uint16_t) i;
+      union fi f;
+      uint16_t rh;
+      f.ui = util_half_to_floatui(h);
+      rh = util_floatui_to_half(f.ui);
+      if(h != rh)
+      {
+	 printf("Roundtrip failed: %x -> %x = %f -> %x\n", h, f.ui, f.f, rh);
+	 ++roundtrip_fails;
+      }
+   }
+
+   if(roundtrip_fails)
+      printf("Failure! %u/65536 half floats failed a conversion to float and back.\n", roundtrip_fails);
+   else
+      printf("Success!\n");
+   return 0;
+}
diff --git a/src/gallium/winsys/g3dvl/Makefile b/src/gallium/winsys/g3dvl/Makefile
deleted file mode 100644
index 424ddea87ad..00000000000
--- a/src/gallium/winsys/g3dvl/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-TOP = ../../../..
-include $(TOP)/configs/current
-
-SUBDIRS = $(GALLIUM_WINSYS_DIRS)
-
-default install clean:
-	@for dir in $(SUBDIRS) ; do \
-		if [ -d $$dir ] ; then \
-			(cd $$dir && $(MAKE) $@) || exit 1; \
-		fi \
-	done
diff --git a/src/gallium/winsys/g3dvl/nouveau/Makefile b/src/gallium/winsys/g3dvl/nouveau/Makefile
deleted file mode 100644
index f07a7926d63..00000000000
--- a/src/gallium/winsys/g3dvl/nouveau/Makefile
+++ /dev/null
@@ -1,43 +0,0 @@
-TARGET		= libnouveau_dri.so
-GALLIUMDIR	= ../../..
-DRMDIR		?= /usr
-DRIDIR		= ../../../../driclient
-
-OBJECTS		= nouveau_screen_vl.o nouveau_context_vl.o nouveau_swapbuffers.o
-
-CFLAGS		+= -g -Wall -Werror=implicit-function-declaration -fPIC	\
-		   -I${GALLIUMDIR}/include				\
-		   -I${GALLIUMDIR}/winsys/g3dvl				\
-		   -I${GALLIUMDIR}/winsys/drm/nouveau			\
-		   -I${DRMDIR}/include					\
-		   -I${DRMDIR}/include/drm				\
-		   -I${DRMDIR}/include/nouveau				\
-		   -I${GALLIUMDIR}/drivers				\
-		   -I${GALLIUMDIR}/auxiliary				\
-		   -I${DRIDIR}/include
-
-LDFLAGS		+= -L${DRMDIR}/lib				\
-		   -L${DRIDIR}/lib				\
-		   -L${GALLIUMDIR}/winsys/drm/nouveau/common	\
-		   -L${GALLIUMDIR}/auxiliary			\
-		   -L${GALLIUMDIR}/drivers/nv30			\
-		   -L${GALLIUMDIR}/drivers/nv40			\
-		   -L${GALLIUMDIR}/drivers/nv50
-
-LIBS		+= -lnouveaudrm -ldriclient -ldrm_nouveau -ldrm -lnv30 -lnv40 -lnv50 -lgallium -lm
-
-#############################################
-
-.PHONY	= all clean libdriclient
-
-all: ${TARGET}
-
-${TARGET}: ${OBJECTS} libdriclient
-	$(CC) ${LDFLAGS} -shared -o $@ ${OBJECTS} ${LIBS}
-
-libdriclient:
-	cd ${DRIDIR}/src; ${MAKE}
-
-clean:
-	cd ${DRIDIR}/src; ${MAKE} clean
-	rm -rf ${OBJECTS} ${TARGET}
diff --git a/src/gallium/winsys/g3dvl/nouveau/nouveau_context_vl.c b/src/gallium/winsys/g3dvl/nouveau/nouveau_context_vl.c
deleted file mode 100644
index dfc4905bc03..00000000000
--- a/src/gallium/winsys/g3dvl/nouveau/nouveau_context_vl.c
+++ /dev/null
@@ -1,172 +0,0 @@
-#include "nouveau_context_vl.h"
-#include <pipe/p_defines.h>
-#include <pipe/p_context.h>
-#include <pipe/p_screen.h>
-#include <util/u_memory.h>
-#include <common/nouveau_dri.h>
-#include <common/nouveau_local.h>
-#include <common/nouveau_winsys_pipe.h>
-#include "nouveau_screen_vl.h"
-
-/*
-#ifdef DEBUG
-static const struct dri_debug_control debug_control[] = {
-	{ "bo", DEBUG_BO },
-	{ NULL, 0 }
-};
-int __nouveau_debug = 0;
-#endif
-*/
-
-int
-nouveau_context_create(dri_context_t *dri_context)
-{
-	dri_screen_t			*dri_screen;
-	struct nouveau_screen_vl	*nv_screen;
-	struct nouveau_context_vl	*nv;
-
-	assert (dri_context);
-
-	dri_screen = dri_context->dri_screen;
-	nv_screen = dri_screen->private;
-	nv = CALLOC_STRUCT(nouveau_context_vl);
-
-	if (!nv)
-		return 1;
-
-	if (nouveau_context_init(&nv_screen->base, dri_context->drm_context,
-	                        (drmLock*)&dri_screen->sarea->lock, NULL, &nv->base))
-	{
-		FREE(nv);
-		return 1;
-	}
-
-	dri_context->private = (void*)nv;
-	nv->dri_context = dri_context;
-	nv->nv_screen  = nv_screen;
-
-	/*
-	driParseConfigFiles(&nv->dri_option_cache, &nv_screen->option_cache,
-			    nv->dri_screen->myNum, "nouveau");
-#ifdef DEBUG
-	__nouveau_debug = driParseDebugString(getenv("NOUVEAU_DEBUG"),
-					      debug_control);
-#endif
-	*/
-
-	nv->base.nvc->pctx[nv->base.pctx_id]->priv = nv;
-
-	return 0;
-}
-
-void
-nouveau_context_destroy(dri_context_t *dri_context)
-{
-	struct nouveau_context_vl *nv = dri_context->private;
-
-	assert(dri_context);
-
-	nouveau_context_cleanup(&nv->base);
-
-	FREE(nv);
-}
-
-int
-nouveau_context_bind(struct nouveau_context_vl *nv, dri_drawable_t *dri_drawable)
-{
-	assert(nv);
-	assert(dri_drawable);
-
-	if (nv->dri_drawable != dri_drawable)
-	{
-		nv->dri_drawable = dri_drawable;
-		dri_drawable->private = nv;
-	}
-
-	return 0;
-}
-
-int
-nouveau_context_unbind(struct nouveau_context_vl *nv)
-{
-	assert(nv);
-
-	nv->dri_drawable = NULL;
-
-	return 0;
-}
-
-/* Show starts here */
-
-int bind_pipe_drawable(struct pipe_context *pipe, Drawable drawable)
-{
-	struct nouveau_context_vl	*nv;
-	dri_drawable_t			*dri_drawable;
-
-	assert(pipe);
-
-	nv = pipe->priv;
-
-	driCreateDrawable(nv->nv_screen->dri_screen, drawable, &dri_drawable);
-
-	nouveau_context_bind(nv, dri_drawable);
-
-	return 0;
-}
-
-int unbind_pipe_drawable(struct pipe_context *pipe)
-{
-	assert (pipe);
-
-	nouveau_context_unbind(pipe->priv);
-
-	return 0;
-}
-
-struct pipe_context* create_pipe_context(Display *display, int screen)
-{
-	dri_screen_t			*dri_screen;
-	dri_framebuffer_t		dri_framebuf;
-	dri_context_t			*dri_context;
-	struct nouveau_context_vl	*nv;
-
-	assert(display);
-
-	driCreateScreen(display, screen, &dri_screen, &dri_framebuf);
-	driCreateContext(dri_screen, XDefaultVisual(display, screen), &dri_context);
-
-	nouveau_screen_create(dri_screen, &dri_framebuf);
-	nouveau_context_create(dri_context);
-
-	nv = dri_context->private;
-
-	return nv->base.nvc->pctx[nv->base.pctx_id];
-}
-
-int destroy_pipe_context(struct pipe_context *pipe)
-{
-	struct pipe_screen		*screen;
-	struct pipe_winsys		*winsys;
-	struct nouveau_context_vl	*nv;
-	dri_screen_t			*dri_screen;
-	dri_context_t			*dri_context;
-
-	assert(pipe);
-
-	screen = pipe->screen;
-	winsys = pipe->winsys;
-	nv = pipe->priv;
-	dri_context = nv->dri_context;
-	dri_screen = dri_context->dri_screen;
-
-	pipe->destroy(pipe);
-	screen->destroy(screen);
-	FREE(winsys);
-
-	nouveau_context_destroy(dri_context);
-	nouveau_screen_destroy(dri_screen);
-	driDestroyContext(dri_context);
-	driDestroyScreen(dri_screen);
-
-	return 0;
-}
diff --git a/src/gallium/winsys/g3dvl/nouveau/nouveau_context_vl.h b/src/gallium/winsys/g3dvl/nouveau/nouveau_context_vl.h
deleted file mode 100644
index 1115c3130cb..00000000000
--- a/src/gallium/winsys/g3dvl/nouveau/nouveau_context_vl.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef __NOUVEAU_CONTEXT_VL_H__
-#define __NOUVEAU_CONTEXT_VL_H__
-
-#include <driclient.h>
-#include <nouveau/nouveau_winsys.h>
-#include <common/nouveau_context.h>
-
-/*#include "xmlconfig.h"*/
-
-struct nouveau_context_vl {
-	struct nouveau_context		base;
-	struct nouveau_screen_vl	*nv_screen;
-	dri_context_t			*dri_context;
-	dri_drawable_t			*dri_drawable;
-	unsigned int			last_stamp;
-	/*driOptionCache		dri_option_cache;*/
-	drm_context_t			drm_context;
-	drmLock				drm_lock;
-};
-
-extern int nouveau_context_create(dri_context_t *);
-extern void nouveau_context_destroy(dri_context_t *);
-extern int nouveau_context_bind(struct nouveau_context_vl *, dri_drawable_t *);
-extern int nouveau_context_unbind(struct nouveau_context_vl *);
-
-#ifdef DEBUG
-extern int __nouveau_debug;
-
-#define DEBUG_BO (1 << 0)
-
-#define DBG(flag, ...) do {                   \
-	if (__nouveau_debug & (DEBUG_##flag)) \
-		NOUVEAU_ERR(__VA_ARGS__);     \
-} while(0)
-#else
-#define DBG(flag, ...)
-#endif
-
-#endif
diff --git a/src/gallium/winsys/g3dvl/nouveau/nouveau_screen_vl.c b/src/gallium/winsys/g3dvl/nouveau/nouveau_screen_vl.c
deleted file mode 100644
index b7c74f8299b..00000000000
--- a/src/gallium/winsys/g3dvl/nouveau/nouveau_screen_vl.c
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "nouveau_screen_vl.h"
-#include <util/u_memory.h>
-#include <nouveau_drm.h>
-#include <common/nouveau_dri.h>
-#include <common/nouveau_local.h>
-
-#if NOUVEAU_DRM_HEADER_PATCHLEVEL != 12
-#error nouveau_drm.h version does not match expected version
-#endif
-
-/*
-PUBLIC const char __driConfigOptions[] =
-DRI_CONF_BEGIN
-DRI_CONF_END;
-static const GLuint __driNConfigOptions = 0;
-*/
-
-int nouveau_check_dri_drm_ddx(dri_version_t *dri, dri_version_t *drm, dri_version_t *ddx)
-{
-	static const dri_version_t ddx_expected = {0, 0, NOUVEAU_DRM_HEADER_PATCHLEVEL};
-	static const dri_version_t dri_expected = {4, 0, 0};
-	static const dri_version_t drm_expected = {0, 0, NOUVEAU_DRM_HEADER_PATCHLEVEL};
-
-	assert(dri);
-	assert(drm);
-	assert(ddx);
-
-	if (dri->major != dri_expected.major || dri->minor < dri_expected.minor)
-	{
-		NOUVEAU_ERR("Unexpected DRI version.\n");
-		return 1;
-	}
-	if (drm->major != drm_expected.major || drm->minor < drm_expected.minor)
-	{
-		NOUVEAU_ERR("Unexpected DRM version.\n");
-		return 1;
-	}
-	if (ddx->major != ddx_expected.major || ddx->minor < ddx_expected.minor)
-	{
-		NOUVEAU_ERR("Unexpected DDX version.\n");
-		return 1;
-	}
-
-	return 0;
-}
-
-int
-nouveau_screen_create(dri_screen_t *dri_screen, dri_framebuffer_t *dri_framebuf)
-{
-	struct nouveau_dri		*nv_dri = dri_framebuf->private;
-	struct nouveau_screen_vl	*nv_screen;
-
-	assert(dri_screen);
-	assert(dri_framebuf);
-
-	if (nouveau_check_dri_drm_ddx(&dri_screen->dri, &dri_screen->drm, &dri_screen->ddx))
-		return 1;
-
-	nv_screen = CALLOC_STRUCT(nouveau_screen_vl);
-
-	if (!nv_screen)
-		return 1;
-
-	if (nouveau_screen_init(nv_dri, dri_screen->fd, &nv_screen->base))
-	{
-		FREE(nv_screen);
-		return 1;
-	}
-
-	/*
-	driParseOptionInfo(&nv_screen->option_cache,
-			   __driConfigOptions, __driNConfigOptions);
-	*/
-
-	nv_screen->dri_screen = dri_screen;
-	dri_screen->private = (void*)nv_screen;
-
-	return 0;
-}
-
-void
-nouveau_screen_destroy(dri_screen_t *dri_screen)
-{
-	struct nouveau_screen_vl *nv_screen = dri_screen->private;
-
-	nouveau_screen_cleanup(&nv_screen->base);
-	FREE(nv_screen);
-}
diff --git a/src/gallium/winsys/g3dvl/nouveau/nouveau_screen_vl.h b/src/gallium/winsys/g3dvl/nouveau/nouveau_screen_vl.h
deleted file mode 100644
index 0c1ceca6dee..00000000000
--- a/src/gallium/winsys/g3dvl/nouveau/nouveau_screen_vl.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef __NOUVEAU_SCREEN_VL_H__
-#define __NOUVEAU_SCREEN_VL_H__
-
-#include <driclient.h>
-#include <common/nouveau_screen.h>
-
-/* TODO: Investigate using DRI options for interesting things */
-/*#include "xmlconfig.h"*/
-
-struct nouveau_screen_vl
-{
-	struct nouveau_screen		base;
-	dri_screen_t			*dri_screen;
-	/*driOptionCache		option_cache;*/
-};
-
-int nouveau_screen_create(dri_screen_t *dri_screen, dri_framebuffer_t *dri_framebuf);
-void nouveau_screen_destroy(dri_screen_t *dri_screen);
-
-#endif
diff --git a/src/gallium/winsys/g3dvl/nouveau/nouveau_swapbuffers.c b/src/gallium/winsys/g3dvl/nouveau/nouveau_swapbuffers.c
deleted file mode 100644
index 77e46a2054b..00000000000
--- a/src/gallium/winsys/g3dvl/nouveau/nouveau_swapbuffers.c
+++ /dev/null
@@ -1,94 +0,0 @@
-#include <driclient.h>
-#include <common/nouveau_local.h>
-#include <common/nouveau_screen.h>
-#include "nouveau_context_vl.h"
-#include "nouveau_swapbuffers.h"
-
-void
-nouveau_copy_buffer(dri_drawable_t *dri_drawable, struct pipe_surface *surf,
-		    const drm_clip_rect_t *rect)
-{
-	struct nouveau_context_vl	*nv = dri_drawable->private;
-	struct pipe_context		*pipe = nv->base.nvc->pctx[nv->base.pctx_id];
-	drm_clip_rect_t			*pbox;
-	int				nbox, i;
-
-	LOCK_HARDWARE(&nv->base);
-	if (!dri_drawable->num_cliprects) {
-		UNLOCK_HARDWARE(&nv->base);
-		return;
-	}
-	pbox = dri_drawable->cliprects;
-	nbox = dri_drawable->num_cliprects;
-
-	for (i = 0; i < nbox; i++, pbox++) {
-		int sx, sy, dx, dy, w, h;
-
-		sx = pbox->x1 - dri_drawable->x;
-		sy = pbox->y1 - dri_drawable->y;
-		dx = pbox->x1;
-		dy = pbox->y1;
-		w  = pbox->x2 - pbox->x1;
-		h  = pbox->y2 - pbox->y1;
-
-		pipe->surface_copy(pipe, nv->base.frontbuffer,
-				   dx, dy, surf, sx, sy, w, h);
-	}
-
-	FIRE_RING(nv->base.nvc->channel);
-	UNLOCK_HARDWARE(&nv->base);
-}
-
-void
-nouveau_copy_sub_buffer(dri_drawable_t *dri_drawable, struct pipe_surface *surf, int x, int y, int w, int h)
-{
-	if (surf) {
-		drm_clip_rect_t rect;
-		rect.x1 = x;
-		rect.y1 = y;
-		rect.x2 = x + w;
-		rect.y2 = y + h;
-
-		nouveau_copy_buffer(dri_drawable, surf, &rect);
-	}
-}
-
-void
-nouveau_swap_buffers(dri_drawable_t *dri_drawable, struct pipe_surface *surf)
-{
-	if (surf)
-		nouveau_copy_buffer(dri_drawable, surf, NULL);
-}
-
-void
-nouveau_flush_frontbuffer(struct pipe_winsys *pws, struct pipe_surface *surf,
-			  void *context_private)
-{
-	struct nouveau_context_vl	*nv;
-	dri_drawable_t			*dri_drawable;
-
-	assert(pws);
-	assert(surf);
-	assert(context_private);
-
-	nv = context_private;
-	dri_drawable = nv->dri_drawable;
-
-	nouveau_copy_buffer(dri_drawable, surf, NULL);
-}
-
-void
-nouveau_contended_lock(struct nouveau_context *nv)
-{
-	struct nouveau_context_vl	*nv_vl = (struct nouveau_context_vl*)nv;
-	dri_drawable_t			*dri_drawable = nv_vl->dri_drawable;
-	dri_screen_t			*dri_screen = nv_vl->dri_context->dri_screen;
-
-	/* If the window moved, may need to set a new cliprect now.
-	 *
-	 * NOTE: This releases and regains the hw lock, so all state
-	 * checking must be done *after* this call:
-	 */
-	if (dri_drawable)
-		DRI_VALIDATE_DRAWABLE_INFO(dri_screen, dri_drawable);
-}
diff --git a/src/gallium/winsys/g3dvl/nouveau/nouveau_swapbuffers.h b/src/gallium/winsys/g3dvl/nouveau/nouveau_swapbuffers.h
deleted file mode 100644
index 35e934adba8..00000000000
--- a/src/gallium/winsys/g3dvl/nouveau/nouveau_swapbuffers.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef __NOUVEAU_SWAPBUFFERS_H__
-#define __NOUVEAU_SWAPBUFFERS_H__
-
-extern void nouveau_copy_buffer(dri_drawable_t *, struct pipe_surface *,
-				const drm_clip_rect_t *);
-extern void nouveau_copy_sub_buffer(dri_drawable_t *, struct pipe_surface *,
-				    int x, int y, int w, int h);
-extern void nouveau_swap_buffers(dri_drawable_t *, struct pipe_surface *);
-
-#endif
diff --git a/src/gallium/winsys/g3dvl/vl_winsys.h b/src/gallium/winsys/g3dvl/vl_winsys.h
deleted file mode 100644
index b4fa0d67a1b..00000000000
--- a/src/gallium/winsys/g3dvl/vl_winsys.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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 vl_winsys_h
-#define vl_winsys_h
-
-#include <X11/Xlib.h>
-#include <pipe/p_defines.h>
-#include <pipe/p_format.h>
-
-struct pipe_screen;
-struct pipe_video_context;
-
-struct pipe_screen*
-vl_screen_create(Display *display, int screen);
-
-struct pipe_video_context*
-vl_video_create(Display *display, int screen,
-                struct pipe_screen *p_screen,
-                enum pipe_video_profile profile,
-                enum pipe_video_chroma_format chroma_format,
-                unsigned width, unsigned height);
-
-Drawable
-vl_video_bind_drawable(struct pipe_video_context *vpipe, Drawable drawable);
-
-#endif
diff --git a/src/gallium/winsys/g3dvl/xlib/Makefile b/src/gallium/winsys/g3dvl/xlib/Makefile
deleted file mode 100644
index 9877660a276..00000000000
--- a/src/gallium/winsys/g3dvl/xlib/Makefile
+++ /dev/null
@@ -1,68 +0,0 @@
-# This makefile produces a "stand-alone" libXvMCg3dvl.so which is
-# based on Xlib (no DRI HW acceleration)
-
-TOP = ../../../../..
-include $(TOP)/configs/current
-
-XVMC_MAJOR = 1
-XVMC_MINOR = 0
-XVMC_LIB = XvMCg3dvl
-XVMC_LIB_NAME = lib$(XVMC_LIB).so
-XVMC_LIB_DEPS = $(EXTRA_LIB_PATH) -lXvMC -lXv -lX11 -lm
-
-INCLUDES = -I$(TOP)/src/gallium/include \
-           -I$(TOP)/src/gallium/auxiliary \
-           -I$(TOP)/src/gallium/drivers \
-           -I$(TOP)/src/gallium/winsys/g3dvl
-
-DEFINES += -DGALLIUM_SOFTPIPE \
-	   -DGALLIUM_TRACE
-
-SOURCES = xsp_winsys.c
-
-# XXX: Hack, if we include libxvmctracker.a in LIBS none of the symbols are
-# pulled in by the linker because xsp_winsys.c doesn't refer to them
-OBJECTS = $(SOURCES:.c=.o) $(TOP)/src/gallium/state_trackers/xorg/xvmc/*.o
-
-LIBS = $(TOP)/src/gallium/drivers/softpipe/libsoftpipe.a \
-       $(TOP)/src/gallium/auxiliary/libgallium.a
-
-.c.o:
-	$(CC) -c $(INCLUDES) $(DEFINES) $(CFLAGS) $< -o $@
-
-.S.o:
-	$(CC) -c $(INCLUDES) $(DEFINES) $(CFLAGS) $< -o $@
-
-.PHONY: default $(TOP)/$(LIB_DIR)/gallium clean
-
-default: depend $(TOP)/$(LIB_DIR)/gallium $(TOP)/$(LIB_DIR)/gallium/$(XVMC_LIB_NAME)
-
-$(TOP)/$(LIB_DIR)/gallium:
-	@mkdir -p $(TOP)/$(LIB_DIR)/gallium
-
-# Make the libXvMCg3dvl.so library
-$(TOP)/$(LIB_DIR)/gallium/$(XVMC_LIB_NAME): $(OBJECTS) $(LIBS) Makefile
-	$(MKLIB) -o $(XVMC_LIB) -linker '$(CC)' -ldflags '$(LDFLAGS)' \
-		-major $(XVMC_MAJOR) -minor $(XVMC_MINOR) $(MKLIB_OPTIONS) \
-		-install $(TOP)/$(LIB_DIR)/gallium -id $(INSTALL_LIB_DIR)/lib$(XVMC_LIB).1.dylib \
-		$(XVMC_LIB_DEPS) $(OBJECTS) $(LIBS)
-
-depend: $(SOURCES) Makefile
-	$(RM) depend
-	touch depend
-	$(MKDEP) $(MKDEP_OPTIONS) $(DEFINES) $(INCLUDES) $(SOURCES)
-
-#install: default
-#	$(INSTALL) -d $(INSTALL_DIR)/include/GL
-#	$(INSTALL) -d $(INSTALL_DIR)/$(LIB_DIR)
-#	$(INSTALL) -m 644 $(TOP)/include/GL/*.h $(INSTALL_DIR)/include/GL
-#	@if [ -e $(TOP)/$(LIB_DIR)/$(GL_LIB_NAME) ]; then \
-#		$(INSTALL) $(TOP)/$(LIB_DIR)/libGL* $(INSTALL_DIR)/$(LIB_DIR); \
-#	fi
-
-clean: Makefile
-	$(RM) $(TOP)/$(LIB_DIR)/gallium/$(XVMC_LIB_NAME)
-	$(RM) *.o *~
-	$(RM) depend depend.bak
-
--include depend
diff --git a/src/gallium/winsys/g3dvl/xlib/xsp_winsys.c b/src/gallium/winsys/g3dvl/xlib/xsp_winsys.c
deleted file mode 100644
index 048af62ed30..00000000000
--- a/src/gallium/winsys/g3dvl/xlib/xsp_winsys.c
+++ /dev/null
@@ -1,330 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2009 Younes Manton.
- * 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.
- * 
- **************************************************************************/
-
-#include <vl_winsys.h>
-#include <X11/Xutil.h>
-#include <util/u_simple_screen.h>
-#include <pipe/p_state.h>
-#include <util/u_inlines.h>
-#include <util/u_format.h>
-#include <util/u_memory.h>
-#include <util/u_math.h>
-#include <softpipe/sp_winsys.h>
-#include <softpipe/sp_video_context.h>
-#include <softpipe/sp_texture.h>
-
-/* pipe_winsys implementation */
-
-struct xsp_pipe_winsys
-{
-   struct pipe_winsys base;
-   Display *display;
-   int screen;
-   XImage *fbimage;
-};
-
-struct xsp_context
-{
-   Drawable drawable;
-
-   void (*pipe_destroy)(struct pipe_video_context *vpipe);
-};
-
-struct xsp_buffer
-{
-   struct pipe_buffer base;
-   boolean is_user_buffer;
-   void *data;
-   void *mapped_data;
-};
-
-static struct pipe_buffer* xsp_buffer_create(struct pipe_winsys *pws, unsigned alignment, unsigned usage, unsigned size)
-{
-   struct xsp_buffer *buffer;
-
-   assert(pws);
-
-   buffer = calloc(1, sizeof(struct xsp_buffer));
-   pipe_reference_init(&buffer->base.reference, 1);
-   buffer->base.alignment = alignment;
-   buffer->base.usage = usage;
-   buffer->base.size = size;
-   buffer->data = align_malloc(size, alignment);
-
-   return (struct pipe_buffer*)buffer;
-}
-
-static struct pipe_buffer* xsp_user_buffer_create(struct pipe_winsys *pws, void *data, unsigned size)
-{
-   struct xsp_buffer *buffer;
-
-   assert(pws);
-
-   buffer = calloc(1, sizeof(struct xsp_buffer));
-   pipe_reference_init(&buffer->base.reference, 1);
-   buffer->base.size = size;
-   buffer->is_user_buffer = TRUE;
-   buffer->data = data;
-
-   return (struct pipe_buffer*)buffer;
-}
-
-static void* xsp_buffer_map(struct pipe_winsys *pws, struct pipe_buffer *buffer, unsigned flags)
-{
-   struct xsp_buffer *xsp_buf = (struct xsp_buffer*)buffer;
-
-   assert(pws);
-   assert(buffer);
-
-   xsp_buf->mapped_data = xsp_buf->data;
-
-   return xsp_buf->mapped_data;
-}
-
-static void xsp_buffer_unmap(struct pipe_winsys *pws, struct pipe_buffer *buffer)
-{
-   struct xsp_buffer *xsp_buf = (struct xsp_buffer*)buffer;
-
-   assert(pws);
-   assert(buffer);
-
-   xsp_buf->mapped_data = NULL;
-}
-
-static void xsp_buffer_destroy(struct pipe_buffer *buffer)
-{
-   struct xsp_buffer *xsp_buf = (struct xsp_buffer*)buffer;
-
-   assert(buffer);
-
-   if (!xsp_buf->is_user_buffer)
-      align_free(xsp_buf->data);
-
-   free(xsp_buf);
-}
-
-static struct pipe_buffer* xsp_surface_buffer_create
-(
-   struct pipe_winsys *pws,
-   unsigned width,
-   unsigned height,
-   enum pipe_format format,
-   unsigned usage,
-   unsigned tex_usage,
-   unsigned *stride
-)
-{
-   const unsigned int ALIGNMENT = 1;
-   unsigned nblocksy;
-
-   nblocksy = util_format_get_nblocksy(format, height);
-   *stride = align(util_format_get_stride(format, width), ALIGNMENT);
-
-   return pws->buffer_create(pws, ALIGNMENT, usage,
-                             *stride * nblocksy);
-}
-
-static void xsp_fence_reference(struct pipe_winsys *pws, struct pipe_fence_handle **ptr, struct pipe_fence_handle *fence)
-{
-   assert(pws);
-   assert(ptr);
-   assert(fence);
-}
-
-static int xsp_fence_signalled(struct pipe_winsys *pws, struct pipe_fence_handle *fence, unsigned flag)
-{
-   assert(pws);
-   assert(fence);
-
-   return 0;
-}
-
-static int xsp_fence_finish(struct pipe_winsys *pws, struct pipe_fence_handle *fence, unsigned flag)
-{
-   assert(pws);
-   assert(fence);
-
-   return 0;
-}
-
-static void xsp_flush_frontbuffer(struct pipe_winsys *pws, struct pipe_surface *surface, void *context_private)
-{
-   struct xsp_pipe_winsys *xsp_winsys;
-   struct xsp_context *xsp_context;
-
-   assert(pws);
-   assert(surface);
-   assert(context_private);
-
-   xsp_winsys = (struct xsp_pipe_winsys*)pws;
-   xsp_context = (struct xsp_context*)context_private;
-   xsp_winsys->fbimage->width = surface->width;
-   xsp_winsys->fbimage->height = surface->height;
-   xsp_winsys->fbimage->bytes_per_line = surface->width * (xsp_winsys->fbimage->bits_per_pixel >> 3);
-   xsp_winsys->fbimage->data = (char*)((struct xsp_buffer *)softpipe_texture(surface->texture)->buffer)->data + surface->offset;
-
-   XPutImage
-   (
-      xsp_winsys->display, xsp_context->drawable,
-      XDefaultGC(xsp_winsys->display, xsp_winsys->screen),
-      xsp_winsys->fbimage, 0, 0, 0, 0,
-      surface->width, surface->height
-   );
-   XFlush(xsp_winsys->display);
-}
-
-static const char* xsp_get_name(struct pipe_winsys *pws)
-{
-   assert(pws);
-   return "X11 SoftPipe";
-}
-
-static void xsp_destroy(struct pipe_winsys *pws)
-{
-   struct xsp_pipe_winsys *xsp_winsys = (struct xsp_pipe_winsys*)pws;
-
-   assert(pws);
-
-   /* XDestroyImage() wants to free the data as well */
-   xsp_winsys->fbimage->data = NULL;
-
-   XDestroyImage(xsp_winsys->fbimage);
-   FREE(xsp_winsys);
-}
-
-/* Called through pipe_video_context::destroy() */
-static void xsp_pipe_destroy(struct pipe_video_context *vpipe)
-{
-   struct xsp_context *xsp_context;
-
-   assert(vpipe);
-
-   xsp_context = vpipe->priv;
-
-   /* Call the original destroy */
-   xsp_context->pipe_destroy(vpipe);
-
-   FREE(xsp_context);
-}
-
-/* Show starts here */
-
-Drawable
-vl_video_bind_drawable(struct pipe_video_context *vpipe, Drawable drawable)
-{
-   struct xsp_context *xsp_context;
-   Drawable old_drawable;
-
-   assert(vpipe);
-
-   xsp_context = vpipe->priv;
-   old_drawable = xsp_context->drawable;
-   xsp_context->drawable = drawable;
-
-   return old_drawable;
-}
-
-struct pipe_screen*
-vl_screen_create(Display *display, int screen)
-{
-   struct xsp_pipe_winsys *xsp_winsys;
-
-   assert(display);
-
-   xsp_winsys = CALLOC_STRUCT(xsp_pipe_winsys);
-   if (!xsp_winsys)
-      return NULL;
-
-   xsp_winsys->base.buffer_create = xsp_buffer_create;
-   xsp_winsys->base.user_buffer_create = xsp_user_buffer_create;
-   xsp_winsys->base.buffer_map = xsp_buffer_map;
-   xsp_winsys->base.buffer_unmap = xsp_buffer_unmap;
-   xsp_winsys->base.buffer_destroy = xsp_buffer_destroy;
-   xsp_winsys->base.surface_buffer_create = xsp_surface_buffer_create;
-   xsp_winsys->base.fence_reference = xsp_fence_reference;
-   xsp_winsys->base.fence_signalled = xsp_fence_signalled;
-   xsp_winsys->base.fence_finish = xsp_fence_finish;
-   xsp_winsys->base.flush_frontbuffer = xsp_flush_frontbuffer;
-   xsp_winsys->base.get_name = xsp_get_name;
-   xsp_winsys->base.destroy = xsp_destroy;
-   xsp_winsys->display = display;
-   xsp_winsys->screen = screen;
-   xsp_winsys->fbimage = XCreateImage
-   (
-      display,
-      XDefaultVisual(display, screen),
-      XDefaultDepth(display, screen),
-      ZPixmap,
-      0,
-      NULL,
-      0, /* Don't know the width and height until flush_frontbuffer */
-      0,
-      32,
-      0
-   );
-
-   if (!xsp_winsys->fbimage) {
-      FREE(xsp_winsys);
-      return NULL;
-   }
-
-   XInitImage(xsp_winsys->fbimage);
-
-   return softpipe_create_screen(&xsp_winsys->base);
-}
-
-struct pipe_video_context*
-vl_video_create(Display *display, int screen,
-                struct pipe_screen *p_screen,
-                enum pipe_video_profile profile,
-                enum pipe_video_chroma_format chroma_format,
-                unsigned width, unsigned height)
-{
-   struct pipe_video_context *vpipe;
-   struct xsp_context *xsp_context;
-
-   assert(p_screen);
-   assert(width && height);
-
-   vpipe = sp_video_create(p_screen, profile, chroma_format, width, height);
-   if (!vpipe)
-      return NULL;
-
-   xsp_context = CALLOC_STRUCT(xsp_context);
-   if (!xsp_context) {
-      vpipe->destroy(vpipe);
-      return NULL;
-   }
-
-   /* Override this so we can free our xsp_context when the pipe is freed */
-   xsp_context->pipe_destroy = vpipe->destroy;
-   vpipe->destroy = xsp_pipe_destroy;
-
-   vpipe->priv = xsp_context;
-
-   return vpipe;
-}
diff --git a/src/gallium/winsys/i915/drm/SConscript b/src/gallium/winsys/i915/drm/SConscript
index ba29ac72fe7..96ca707e35f 100644
--- a/src/gallium/winsys/i915/drm/SConscript
+++ b/src/gallium/winsys/i915/drm/SConscript
@@ -2,6 +2,8 @@ Import('*')
 
 env = env.Clone()
 
+env.ParseConfig('pkg-config --cflags libdrm')
+
 i915drm_sources = [
     'i915_drm_api.c',
     'i915_drm_batchbuffer.c',
diff --git a/src/gallium/winsys/nouveau/drm/nouveau_drm_api.c b/src/gallium/winsys/nouveau/drm/nouveau_drm_api.c
index 716d4bacd3b..6fd6009d3a5 100644
--- a/src/gallium/winsys/nouveau/drm/nouveau_drm_api.c
+++ b/src/gallium/winsys/nouveau/drm/nouveau_drm_api.c
@@ -19,12 +19,16 @@ dri_surface_from_handle(struct drm_api *api, struct pipe_screen *pscreen,
                         unsigned width, unsigned height, unsigned pitch)
 {
 	struct pipe_surface *ps = NULL;
-	struct pipe_texture *pt = NULL;
-	struct pipe_texture tmpl;
+	struct pipe_resource *pt = NULL;
+	struct pipe_resource tmpl;
 	struct winsys_handle whandle;
+	unsigned bind = (PIPE_BIND_SCANOUT |
+			 PIPE_BIND_RENDER_TARGET |
+			 PIPE_BIND_BLIT_DESTINATION |
+			 PIPE_BIND_BLIT_SOURCE);
 
 	memset(&tmpl, 0, sizeof(tmpl));
-	tmpl.tex_usage = PIPE_TEXTURE_USAGE_SCANOUT;
+	tmpl.bind = bind;
 	tmpl.target = PIPE_TEXTURE_2D;
 	tmpl.last_level = 0;
 	tmpl.depth0 = 1;
@@ -36,16 +40,14 @@ dri_surface_from_handle(struct drm_api *api, struct pipe_screen *pscreen,
 	whandle.stride = pitch;
 	whandle.handle = handle;
 
-	pt = pscreen->texture_from_handle(pscreen, &tmpl, &whandle);
+	pt = pscreen->resource_from_handle(pscreen, &tmpl, &whandle);
 	if (!pt)
 		return NULL;
 
-	ps = pscreen->get_tex_surface(pscreen, pt, 0, 0, 0,
-				      PIPE_BUFFER_USAGE_GPU_READ |
-				      PIPE_BUFFER_USAGE_GPU_WRITE);
+	ps = pscreen->get_tex_surface(pscreen, pt, 0, 0, 0, bind);
 
 	/* we don't need the texture from this point on */
-	pipe_texture_reference(&pt, NULL);
+	pipe_resource_reference(&pt, NULL);
 	return ps;
 }
 
diff --git a/src/gallium/winsys/radeon/drm/radeon_buffer.h b/src/gallium/winsys/radeon/drm/radeon_buffer.h
index 218a3763018..8782d675df2 100644
--- a/src/gallium/winsys/radeon/drm/radeon_buffer.h
+++ b/src/gallium/winsys/radeon/drm/radeon_buffer.h
@@ -72,6 +72,10 @@ void radeon_drm_bufmgr_write_reloc(struct pb_buffer *_buf,
 struct pb_buffer *radeon_drm_bufmgr_create_buffer_from_handle(struct pb_manager *_mgr,
 							      uint32_t handle);
 
+void radeon_drm_bufmgr_get_tiling(struct pb_buffer *_buf,
+                                  enum r300_buffer_tiling *microtiled,
+                                  enum r300_buffer_tiling *macrotiled);
+
 void radeon_drm_bufmgr_set_tiling(struct pb_buffer *_buf,
                                   enum r300_buffer_tiling microtiled,
                                   enum r300_buffer_tiling macrotiled,
diff --git a/src/gallium/winsys/radeon/drm/radeon_drm.c b/src/gallium/winsys/radeon/drm/radeon_drm.c
index 3dfcc5aef07..2809b578626 100644
--- a/src/gallium/winsys/radeon/drm/radeon_drm.c
+++ b/src/gallium/winsys/radeon/drm/radeon_drm.c
@@ -100,6 +100,9 @@ static void do_ioctls(int fd, struct radeon_libdrm_winsys* winsys)
                            version->version_minor >= 1;
 #endif
 
+    /* XXX */
+    winsys->tex3d_mip_bug = TRUE;
+
     info.request = RADEON_INFO_DEVICE_ID;
     retval = drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info));
     if (retval) {
diff --git a/src/gallium/winsys/radeon/drm/radeon_drm.h b/src/gallium/winsys/radeon/drm/radeon_drm.h
index 2dc077c0521..78451b6f011 100644
--- a/src/gallium/winsys/radeon/drm/radeon_drm.h
+++ b/src/gallium/winsys/radeon/drm/radeon_drm.h
@@ -37,22 +37,6 @@ struct pipe_screen* radeon_create_screen(struct drm_api* api,
                                          int drmFB,
 					 struct drm_create_screen_arg *arg);
 
-boolean radeon_buffer_from_texture(struct drm_api* api,
-                                   struct pipe_screen* screen,
-                                   struct pipe_texture* texture,
-                                   struct pipe_buffer** buffer,
-                                   unsigned* stride);
-
-boolean radeon_handle_from_buffer(struct drm_api* api,
-                                  struct pipe_screen* screen,
-                                  struct pipe_buffer* buffer,
-                                  unsigned* handle);
-
-boolean radeon_global_handle_from_buffer(struct drm_api* api,
-                                         struct pipe_screen* screen,
-                                         struct pipe_buffer* buffer,
-                                         unsigned* handle);
-
 void radeon_destroy_drm_api(struct drm_api* api);
 
 /* Guess at whether this chipset should use r300g.
diff --git a/src/gallium/winsys/radeon/drm/radeon_drm_buffer.c b/src/gallium/winsys/radeon/drm/radeon_drm_buffer.c
index 66f61322457..c9179a3620a 100644
--- a/src/gallium/winsys/radeon/drm/radeon_drm_buffer.c
+++ b/src/gallium/winsys/radeon/drm/radeon_drm_buffer.c
@@ -72,9 +72,9 @@ radeon_drm_buffer_map(struct pb_buffer *_buf,
     struct radeon_drm_buffer *buf = radeon_drm_buffer(_buf);
     int write = 0;
 
-    if (flags & PIPE_BUFFER_USAGE_DONTBLOCK) {
-	if ((_buf->base.usage & PIPE_BUFFER_USAGE_VERTEX) ||
-	    (_buf->base.usage & PIPE_BUFFER_USAGE_INDEX))
+    if (flags & PIPE_TRANSFER_DONTBLOCK) {
+	if ((_buf->base.usage & PIPE_BIND_VERTEX_BUFFER) ||
+	    (_buf->base.usage & PIPE_BIND_INDEX_BUFFER))
 	    if (radeon_bo_is_referenced_by_cs(buf->bo, buf->mgr->rws->cs))
 		return NULL;
     }
@@ -82,7 +82,7 @@ radeon_drm_buffer_map(struct pb_buffer *_buf,
     if (buf->bo->ptr != NULL)
 	return buf->bo->ptr;
 
-    if (flags & PIPE_BUFFER_USAGE_DONTBLOCK) {
+    if (flags & PIPE_TRANSFER_DONTBLOCK) {
         uint32_t domain;
         if (radeon_bo_is_busy(buf->bo, &domain))
             return NULL;
@@ -92,7 +92,7 @@ radeon_drm_buffer_map(struct pb_buffer *_buf,
         buf->mgr->rws->flush_cb(buf->mgr->rws->flush_data);
     }
 
-    if (flags & PIPE_BUFFER_USAGE_CPU_WRITE) {
+    if (flags & PIPE_TRANSFER_WRITE) {
         write = 1;
     }
 
@@ -148,16 +148,20 @@ static uint32_t radeon_domain_from_usage(unsigned usage)
 {
     uint32_t domain = 0;
 
-    if (usage & PIPE_BUFFER_USAGE_GPU_WRITE) {
+    if (usage & PIPE_BIND_RENDER_TARGET) {
         domain |= RADEON_GEM_DOMAIN_VRAM;
     }
-    if (usage & PIPE_BUFFER_USAGE_PIXEL) {
+    if (usage & PIPE_BIND_DEPTH_STENCIL) {
         domain |= RADEON_GEM_DOMAIN_VRAM;
     }
-    if (usage & PIPE_BUFFER_USAGE_VERTEX) {
+    if (usage & PIPE_BIND_SAMPLER_VIEW) {
+        domain |= RADEON_GEM_DOMAIN_VRAM;
+    }
+    /* also need BIND_BLIT_SOURCE/DESTINATION ? */
+    if (usage & PIPE_BIND_VERTEX_BUFFER) {
         domain |= RADEON_GEM_DOMAIN_GTT;
     }
-    if (usage & PIPE_BUFFER_USAGE_INDEX) {
+    if (usage & PIPE_BIND_INDEX_BUFFER) {
         domain |= RADEON_GEM_DOMAIN_GTT;
     }
 
@@ -187,7 +191,7 @@ struct pb_buffer *radeon_drm_bufmgr_create_buffer_from_handle(struct pb_manager
 
     pipe_reference_init(&buf->base.base.reference, 1);
     buf->base.base.alignment = 0;
-    buf->base.base.usage = PIPE_BUFFER_USAGE_PIXEL;
+    buf->base.base.usage = PIPE_BIND_SAMPLER_VIEW;
     buf->base.base.size = 0;
     buf->base.vtbl = &radeon_drm_buffer_vtbl;
     buf->mgr = mgr;
@@ -304,7 +308,24 @@ boolean radeon_drm_bufmgr_get_handle(struct pb_buffer *_buf,
     }
     return TRUE;
 }
-					   
+
+void radeon_drm_bufmgr_get_tiling(struct pb_buffer *_buf,
+                                  enum r300_buffer_tiling *microtiled,
+                                  enum r300_buffer_tiling *macrotiled)
+{
+    struct radeon_drm_buffer *buf = get_drm_buffer(_buf);
+    uint32_t flags = 0, pitch;
+
+    radeon_bo_get_tiling(buf->bo, &flags, &pitch);
+
+    *microtiled = R300_BUFFER_LINEAR;
+    *macrotiled = R300_BUFFER_LINEAR;
+    if (flags & RADEON_BO_FLAGS_MICRO_TILE)
+	*microtiled = R300_BUFFER_TILED;
+
+    if (flags & RADEON_BO_FLAGS_MACRO_TILE)
+	*macrotiled = R300_BUFFER_TILED;
+}
 
 void radeon_drm_bufmgr_set_tiling(struct pb_buffer *_buf,
                                   enum r300_buffer_tiling microtiled,
diff --git a/src/gallium/winsys/radeon/drm/radeon_r300.c b/src/gallium/winsys/radeon/drm/radeon_r300.c
index 38fcf889c8b..d1e65f87c36 100644
--- a/src/gallium/winsys/radeon/drm/radeon_r300.c
+++ b/src/gallium/winsys/radeon/drm/radeon_r300.c
@@ -42,10 +42,10 @@ radeon_r300_winsys_buffer_create(struct r300_winsys_screen *rws,
     desc.alignment = alignment;
     desc.usage = usage;
 
-    if (usage & PIPE_BUFFER_USAGE_CONSTANT)
+    if (usage & PIPE_BIND_CONSTANT_BUFFER)
         provider = ws->mman;
-    else if ((usage & PIPE_BUFFER_USAGE_VERTEX) ||
-	     (usage & PIPE_BUFFER_USAGE_INDEX))
+    else if ((usage & PIPE_BIND_VERTEX_BUFFER) ||
+	     (usage & PIPE_BIND_INDEX_BUFFER))
 	provider = ws->cman;
     else
         provider = ws->kman;
@@ -72,6 +72,15 @@ static void radeon_r300_winsys_buffer_set_tiling(struct r300_winsys_screen *rws,
     radeon_drm_bufmgr_set_tiling(_buf, microtiled, macrotiled, pitch);
 }
 
+static void radeon_r300_winsys_buffer_get_tiling(struct r300_winsys_screen *rws,
+						  struct r300_winsys_buffer *buf,
+						  enum r300_buffer_tiling *microtiled,
+						  enum r300_buffer_tiling *macrotiled)
+{
+    struct pb_buffer *_buf = radeon_pb_buffer(buf);
+    radeon_drm_bufmgr_get_tiling(_buf, microtiled, macrotiled);
+}
+
 static void *radeon_r300_winsys_buffer_map(struct r300_winsys_screen *ws,
 					   struct r300_winsys_buffer *buf,
 					   unsigned usage)
@@ -255,6 +264,8 @@ static uint32_t radeon_get_value(struct r300_winsys_screen *rws,
 	return ws->z_pipes;
     case R300_VID_SQUARE_TILING_SUPPORT:
         return ws->squaretiling;
+    case R300_VID_TEX3D_MIP_BUG:
+        return ws->tex3d_mip_bug;
     }
     return 0;
 }
@@ -320,6 +331,7 @@ radeon_setup_winsys(int fd, struct radeon_libdrm_winsys* ws)
     ws->base.buffer_create = radeon_r300_winsys_buffer_create;
     ws->base.buffer_destroy = radeon_r300_winsys_buffer_destroy;
     ws->base.buffer_set_tiling = radeon_r300_winsys_buffer_set_tiling;
+    ws->base.buffer_get_tiling = radeon_r300_winsys_buffer_get_tiling;
     ws->base.buffer_map = radeon_r300_winsys_buffer_map;
     ws->base.buffer_unmap = radeon_r300_winsys_buffer_unmap;
     ws->base.buffer_reference = radeon_r300_winsys_buffer_reference;
diff --git a/src/gallium/winsys/radeon/drm/radeon_winsys.h b/src/gallium/winsys/radeon/drm/radeon_winsys.h
index 4260dbaad72..396f258c312 100644
--- a/src/gallium/winsys/radeon/drm/radeon_winsys.h
+++ b/src/gallium/winsys/radeon/drm/radeon_winsys.h
@@ -60,6 +60,9 @@ struct radeon_libdrm_winsys {
     /* Square tiling support. */
     boolean squaretiling;
 
+    /* Square tiling support. */
+    boolean tex3d_mip_bug;
+
     /* DRM FD */
     int fd;
 
diff --git a/src/gallium/winsys/sw/dri/dri_sw_winsys.c b/src/gallium/winsys/sw/dri/dri_sw_winsys.c
index 870c6afc124..1bca827bd65 100644
--- a/src/gallium/winsys/sw/dri/dri_sw_winsys.c
+++ b/src/gallium/winsys/sw/dri/dri_sw_winsys.c
@@ -148,7 +148,7 @@ dri_sw_displaytarget_unmap(struct sw_winsys *ws,
 
 static struct sw_displaytarget *
 dri_sw_displaytarget_from_handle(struct sw_winsys *winsys,
-                                 const struct pipe_texture *templ,
+                                 const struct pipe_resource *templ,
                                  struct winsys_handle *whandle,
                                  unsigned *stride)
 {
diff --git a/src/gallium/winsys/sw/drm/sw_drm_api.c b/src/gallium/winsys/sw/drm/sw_drm_api.c
index eb81d26a593..2ccde610e60 100644
--- a/src/gallium/winsys/sw/drm/sw_drm_api.c
+++ b/src/gallium/winsys/sw/drm/sw_drm_api.c
@@ -65,8 +65,12 @@ sw_drm_create_screen(struct drm_api *_api, int drmFD,
    struct pipe_screen *screen;
 
    screen = api->create_screen(api, drmFD, arg);
+   if (!screen)
+      return NULL;
 
    sww = wrapper_sw_winsys_warp_pipe_screen(screen);
+   if (!sww)
+      return NULL;
 
    return softpipe_create_screen(sww);
 }
@@ -86,7 +90,10 @@ sw_drm_api_create(struct drm_api *api)
 {
    struct sw_drm_api *swapi = CALLOC_STRUCT(sw_drm_api);
 
-   swapi->base.name = "sw";
+   if (!swapi)
+      return api;
+
+   swapi->base.name = api->name;
    swapi->base.driver_name = api->driver_name;
    swapi->base.create_screen = sw_drm_create_screen;
    swapi->base.destroy = sw_drm_destroy;
diff --git a/src/gallium/winsys/sw/gdi/gdi_sw_winsys.c b/src/gallium/winsys/sw/gdi/gdi_sw_winsys.c
index 4dba4b577b8..2e12f6e6cc8 100644
--- a/src/gallium/winsys/sw/gdi/gdi_sw_winsys.c
+++ b/src/gallium/winsys/sw/gdi/gdi_sw_winsys.c
@@ -172,7 +172,7 @@ no_gdt:
 
 static struct sw_displaytarget *
 gdi_sw_displaytarget_from_handle(struct sw_winsys *winsys,
-                                 const struct pipe_texture *templet,
+                                 const struct pipe_resource *templet,
                                  struct winsys_handle *whandle,
                                  unsigned *stride)
 {
diff --git a/src/gallium/winsys/sw/null/null_sw_winsys.c b/src/gallium/winsys/sw/null/null_sw_winsys.c
index 5027e57b303..157efa9973e 100644
--- a/src/gallium/winsys/sw/null/null_sw_winsys.c
+++ b/src/gallium/winsys/sw/null/null_sw_winsys.c
@@ -91,7 +91,7 @@ null_sw_displaytarget_create(struct sw_winsys *winsys,
 
 static struct sw_displaytarget *
 null_sw_displaytarget_from_handle(struct sw_winsys *winsys,
-                                  const struct pipe_texture *templet,
+                                  const struct pipe_resource *templet,
                                   struct winsys_handle *whandle,
                                   unsigned *stride)
 {
diff --git a/src/gallium/winsys/sw/wrapper/wrapper_sw_winsys.c b/src/gallium/winsys/sw/wrapper/wrapper_sw_winsys.c
index 459b1c1e2a3..d4d4270eb86 100644
--- a/src/gallium/winsys/sw/wrapper/wrapper_sw_winsys.c
+++ b/src/gallium/winsys/sw/wrapper/wrapper_sw_winsys.c
@@ -57,7 +57,7 @@ struct wrapper_sw_winsys
 struct wrapper_sw_displaytarget
 {
    struct wrapper_sw_winsys *winsys;
-   struct pipe_texture *tex;
+   struct pipe_resource *tex;
    struct pipe_transfer *transfer;
 
    unsigned width;
@@ -89,26 +89,26 @@ static boolean
 wsw_dt_get_stride(struct wrapper_sw_displaytarget *wdt, unsigned *stride)
 {
    struct pipe_context *pipe = wdt->winsys->pipe;
-   struct pipe_texture *tex = wdt->tex;
+   struct pipe_resource *tex = wdt->tex;
    struct pipe_transfer *tr;
 
-   tr = pipe->get_tex_transfer(pipe, tex, 0, 0, 0,
-                               PIPE_TRANSFER_READ_WRITE,
-                               0, 0, wdt->width, wdt->height);
+   tr = pipe_get_transfer(pipe, tex, 0, 0, 0,
+			  PIPE_TRANSFER_READ_WRITE,
+			  0, 0, wdt->width, wdt->height);
    if (!tr)
       return FALSE;
 
    *stride = tr->stride;
    wdt->stride = tr->stride;
 
-   pipe->tex_transfer_destroy(pipe, tr);
+   pipe->transfer_destroy(pipe, tr);
 
    return TRUE;
 }
 
 static struct sw_displaytarget *
 wsw_dt_wrap_texture(struct wrapper_sw_winsys *wsw,
-                    struct pipe_texture *tex, unsigned *stride)
+                    struct pipe_resource *tex, unsigned *stride)
 {
    struct wrapper_sw_displaytarget *wdt = CALLOC_STRUCT(wrapper_sw_displaytarget);
    if (!wdt)
@@ -125,21 +125,21 @@ wsw_dt_wrap_texture(struct wrapper_sw_winsys *wsw,
 err_free:
    FREE(wdt);
 err_unref:
-   pipe_texture_reference(&tex, NULL);
+   pipe_resource_reference(&tex, NULL);
    return NULL;
 }
 
 static struct sw_displaytarget *
 wsw_dt_create(struct sw_winsys *ws,
-              unsigned tex_usage,
+              unsigned bind,
               enum pipe_format format,
               unsigned width, unsigned height,
               unsigned alignment,
               unsigned *stride)
 {
    struct wrapper_sw_winsys *wsw = wrapper_sw_winsys(ws);
-   struct pipe_texture templ;
-   struct pipe_texture *tex;
+   struct pipe_resource templ;
+   struct pipe_resource *tex;
 
    /*
     * XXX Why don't we just get the template.
@@ -148,11 +148,11 @@ wsw_dt_create(struct sw_winsys *ws,
    templ.width0 = width;
    templ.height0 = height;
    templ.format = format;
-   templ.tex_usage = tex_usage;
+   templ.bind = bind;
 
    /* XXX alignment: we can't do anything about this */
 
-   tex = wsw->screen->texture_create(wsw->screen, &templ);
+   tex = wsw->screen->resource_create(wsw->screen, &templ);
    if (!tex)
       return NULL;
 
@@ -161,14 +161,14 @@ wsw_dt_create(struct sw_winsys *ws,
 
 static struct sw_displaytarget *
 wsw_dt_from_handle(struct sw_winsys *ws,
-                   const struct pipe_texture *templ,
+                   const struct pipe_resource *templ,
                    struct winsys_handle *whandle,
                    unsigned *stride)
 {
    struct wrapper_sw_winsys *wsw = wrapper_sw_winsys(ws);
-   struct pipe_texture *tex;
+   struct pipe_resource *tex;
 
-   tex = wsw->screen->texture_from_handle(wsw->screen, templ, whandle);
+   tex = wsw->screen->resource_from_handle(wsw->screen, templ, whandle);
    if (!tex)
       return NULL;
 
@@ -182,7 +182,7 @@ wsw_dt_map(struct sw_winsys *ws,
 {
    struct wrapper_sw_displaytarget *wdt = wrapper_sw_displaytarget(dt);
    struct pipe_context *pipe = wdt->winsys->pipe;
-   struct pipe_texture *tex = wdt->tex;
+   struct pipe_resource *tex = wdt->tex;
    struct pipe_transfer *tr;
    void *ptr;
 
@@ -190,9 +190,9 @@ wsw_dt_map(struct sw_winsys *ws,
 
       assert(!wdt->transfer);
 
-      tr = pipe->get_tex_transfer(pipe, tex, 0, 0, 0,
-                                  PIPE_TRANSFER_READ_WRITE,
-                                  0, 0, wdt->width, wdt->height);
+      tr = pipe_get_transfer(pipe, tex, 0, 0, 0,
+			     PIPE_TRANSFER_READ_WRITE,
+			     0, 0, wdt->width, wdt->height);
       if (!tr)
          return NULL;
 
@@ -212,7 +212,7 @@ wsw_dt_map(struct sw_winsys *ws,
    return wdt->ptr;
 
 err:
-   pipe->tex_transfer_destroy(pipe, tr);
+   pipe->transfer_destroy(pipe, tr);
    return NULL;
 }
 
@@ -231,7 +231,7 @@ wsw_dt_unmap(struct sw_winsys *ws,
       return;
 
    pipe->transfer_unmap(pipe, wdt->transfer);
-   pipe->tex_transfer_destroy(pipe, wdt->transfer);
+   pipe->transfer_destroy(pipe, wdt->transfer);
    wdt->transfer = NULL;
 }
 
@@ -241,7 +241,7 @@ wsw_dt_destroy(struct sw_winsys *ws,
 {
    struct wrapper_sw_displaytarget *wdt = wrapper_sw_displaytarget(dt);
 
-   pipe_texture_reference(&wdt->tex, NULL);
+   pipe_resource_reference(&wdt->tex, NULL);
 
    FREE(wdt);
 }
@@ -262,6 +262,9 @@ wrapper_sw_winsys_warp_pipe_screen(struct pipe_screen *screen)
 {
    struct wrapper_sw_winsys *wsw = CALLOC_STRUCT(wrapper_sw_winsys);
 
+   if (!wsw)
+      goto err;
+
    wsw->base.displaytarget_create = wsw_dt_create;
    wsw->base.displaytarget_from_handle = wsw_dt_from_handle;
    wsw->base.displaytarget_map = wsw_dt_map;
@@ -272,11 +275,12 @@ wrapper_sw_winsys_warp_pipe_screen(struct pipe_screen *screen)
    wsw->screen = screen;
    wsw->pipe = screen->context_create(screen, NULL);
    if (!wsw->pipe)
-      goto err;
+      goto err_free;
 
    return &wsw->base;
 
-err:
+err_free:
    FREE(wsw);
+err:
    return NULL;
 }
diff --git a/src/gallium/winsys/sw/xlib/xlib_sw_winsys.c b/src/gallium/winsys/sw/xlib/xlib_sw_winsys.c
index ad843b7def6..ec4f919d082 100644
--- a/src/gallium/winsys/sw/xlib/xlib_sw_winsys.c
+++ b/src/gallium/winsys/sw/xlib/xlib_sw_winsys.c
@@ -49,7 +49,7 @@
 #include <X11/extensions/XShm.h>
 
 /**
- * Subclass of pipe_buffer for Xlib winsys.
+ * Display target for Xlib winsys.
  * Low-level OS/window system memory buffer
  */
 struct xm_displaytarget
@@ -412,7 +412,7 @@ no_xm_dt:
 
 static struct sw_displaytarget *
 xm_displaytarget_from_handle(struct sw_winsys *winsys,
-                             const struct pipe_texture *templet,
+                             const struct pipe_resource *templet,
                              struct winsys_handle *whandle,
                              unsigned *stride)
 {
diff --git a/src/glew/SConscript b/src/glew/SConscript
index 45375e083a5..4b5b5b8d0ff 100644
--- a/src/glew/SConscript
+++ b/src/glew/SConscript
@@ -15,6 +15,7 @@ if env['platform'] == 'windows':
         'user32', 
     ])
 else:
+    env.Tool('x11')
     env.PrependUnique(LIBS = [
         'GLU',
         'GL',
diff --git a/src/glut/glx/SConscript b/src/glut/glx/SConscript
index 9363b5ca5cc..29d2cc01494 100644
--- a/src/glut/glx/SConscript
+++ b/src/glut/glx/SConscript
@@ -78,6 +78,7 @@ if env['platform'] == 'windows':
         'glut.def',
     ]
 else:
+    env.Tool('x11')
     env.PrependUnique(LIBS = [
         'GLU',
         'GL',
diff --git a/src/glx/dri2.c b/src/glx/dri2.c
index 9ca9b3eb065..6afa4149651 100644
--- a/src/glx/dri2.c
+++ b/src/glx/dri2.c
@@ -101,8 +101,7 @@ DRI2WireToEvent(Display *dpy, XEvent *event, xEvent *wire)
       GLXBufferSwapComplete *aevent = (GLXBufferSwapComplete *)event;
       xDRI2BufferSwapComplete *awire = (xDRI2BufferSwapComplete *)wire;
       aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire);
-      aevent->type =
-	  (glx_info->codes->first_event + GLX_BufferSwapComplete) & 0x75;
+      aevent->type = glx_info->codes->first_event + GLX_BufferSwapComplete;
       aevent->send_event = (awire->type & 0x80) != 0;
       aevent->display = dpy;
       aevent->drawable = awire->drawable;
@@ -111,7 +110,7 @@ DRI2WireToEvent(Display *dpy, XEvent *event, xEvent *wire)
 	 aevent->event_type = GLX_EXCHANGE_COMPLETE_INTEL;
 	 break;
       case DRI2_BLIT_COMPLETE:
-	 aevent->event_type = GLX_BLIT_COMPLETE_INTEL;
+	 aevent->event_type = GLX_COPY_COMPLETE_INTEL;
 	 break;
       case DRI2_FLIP_COMPLETE:
 	 aevent->event_type = GLX_FLIP_COMPLETE_INTEL;
diff --git a/src/glx/dri2_glx.c b/src/glx/dri2_glx.c
index 14788b89bea..06f3d8b71c0 100644
--- a/src/glx/dri2_glx.c
+++ b/src/glx/dri2_glx.c
@@ -185,6 +185,7 @@ dri2CreateDrawable(__GLXscreenConfigs * psc,
    pdraw->base.drawable = drawable;
    pdraw->base.psc = psc;
    pdraw->bufferCount = 0;
+   pdraw->swap_interval = 0;
 
    DRI2CreateDrawable(psc->dpy, xDrawable);
 
@@ -329,7 +330,7 @@ dri2FlushFrontBuffer(__DRIdrawable *driDrawable, void *loaderPrivate)
 
    /* Old servers don't send invalidate events */
    if (!pdp->invalidateAvailable)
-       dri2InvalidateBuffers(priv->dpy, pdraw->base.xDrawable);
+       dri2InvalidateBuffers(priv->dpy, pdraw->base.drawable);
 
    dri2WaitGL(loaderPrivate);
 }
@@ -393,7 +394,7 @@ dri2SwapBuffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
 
     /* Old servers don't send invalidate events */
     if (!pdp->invalidateAvailable)
-       dri2InvalidateBuffers(dpyPriv->dpy, pdraw->xDrawable);
+       dri2InvalidateBuffers(dpyPriv->dpy, pdraw->drawable);
 
     /* Old servers can't handle swapbuffers */
     if (!pdp->swapAvailable) {
diff --git a/src/glx/glx_pbuffer.c b/src/glx/glx_pbuffer.c
index 52e067165c8..2098cc6a52d 100644
--- a/src/glx/glx_pbuffer.c
+++ b/src/glx/glx_pbuffer.c
@@ -127,64 +127,6 @@ ChangeDrawableAttribute(Display * dpy, GLXDrawable drawable,
 }
 
 
-/**
- * Destroy a pbuffer.
- *
- * This function is used to implement \c glXDestroyPbuffer and
- * \c glXDestroyGLXPbufferSGIX.
- *
- * \note
- * This function dynamically determines whether to use the SGIX_pbuffer
- * version of the protocol or the GLX 1.3 version of the protocol.
- *
- * \todo
- * This function needs to be modified to work with direct-rendering drivers.
- */
-static void
-DestroyPbuffer(Display * dpy, GLXDrawable drawable)
-{
-   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
-   CARD8 opcode;
-
-   if ((dpy == NULL) || (drawable == 0)) {
-      return;
-   }
-
-   opcode = __glXSetupForCommand(dpy);
-   if (!opcode)
-      return;
-
-   LockDisplay(dpy);
-
-   if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
-      xGLXDestroyPbufferReq *req;
-
-      GetReq(GLXDestroyPbuffer, req);
-      req->reqType = opcode;
-      req->glxCode = X_GLXDestroyPbuffer;
-      req->pbuffer = (GLXPbuffer) drawable;
-   }
-   else {
-      xGLXVendorPrivateWithReplyReq *vpreq;
-      CARD32 *data;
-
-      GetReqExtra(GLXVendorPrivateWithReply, 4, vpreq);
-      data = (CARD32 *) (vpreq + 1);
-
-      data[0] = (CARD32) drawable;
-
-      vpreq->reqType = opcode;
-      vpreq->glxCode = X_GLXVendorPrivateWithReply;
-      vpreq->vendorCode = X_GLXvop_DestroyGLXPbufferSGIX;
-   }
-
-   UnlockDisplay(dpy);
-   SyncHandle();
-
-   return;
-}
-
-
 #ifdef GLX_DIRECT_RENDERING
 static GLenum
 determineTextureTarget(const int *attribs, int numAttribs)
@@ -208,7 +150,6 @@ determineTextureTarget(const int *attribs, int numAttribs)
    return target;
 }
 
-
 static GLenum
 determineTextureFormat(const int *attribs, int numAttribs)
 {
@@ -221,6 +162,66 @@ determineTextureFormat(const int *attribs, int numAttribs)
 
    return 0;
 }
+
+static void
+CreateDRIDrawable(Display *dpy, const __GLcontextModes *fbconfig,
+		  XID drawable, XID glxdrawable,
+		  const int *attrib_list, size_t num_attribs)
+{
+   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
+   __GLXDRIdrawable *pdraw;
+   __GLXscreenConfigs *psc;
+
+   psc = &priv->screenConfigs[fbconfig->screen];
+   if (psc->driScreen == NULL)
+      return;
+
+   pdraw = psc->driScreen->createDrawable(psc, drawable,
+					  glxdrawable, fbconfig);
+   if (pdraw == NULL) {
+      fprintf(stderr, "failed to create drawable\n");
+      return;
+   }
+
+   if (__glxHashInsert(psc->drawHash, glxdrawable, pdraw)) {
+      (*pdraw->destroyDrawable) (pdraw);
+      return; /* FIXME: Check what we're supposed to do here... */
+   }
+
+   pdraw->textureTarget = determineTextureTarget(attrib_list, num_attribs);
+   pdraw->textureFormat = determineTextureFormat(attrib_list, num_attribs);
+}
+
+static void
+DestroyDRIDrawable(Display *dpy, GLXDrawable drawable, int destroy_xdrawable)
+{
+   int screen;
+   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
+   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
+   __GLXscreenConfigs *psc = &priv->screenConfigs[screen];
+
+   if (pdraw != NULL) {
+      if (destroy_xdrawable)
+         XFreePixmap(psc->dpy, pdraw->xDrawable);
+      (*pdraw->destroyDrawable) (pdraw);
+      __glxHashDelete(psc->drawHash, drawable);
+   }
+}
+
+#else
+
+static void
+CreateDRIDrawable(Display *dpy, const __GLcontextModes * fbconfig,
+		  XID drawable, XID glxdrawable,
+		  const int *attrib_list, size_t num_attribs)
+{
+}
+
+static void
+DestroyDRIDrawable(Display *dpy, GLXDrawable drawable, int destroy_xdrawable)
+{
+}
+
 #endif
 
 /**
@@ -385,34 +386,7 @@ CreateDrawable(Display * dpy, const __GLcontextModes * fbconfig,
    UnlockDisplay(dpy);
    SyncHandle();
 
-#ifdef GLX_DIRECT_RENDERING
-   do {
-      /* FIXME: Maybe delay __DRIdrawable creation until the drawable
-       * is actually bound to a context... */
-
-      __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
-      __GLXDRIdrawable *pdraw;
-      __GLXscreenConfigs *psc;
-
-      psc = &priv->screenConfigs[fbconfig->screen];
-      if (psc->driScreen == NULL)
-         break;
-      pdraw = psc->driScreen->createDrawable(psc, drawable,
-                                             req->glxwindow, fbconfig);
-      if (pdraw == NULL) {
-         fprintf(stderr, "failed to create drawable\n");
-         break;
-      }
-
-      if (__glxHashInsert(psc->drawHash, req->glxwindow, pdraw)) {
-         (*pdraw->destroyDrawable) (pdraw);
-         return None;           /* FIXME: Check what we're supposed to do here... */
-      }
-
-      pdraw->textureTarget = determineTextureTarget(attrib_list, i);
-      pdraw->textureFormat = determineTextureFormat(attrib_list, i);
-   } while (0);
-#endif
+   CreateDRIDrawable(dpy, fbconfig, drawable, req->glxwindow, attrib_list, i);
 
    return (GLXDrawable) req->glxwindow;
 }
@@ -420,9 +394,6 @@ CreateDrawable(Display * dpy, const __GLcontextModes * fbconfig,
 
 /**
  * Destroy a non-pbuffer GLX drawable.
- *
- * \todo
- * This function needs to be modified to work with direct-rendering drivers.
  */
 static void
 DestroyDrawable(Display * dpy, GLXDrawable drawable, CARD32 glxCode)
@@ -449,19 +420,7 @@ DestroyDrawable(Display * dpy, GLXDrawable drawable, CARD32 glxCode)
    UnlockDisplay(dpy);
    SyncHandle();
 
-#ifdef GLX_DIRECT_RENDERING
-   {
-      int screen;
-      __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
-      __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
-      __GLXscreenConfigs *psc = &priv->screenConfigs[screen];
-
-      if (pdraw != NULL) {
-         (*pdraw->destroyDrawable) (pdraw);
-         __glxHashDelete(psc->drawHash, drawable);
-      }
-   }
-#endif
+   DestroyDRIDrawable(dpy, drawable, GL_FALSE);
 
    return;
 }
@@ -490,6 +449,7 @@ CreatePbuffer(Display * dpy, const __GLcontextModes * fbconfig,
    CARD32 *data;
    CARD8 opcode;
    unsigned int i;
+   Pixmap pixmap;
 
    i = 0;
    if (attrib_list) {
@@ -549,9 +509,69 @@ CreatePbuffer(Display * dpy, const __GLcontextModes * fbconfig,
    UnlockDisplay(dpy);
    SyncHandle();
 
+   pixmap = XCreatePixmap(dpy, RootWindow(dpy, fbconfig->screen),
+			  width, height, fbconfig->rgbBits);
+
+   CreateDRIDrawable(dpy, fbconfig, pixmap, id, attrib_list, i);
+
    return id;
 }
 
+/**
+ * Destroy a pbuffer.
+ *
+ * This function is used to implement \c glXDestroyPbuffer and
+ * \c glXDestroyGLXPbufferSGIX.
+ *
+ * \note
+ * This function dynamically determines whether to use the SGIX_pbuffer
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ */
+static void
+DestroyPbuffer(Display * dpy, GLXDrawable drawable)
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+   CARD8 opcode;
+
+   if ((dpy == NULL) || (drawable == 0)) {
+      return;
+   }
+
+   opcode = __glXSetupForCommand(dpy);
+   if (!opcode)
+      return;
+
+   LockDisplay(dpy);
+
+   if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
+      xGLXDestroyPbufferReq *req;
+
+      GetReq(GLXDestroyPbuffer, req);
+      req->reqType = opcode;
+      req->glxCode = X_GLXDestroyPbuffer;
+      req->pbuffer = (GLXPbuffer) drawable;
+   }
+   else {
+      xGLXVendorPrivateWithReplyReq *vpreq;
+      CARD32 *data;
+
+      GetReqExtra(GLXVendorPrivateWithReply, 4, vpreq);
+      data = (CARD32 *) (vpreq + 1);
+
+      data[0] = (CARD32) drawable;
+
+      vpreq->reqType = opcode;
+      vpreq->glxCode = X_GLXVendorPrivateWithReply;
+      vpreq->vendorCode = X_GLXvop_DestroyGLXPbufferSGIX;
+   }
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   DestroyDRIDrawable(dpy, drawable, GL_TRUE);
+
+   return;
+}
 
 /**
  * Create a new pbuffer.
diff --git a/src/glx/glxcmds.c b/src/glx/glxcmds.c
index ea267f3dd8a..e256a078f19 100644
--- a/src/glx/glxcmds.c
+++ b/src/glx/glxcmds.c
@@ -1110,6 +1110,13 @@ init_fbconfig_for_chooser(__GLcontextModes * config,
     }                                           \
   } while ( 0 )
 
+/* Test that all bits from a are contained in b */
+#define MATCH_MASK(param)			\
+  do {						\
+    if ((a->param & ~b->param) != 0)		\
+      return False;				\
+  } while (0);
+
 /**
  * Determine if two GLXFBConfigs are compatible.
  *
@@ -1148,11 +1155,8 @@ fbconfigs_compatible(const __GLcontextModes * const a,
    MATCH_DONT_CARE(stereoMode);
    MATCH_EXACT(level);
 
-   if (((a->drawableType & b->drawableType) == 0)
-       || ((a->renderType & b->renderType) == 0)) {
-      return False;
-   }
-
+   MATCH_MASK(drawableType);
+   MATCH_MASK(renderType);
 
    /* There is a bug in a few of the XFree86 DDX drivers.  They contain
     * visuals with a "transparent type" of 0 when they really mean GLX_NONE.
@@ -1917,6 +1921,7 @@ __glXSwapIntervalSGI(int interval)
 #endif
    psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
 
+#ifdef GLX_DIRECT_RENDERING
    if (gc->driContext && psc->driScreen && psc->driScreen->setSwapInterval) {
       __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(gc->currentDpy,
 						  gc->currentDrawable,
@@ -1924,6 +1929,7 @@ __glXSwapIntervalSGI(int interval)
       psc->driScreen->setSwapInterval(pdraw, interval);
       return 0;
    }
+#endif
 
    dpy = gc->currentDpy;
    opcode = __glXSetupForCommand(dpy);
@@ -1974,6 +1980,7 @@ __glXSwapIntervalMESA(unsigned int interval)
    }
 #endif
 
+#ifdef GLX_DIRECT_RENDERING
    if (gc != NULL && gc->driContext) {
       __GLXscreenConfigs *psc;
 
@@ -1985,6 +1992,7 @@ __glXSwapIntervalMESA(unsigned int interval)
 	 return 0;
       }
    }
+#endif
 
    return GLX_BAD_CONTEXT;
 }
@@ -2009,6 +2017,8 @@ __glXGetSwapIntervalMESA(void)
       }
    }
 #endif
+
+#ifdef GLX_DIRECT_RENDERING
    if (gc != NULL && gc->driContext) {
       __GLXscreenConfigs *psc;
 
@@ -2019,6 +2029,7 @@ __glXGetSwapIntervalMESA(void)
 	 return psc->driScreen->getSwapInterval(pdraw);
       }
    }
+#endif
 
    return 0;
 }
@@ -2135,13 +2146,22 @@ __glXGetVideoSyncSGI(unsigned int *count)
    int ret;
    GLXContext gc = __glXGetCurrentContext();
    __GLXscreenConfigs *psc;
+#ifdef GLX_DIRECT_RENDERING
    __GLXDRIdrawable *pdraw;
+#endif
+
+   if (!gc)
+      return GLX_BAD_CONTEXT;
 
-   if (!gc || !gc->driContext)
+#ifdef GLX_DIRECT_RENDERING
+   if (!gc->driContext)
       return GLX_BAD_CONTEXT;
+#endif
 
    psc = GetGLXScreenConfigs(gc->currentDpy, gc->screen);
+#ifdef GLX_DIRECT_RENDERING
    pdraw = GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
+#endif
 
    /* FIXME: Looking at the GLX_SGI_video_sync spec in the extension registry,
     * FIXME: there should be a GLX encoding for this call.  I can find no
@@ -2156,11 +2176,14 @@ __glXGetVideoSyncSGI(unsigned int *count)
       return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
    }
 #endif
+
+#ifdef GLX_DIRECT_RENDERING
    if (psc->driScreen && psc->driScreen->getDrawableMSC) {
       ret = psc->driScreen->getDrawableMSC(psc, pdraw, &ust, &msc, &sbc);
       *count = (unsigned) msc;
       return (ret == True) ? 0 : GLX_BAD_CONTEXT;
    }
+#endif
 
    return GLX_BAD_CONTEXT;
 }
@@ -2170,18 +2193,27 @@ __glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
 {
    GLXContext gc = __glXGetCurrentContext();
    __GLXscreenConfigs *psc;
+#ifdef GLX_DIRECT_RENDERING
    __GLXDRIdrawable *pdraw;
+#endif
    int64_t ust, msc, sbc;
    int ret;
 
    if (divisor <= 0 || remainder < 0)
       return GLX_BAD_VALUE;
 
-   if (!gc || !gc->driContext)
+   if (!gc)
       return GLX_BAD_CONTEXT;
 
+#ifdef GLX_DIRECT_RENDERING
+   if (!gc->driContext)
+      return GLX_BAD_CONTEXT;
+#endif
+
    psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
+#ifdef GLX_DIRECT_RENDERING
    pdraw = GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
+#endif
 
 #ifdef __DRI_MEDIA_STREAM_COUNTER
    if (psc->msc != NULL && psc->driScreen ) {
@@ -2191,12 +2223,15 @@ __glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
       return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
    }
 #endif
+
+#ifdef GLX_DIRECT_RENDERING
    if (psc->driScreen && psc->driScreen->waitForMSC) {
       ret = psc->driScreen->waitForMSC(pdraw, 0, divisor, remainder, &ust, &msc,
 				       &sbc);
       *count = (unsigned) msc;
       return (ret == True) ? 0 : GLX_BAD_CONTEXT;
    }
+#endif
 
    return GLX_BAD_CONTEXT;
 }
@@ -2354,13 +2389,17 @@ __glXGetSyncValuesOML(Display * dpy, GLXDrawable drawable,
 {
    __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
    int i, ret;
+#ifdef GLX_DIRECT_RENDERING
    __GLXDRIdrawable *pdraw;
+#endif
    __GLXscreenConfigs *psc;
 
    if (!priv)
       return False;
 
+#ifdef GLX_DIRECT_RENDERING
    pdraw = GetGLXDRIDrawable(dpy, drawable, &i);
+#endif
    psc = &priv->screenConfigs[i];
 
 #if defined(__DRI_SWAP_BUFFER_COUNTER) && defined(__DRI_MEDIA_STREAM_COUNTER)
@@ -2370,10 +2409,13 @@ __glXGetSyncValuesOML(Display * dpy, GLXDrawable drawable,
 	       && ((*psc->sbc->getSBC)(pdraw->driDrawable, sbc) == 0)
 	       && (__glXGetUST(ust) == 0) );
 #endif
+
+#ifdef GLX_DIRECT_RENDERING
    if (pdraw && psc && psc->driScreen && psc->driScreen->getDrawableMSC) {
       ret = psc->driScreen->getDrawableMSC(psc, pdraw, ust, msc, sbc);
       return ret;
    }
+#endif
 
    return False;
 }
@@ -2491,12 +2533,19 @@ __glXSwapBuffersMscOML(Display * dpy, GLXDrawable drawable,
 {
    GLXContext gc = __glXGetCurrentContext();
    int screen;
+#ifdef GLX_DIRECT_RENDERING
    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
+#endif
    __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
 
-   if (!pdraw || !gc || !gc->driContext) /* no GLX for this */
+   if (!gc) /* no GLX for this */
       return -1;
 
+#ifdef GLX_DIRECT_RENDERING
+   if (!pdraw || !gc->driContext)
+      return -1;
+#endif
+
    /* The OML_sync_control spec says these should "generate a GLX_BAD_VALUE
     * error", but it also says "It [glXSwapBuffersMscOML] will return a value
     * of -1 if the function failed because of errors detected in the input
@@ -2533,7 +2582,9 @@ __glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
                    int64_t * msc, int64_t * sbc)
 {
    int screen;
+#ifdef GLX_DIRECT_RENDERING
    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
+#endif
    __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, screen );
    int ret;
 
@@ -2557,11 +2608,14 @@ __glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
       return ((ret == 0) && (__glXGetUST(ust) == 0));
    }
 #endif
+
+#ifdef GLX_DIRECT_RENDERING
    if (pdraw && psc->driScreen && psc->driScreen->waitForMSC) {
       ret = psc->driScreen->waitForMSC(pdraw, target_msc, divisor, remainder,
 				       ust, msc, sbc);
       return ret;
    }
+#endif
 
    return False;
 }
@@ -2573,7 +2627,9 @@ __glXWaitForSbcOML(Display * dpy, GLXDrawable drawable,
                    int64_t * msc, int64_t * sbc)
 {
    int screen;
+#ifdef GLX_DIRECT_RENDERING
    __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
+#endif
    __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
    int ret;
 
@@ -2593,10 +2649,14 @@ __glXWaitForSbcOML(Display * dpy, GLXDrawable drawable,
       return ((ret == 0) && (__glXGetUST(ust) == 0));
    }
 #endif
+
+#ifdef GLX_DIRECT_RENDERING
    if (pdraw && psc->driScreen && psc->driScreen->waitForSBC) {
       ret = psc->driScreen->waitForSBC(pdraw, target_sbc, ust, msc, sbc);
       return ret;
    }
+#endif
+
    return False;
 }
 
diff --git a/src/glx/glxext.c b/src/glx/glxext.c
index b5657baf2e8..5289354a521 100644
--- a/src/glx/glxext.c
+++ b/src/glx/glxext.c
@@ -206,7 +206,7 @@ __glXEventToWire(Display *dpy, XEvent *event, xEvent *wire)
       break;
    case GLX_EXCHANGE_COMPLETE_INTEL:
       break;
-   case GLX_BLIT_COMPLETE_INTEL:
+   case GLX_COPY_COMPLETE_INTEL:
       break;
    case GLX_FLIP_COMPLETE_INTEL:
       break;
diff --git a/src/mesa/SConscript b/src/mesa/SConscript
index 5a04dfd68fb..690fa6d1970 100644
--- a/src/mesa/SConscript
+++ b/src/mesa/SConscript
@@ -167,6 +167,7 @@ if env['platform'] != 'winddk':
 		'state_tracker/st_cb_condrender.c',
 		'state_tracker/st_cb_flush.c',
 		'state_tracker/st_cb_drawpixels.c',
+		'state_tracker/st_cb_eglimage.c',
 		'state_tracker/st_cb_fbo.c',
 		'state_tracker/st_cb_feedback.c',
 		'state_tracker/st_cb_program.c',
@@ -181,7 +182,6 @@ if env['platform'] != 'winddk':
 		'state_tracker/st_draw_feedback.c',
 		'state_tracker/st_extensions.c',
 		'state_tracker/st_format.c',
-		'state_tracker/st_framebuffer.c',
 		'state_tracker/st_gen_mipmap.c',
 		'state_tracker/st_manager.c',
 		'state_tracker/st_mesa_to_tgsi.c',
@@ -356,10 +356,9 @@ if env['platform'] != 'winddk':
 	)
 	Export('mesa')
 	
-	if not dri:
-		glapi = env.ConvenienceLibrary(
-			target = 'glapi',
-			source = glapi_sources,
-		)
-		Export('glapi')
+	glapi = env.ConvenienceLibrary(
+		target = 'glapi',
+		source = glapi_sources,
+	)
+	Export('glapi')
 
diff --git a/src/mesa/drivers/dri/Makefile.template b/src/mesa/drivers/dri/Makefile.template
index f19cc039b22..4cdd51efeee 100644
--- a/src/mesa/drivers/dri/Makefile.template
+++ b/src/mesa/drivers/dri/Makefile.template
@@ -54,7 +54,7 @@ $(LIBNAME): $(OBJECTS) $(MESA_MODULES) $(EXTRA_MODULES) Makefile \
 		$(TOP)/src/mesa/drivers/dri/Makefile.template $(TOP)/src/mesa/drivers/dri/common/dri_test.o
 	$(MKLIB) -o $@.tmp -noprefix -linker '$(CC)' -ldflags '$(LDFLAGS)' \
 		$(OBJECTS) $(MESA_MODULES) $(EXTRA_MODULES) $(DRI_LIB_DEPS)
-	$(CC) -o $@.test $(TOP)/src/mesa/drivers/dri/common/dri_test.o $@.tmp $(DRI_LIB_DEPS)
+	$(CC) $(CFLAGS) -o $@.test $(TOP)/src/mesa/drivers/dri/common/dri_test.o $@.tmp $(DRI_LIB_DEPS)
 	@rm -f $@.test
 	mv -f $@.tmp $@
 
diff --git a/src/mesa/drivers/dri/i915/i915_tex_layout.c b/src/mesa/drivers/dri/i915/i915_tex_layout.c
index 702655283ba..af9c7ee9b6f 100644
--- a/src/mesa/drivers/dri/i915/i915_tex_layout.c
+++ b/src/mesa/drivers/dri/i915/i915_tex_layout.c
@@ -67,7 +67,8 @@ static GLint bottom_offsets[6] = {
 
 
 /**
- * Cube texture map layout for i830M-GM915.
+ * Cube texture map layout for i830M-GM915 and
+ * non-compressed cube texture map on GM945.
  *
  * Hardware layout looks like:
  *
@@ -258,7 +259,7 @@ i915_miptree_layout(struct intel_context *intel, struct intel_mipmap_tree * mt,
 
 
 /**
- * Cube texture map layout for GM945 and later.
+ * Compressed cube texture map layout for GM945 and later.
  *
  * The hardware layout looks like the 830-915 layout, except for the small
  * sizes.  A zoomed in view of the layout for 945 is:
diff --git a/src/mesa/drivers/dri/i965/brw_optimize.c b/src/mesa/drivers/dri/i965/brw_optimize.c
index 57df9ea1151..e79b3ddea35 100644
--- a/src/mesa/drivers/dri/i965/brw_optimize.c
+++ b/src/mesa/drivers/dri/i965/brw_optimize.c
@@ -27,7 +27,6 @@
 
 #include "main/macros.h"
 #include "shader/program.h"
-#include "shader/prog_parameter.h"
 #include "shader/prog_print.h"
 #include "brw_context.h"
 #include "brw_defines.h"
diff --git a/src/mesa/drivers/dri/intel/intel_blit.c b/src/mesa/drivers/dri/intel/intel_blit.c
index 167140d274a..7d9f302dca6 100644
--- a/src/mesa/drivers/dri/intel/intel_blit.c
+++ b/src/mesa/drivers/dri/intel/intel_blit.c
@@ -233,8 +233,6 @@ intelClearWithBlit(GLcontext *ctx, GLbitfield mask)
    GLuint buf;
    all = (cw == fb->Width && ch == fb->Height);
 
-   intel_prepare_render(intel);
-
    /* Loop over all renderbuffers */
    for (buf = 0; buf < BUFFER_COUNT && mask; buf++) {
       const GLbitfield bufBit = 1 << buf;
diff --git a/src/mesa/drivers/dri/intel/intel_clear.c b/src/mesa/drivers/dri/intel/intel_clear.c
index 03b24e2b51f..3c221188660 100644
--- a/src/mesa/drivers/dri/intel/intel_clear.c
+++ b/src/mesa/drivers/dri/intel/intel_clear.c
@@ -90,6 +90,10 @@ intelClear(GLcontext *ctx, GLbitfield mask)
       tri_mask |= (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT));
    }
 
+   /* Make sure we have up to date buffers before we start looking at
+    * the tiling bits to determine how to clear. */
+   intel_prepare_render(intel);
+
    /* HW stencil */
    if (mask & BUFFER_BIT_STENCIL) {
       const struct intel_region *stencilRegion
diff --git a/src/mesa/drivers/dri/intel/intel_extensions.c b/src/mesa/drivers/dri/intel/intel_extensions.c
index a1aac699c91..9c2083873a1 100644
--- a/src/mesa/drivers/dri/intel/intel_extensions.c
+++ b/src/mesa/drivers/dri/intel/intel_extensions.c
@@ -63,6 +63,7 @@
 #define need_GL_ATI_envmap_bumpmap
 #define need_GL_NV_point_sprite
 #define need_GL_NV_vertex_program
+#define need_GL_OES_EGL_image
 #define need_GL_VERSION_2_0
 #define need_GL_VERSION_2_1
 
@@ -130,6 +131,9 @@ static const struct dri_extension card_extensions[] = {
    { "GL_NV_vertex_program",              GL_NV_vertex_program_functions },
    { "GL_NV_vertex_program1_1",           NULL },
    { "GL_SGIS_generate_mipmap",           NULL },
+#if FEATURE_OES_EGL_image
+   { "GL_OES_EGL_image",                  GL_OES_EGL_image_functions },
+#endif
    { NULL, NULL }
 };
 
diff --git a/src/mesa/drivers/dri/mach64/mach64_context.c b/src/mesa/drivers/dri/mach64/mach64_context.c
index 73b1e08d4b8..77e7e53ce04 100644
--- a/src/mesa/drivers/dri/mach64/mach64_context.c
+++ b/src/mesa/drivers/dri/mach64/mach64_context.c
@@ -31,7 +31,6 @@
 
 #include "main/glheader.h"
 #include "main/context.h"
-#include "main/extensions.h"
 #include "main/simple_list.h"
 #include "main/imports.h"
 
diff --git a/src/mesa/drivers/dri/nouveau/nouveau_class.h b/src/mesa/drivers/dri/nouveau/nouveau_class.h
new file mode 120000
index 00000000000..5eff4af4d54
--- /dev/null
+++ b/src/mesa/drivers/dri/nouveau/nouveau_class.h
@@ -0,0 +1 @@
+../../../../gallium/drivers/nouveau/nouveau_class.h
\ No newline at end of file
diff --git a/src/mesa/drivers/dri/r300/compiler/r300_fragprog.c b/src/mesa/drivers/dri/r300/compiler/r300_fragprog.c
index 928c15e1e40..50360de3a38 100644
--- a/src/mesa/drivers/dri/r300/compiler/r300_fragprog.c
+++ b/src/mesa/drivers/dri/r300/compiler/r300_fragprog.c
@@ -142,20 +142,113 @@ int r300_transform_TEX(
 	/* Hardware uses [0..1]x[0..1] range for rectangle textures
 	 * instead of [0..Width]x[0..Height].
 	 * Add a scaling instruction.
+	 *
+	 * See also comments in this same section in r500_fragprog.c
 	 */
-	if (inst->U.I.Opcode != RC_OPCODE_KIL && inst->U.I.TexSrcTarget == RC_TEXTURE_RECT) {
-		struct rc_instruction * inst_mul = rc_insert_new_instruction(c, inst->Prev);
-
-		inst_mul->U.I.Opcode = RC_OPCODE_MUL;
-		inst_mul->U.I.DstReg.File = RC_FILE_TEMPORARY;
-		inst_mul->U.I.DstReg.Index = rc_find_free_temporary(c);
-		inst_mul->U.I.SrcReg[0] = inst->U.I.SrcReg[0];
-		inst_mul->U.I.SrcReg[1].File = RC_FILE_CONSTANT;
-		inst_mul->U.I.SrcReg[1].Index = rc_constants_add_state(&c->Program.Constants, RC_STATE_R300_TEXRECT_FACTOR, inst->U.I.TexSrcUnit);
+	if (inst->U.I.Opcode != RC_OPCODE_KIL &&
+		(inst->U.I.TexSrcTarget == RC_TEXTURE_RECT ||
+			compiler->state.unit[inst->U.I.TexSrcUnit].fake_npot ||
+			compiler->state.unit[inst->U.I.TexSrcUnit].non_normalized_coords)) {
+		rc_wrap_mode wrapmode = compiler->state.unit[inst->U.I.TexSrcUnit].wrap_mode;
+		struct rc_instruction *inst_rect = NULL;
+		unsigned temp = rc_find_free_temporary(c);
+
+		if (inst->U.I.TexSrcTarget == RC_TEXTURE_RECT ||
+			compiler->state.unit[inst->U.I.TexSrcUnit].non_normalized_coords) {
+			inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+			inst_rect->U.I.Opcode = RC_OPCODE_MUL;
+			inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+			inst_rect->U.I.DstReg.Index = temp;
+			inst_rect->U.I.SrcReg[0] = inst->U.I.SrcReg[0];
+			inst_rect->U.I.SrcReg[1].File = RC_FILE_CONSTANT;
+			inst_rect->U.I.SrcReg[1].Index =
+				rc_constants_add_state(&c->Program.Constants,
+					RC_STATE_R300_TEXRECT_FACTOR, inst->U.I.TexSrcUnit);
+
+			reset_srcreg(&inst->U.I.SrcReg[0]);
+			inst->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+			inst->U.I.SrcReg[0].Index = temp;
+
+			inst->U.I.TexSrcTarget = RC_TEXTURE_2D;
+		}
 
-		reset_srcreg(&inst->U.I.SrcReg[0]);
-		inst->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
-		inst->U.I.SrcReg[0].Index = inst_mul->U.I.DstReg.Index;
+		if (compiler->state.unit[inst->U.I.TexSrcUnit].fake_npot &&
+			wrapmode != RC_WRAP_NONE && wrapmode != RC_WRAP_CLAMP) {
+			if (wrapmode == RC_WRAP_REPEAT) {
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_FRC;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0] = inst->U.I.SrcReg[0];
+
+				reset_srcreg(&inst->U.I.SrcReg[0]);
+				inst->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst->U.I.SrcReg[0].Index = temp;
+			} else if (wrapmode == RC_WRAP_MIRROR) {
+				unsigned temp1;
+				/*
+				 * MUL temp0, abs(temp0), 0.5
+				 * FRC temp0, temp0
+				 * SGE temp1, temp0, 0.5
+				 * MAD temp0, neg(0.5), temp1, temp0
+				 * ADD temp0, temp0, temp0
+				 */
+
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_MUL;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0] = inst->U.I.SrcReg[0];
+				inst_rect->U.I.SrcReg[1].Swizzle = RC_MAKE_SWIZZLE_SMEAR(RC_SWIZZLE_HALF);
+
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_FRC;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[0].Index = temp;
+
+				temp1 = rc_find_free_temporary(c);
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_SGE;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp1;
+				inst_rect->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[0].Index = temp;
+				inst_rect->U.I.SrcReg[1].Swizzle = RC_MAKE_SWIZZLE_SMEAR(RC_SWIZZLE_HALF);
+
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_MAD;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[0].Index = temp1;
+				inst_rect->U.I.SrcReg[1].Swizzle = RC_MAKE_SWIZZLE_SMEAR(RC_SWIZZLE_HALF);
+				inst_rect->U.I.SrcReg[1].Negate = 1;
+				inst_rect->U.I.SrcReg[2].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[2].Index = temp;
+
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_ADD;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[0].Index = temp;
+				inst_rect->U.I.SrcReg[1].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[1].Index = temp;
+
+				reset_srcreg(&inst->U.I.SrcReg[0]);
+				inst->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst->U.I.SrcReg[0].Index = temp;
+			}
+		}
 	}
 
 	/* Cannot write texture to output registers or with masks */
diff --git a/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c b/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c
index cc552aee176..37dafa77106 100644
--- a/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c
+++ b/src/mesa/drivers/dri/r300/compiler/r300_fragprog_emit.c
@@ -353,7 +353,7 @@ void r300BuildFragmentProgramHwCode(struct r300_fragment_program_compiler *compi
 		}
 	}
 
-	if (code->pixsize >= R300_PFS_NUM_TEMP_REGS)
+	if (code->pixsize >= compiler->max_temp_regs)
 		rc_error(&compiler->Base, "Too many hardware temporaries used.\n");
 
 	if (compiler->Base.Error)
diff --git a/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c b/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c
index c2d5dc27b49..a5814875bdb 100644
--- a/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c
+++ b/src/mesa/drivers/dri/r300/compiler/r3xx_fragprog.c
@@ -110,6 +110,16 @@ void r3xx_compile_fragment_program(struct r300_fragment_program_compiler* c)
 		c->Base.SwizzleCaps = &r300_swizzle_caps;
 	}
 
+	/* As a stopgap, run the ALU lowering sequence once again.
+	 *
+	 * The entire lowering sequence should be fixed so that these little
+	 * inter-dependent instructions aren't an issue. I suppose we'd need a
+	 * list of safe instructions first... */
+	struct radeon_program_transformation maths_lowering[] = {
+		{ &radeonTransformALU, 0 }
+	};
+	radeonLocalTransform(&c->Base, 1, maths_lowering);
+
 	if (c->Base.Debug) {
 		fprintf(stderr, "Fragment Program: After native rewrite:\n");
 		rc_print_program(&c->Base.Program);
@@ -156,10 +166,7 @@ void r3xx_compile_fragment_program(struct r300_fragment_program_compiler* c)
 		fflush(stderr);
 	}
 
-	if (c->is_r500)
-		rc_pair_regalloc(c, 128);
-	else
-		rc_pair_regalloc(c, R300_PFS_NUM_TEMP_REGS);
+	rc_pair_regalloc(c, c->max_temp_regs);
 
 	if (c->Base.Error)
 		return;
diff --git a/src/mesa/drivers/dri/r300/compiler/r500_fragprog.c b/src/mesa/drivers/dri/r300/compiler/r500_fragprog.c
index b0fb8e970b7..647bc87d0b7 100644
--- a/src/mesa/drivers/dri/r300/compiler/r500_fragprog.c
+++ b/src/mesa/drivers/dri/r300/compiler/r500_fragprog.c
@@ -138,6 +138,142 @@ int r500_transform_TEX(
 		}
 	}
 
+	/* Texture wrap modes don't work on NPOT textures or texrects.
+	 *
+	 * The game plan is simple. We have two flags, fake_npot and
+	 * non_normalized_coords, as well as a tex target. The RECT tex target
+	 * will make the emitted code use non-scaled texcoords.
+	 *
+	 * Non-wrapped/clamped texcoords with NPOT are free in HW. Repeat and
+	 * mirroring are not. If we need to repeat, we do:
+	 *
+	 * MUL temp, texcoord, <scaling factor constant>
+	 * FRC temp, temp ; Discard integer portion of coords
+	 *
+	 * This gives us coords in [0, 1].
+	 *
+	 * Mirroring is trickier. We're going to start out like repeat:
+	 *
+	 * MUL temp0, texcoord, <scaling factor constant> ; De-mirror across axes
+	 * MUL temp0, abs(temp0), 0.5 ; Pattern repeats in [0, 2]
+	 *                            ; so scale to [0, 1]
+	 * FRC temp0, temp0 ; Make the pattern repeat
+	 * SGE temp1, temp0, 0.5 ; Select components that need to be "reflected"
+	 *                       ; across the mirror
+	 * MAD temp0, neg(0.5), temp1, temp0 ; Add -0.5 to the
+	 *                                   ; selected components
+	 * ADD temp0, temp0, temp0 ; Poor man's 2x to undo earlier MUL
+	 *
+	 * This gives us coords in [0, 1].
+	 *
+	 * ~ C.
+	 */
+	if (inst->U.I.Opcode != RC_OPCODE_KIL &&
+		(inst->U.I.TexSrcTarget == RC_TEXTURE_RECT ||
+			compiler->state.unit[inst->U.I.TexSrcUnit].fake_npot ||
+			compiler->state.unit[inst->U.I.TexSrcUnit].non_normalized_coords)) {
+		rc_wrap_mode wrapmode = compiler->state.unit[inst->U.I.TexSrcUnit].wrap_mode;
+		struct rc_instruction *inst_rect = NULL;
+		unsigned temp = rc_find_free_temporary(c);
+
+		if (compiler->state.unit[inst->U.I.TexSrcUnit].fake_npot &&
+			wrapmode != RC_WRAP_NONE && wrapmode != RC_WRAP_CLAMP) {
+
+			if ((inst->U.I.TexSrcTarget == RC_TEXTURE_RECT ||
+				compiler->state.unit[inst->U.I.TexSrcUnit].non_normalized_coords)) {
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_MUL;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0] = inst->U.I.SrcReg[0];
+				inst_rect->U.I.SrcReg[1].File = RC_FILE_CONSTANT;
+				inst_rect->U.I.SrcReg[1].Index =
+					rc_constants_add_state(&c->Program.Constants,
+						RC_STATE_R300_TEXRECT_FACTOR, inst->U.I.TexSrcUnit);
+
+				reset_srcreg(&inst->U.I.SrcReg[0]);
+				inst->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst->U.I.SrcReg[0].Index = temp;
+
+				inst->U.I.TexSrcTarget = RC_TEXTURE_2D;
+			}
+
+			if (wrapmode == RC_WRAP_REPEAT) {
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_FRC;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0] = inst->U.I.SrcReg[0];
+
+				reset_srcreg(&inst->U.I.SrcReg[0]);
+				inst->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst->U.I.SrcReg[0].Index = temp;
+			} else if (wrapmode == RC_WRAP_MIRROR) {
+				unsigned temp1;
+				/*
+				 * MUL temp0, abs(temp0), 0.5
+				 * FRC temp0, temp0
+				 * SGE temp1, temp0, 0.5
+				 * MAD temp0, neg(0.5), temp1, temp0
+				 * ADD temp0, temp0, temp0
+				 */
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_MUL;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0] = inst->U.I.SrcReg[0];
+				inst_rect->U.I.SrcReg[1].Swizzle = RC_MAKE_SWIZZLE_SMEAR(RC_SWIZZLE_HALF);
+
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_FRC;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[0].Index = temp;
+
+				temp1 = rc_find_free_temporary(c);
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_SGE;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp1;
+				inst_rect->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[0].Index = temp;
+				inst_rect->U.I.SrcReg[1].Swizzle = RC_MAKE_SWIZZLE_SMEAR(RC_SWIZZLE_HALF);
+
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_MAD;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[0].Index = temp1;
+				inst_rect->U.I.SrcReg[1].Swizzle = RC_MAKE_SWIZZLE_SMEAR(RC_SWIZZLE_HALF);
+				inst_rect->U.I.SrcReg[1].Negate = 1;
+				inst_rect->U.I.SrcReg[2].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[2].Index = temp;
+
+				inst_rect = rc_insert_new_instruction(c, inst->Prev);
+
+				inst_rect->U.I.Opcode = RC_OPCODE_ADD;
+				inst_rect->U.I.DstReg.File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.DstReg.Index = temp;
+				inst_rect->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[0].Index = temp;
+				inst_rect->U.I.SrcReg[1].File = RC_FILE_TEMPORARY;
+				inst_rect->U.I.SrcReg[1].Index = temp;
+
+				reset_srcreg(&inst->U.I.SrcReg[0]);
+				inst->U.I.SrcReg[0].File = RC_FILE_TEMPORARY;
+				inst->U.I.SrcReg[0].Index = temp;
+			}
+		}
+	}
+
 	/* Cannot write texture to output registers */
 	if (inst->U.I.Opcode != RC_OPCODE_KIL && inst->U.I.DstReg.File != RC_FILE_TEMPORARY) {
 		struct rc_instruction * inst_mov = rc_insert_new_instruction(c, inst);
@@ -433,19 +569,20 @@ void r500FragmentProgramDump(struct rX00_fragment_program_code *c)
 	      (inst >> 30));
       fprintf(stderr,"\t3 RGB_INST:  0x%08x:", code->inst[n].inst3);
       inst = code->inst[n].inst3;
-      fprintf(stderr,"rgb_A_src:%d %s/%s/%s %d rgb_B_src:%d %s/%s/%s %d\n",
+      fprintf(stderr,"rgb_A_src:%d %s/%s/%s %d rgb_B_src:%d %s/%s/%s %d targ: %d\n",
 	      (inst) & 0x3, toswiz((inst >> 2) & 0x7), toswiz((inst >> 5) & 0x7), toswiz((inst >> 8) & 0x7),
 	      (inst >> 11) & 0x3,
 	      (inst >> 13) & 0x3, toswiz((inst >> 15) & 0x7), toswiz((inst >> 18) & 0x7), toswiz((inst >> 21) & 0x7),
-	      (inst >> 24) & 0x3);
+	      (inst >> 24) & 0x3, (inst >> 29) & 0x3);
 
 
       fprintf(stderr,"\t4 ALPHA_INST:0x%08x:", code->inst[n].inst4);
       inst = code->inst[n].inst4;
-      fprintf(stderr,"%s dest:%d%s alp_A_src:%d %s %d alp_B_src:%d %s %d w:%d\n", to_alpha_op(inst & 0xf),
+      fprintf(stderr,"%s dest:%d%s alp_A_src:%d %s %d alp_B_src:%d %s %d targ %d w:%d\n", to_alpha_op(inst & 0xf),
 	      (inst >> 4) & 0x7f, inst & (1<<11) ? "(rel)":"",
 	      (inst >> 12) & 0x3, toswiz((inst >> 14) & 0x7), (inst >> 17) & 0x3,
 	      (inst >> 19) & 0x3, toswiz((inst >> 21) & 0x7), (inst >> 24) & 0x3,
+	      (inst >> 29) & 0x3,
 	      (inst >> 31) & 0x1);
 
       fprintf(stderr,"\t5 RGBA_INST: 0x%08x:", code->inst[n].inst5);
diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_code.h b/src/mesa/drivers/dri/r300/compiler/radeon_code.h
index 6d979bbaecf..0a20dfe2d1a 100644
--- a/src/mesa/drivers/dri/r300/compiler/radeon_code.h
+++ b/src/mesa/drivers/dri/r300/compiler/radeon_code.h
@@ -108,6 +108,18 @@ typedef enum {
 } rc_compare_func;
 
 /**
+ * Coordinate wrapping modes.
+ *
+ * These are not quite the same as their GL counterparts yet.
+ */
+typedef enum {
+	RC_WRAP_NONE = 0,
+	RC_WRAP_CLAMP,
+	RC_WRAP_REPEAT,
+	RC_WRAP_MIRROR
+} rc_wrap_mode;
+
+/**
  * Stores state that influences the compilation of a fragment program.
  */
 struct r300_fragment_program_external_state {
@@ -127,11 +139,28 @@ struct r300_fragment_program_external_state {
 		 * this field specifies the compare function.
 		 *
 		 * Otherwise, this field is \ref RC_COMPARE_FUNC_NEVER (aka 0).
-		 *
-		 * Otherwise, this field is 0.
 		 * \sa rc_compare_func
 		 */
 		unsigned texture_compare_func : 3;
+
+		/**
+		 * If the sampler needs to fake NPOT, this field is set.
+		 */
+		unsigned fake_npot : 1;
+
+		/**
+		 * If the sampler will recieve non-normalized coords,
+		 * this field is set.
+		 */
+		unsigned non_normalized_coords : 1;
+
+		/**
+		 * This field specifies wrapping modes for the sampler.
+		 *
+		 * If this field is \ref RC_WRAP_NONE (aka 0), no wrapping maths
+		 * will be performed on the coordinates.
+		 */
+		unsigned wrap_mode : 2;
 	} unit[16];
 };
 
diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_compiler.h b/src/mesa/drivers/dri/r300/compiler/radeon_compiler.h
index 6bfda0574f6..934ae28da56 100644
--- a/src/mesa/drivers/dri/r300/compiler/radeon_compiler.h
+++ b/src/mesa/drivers/dri/r300/compiler/radeon_compiler.h
@@ -83,6 +83,7 @@ struct r300_fragment_program_compiler {
 	struct rX00_fragment_program_code *code;
 	struct r300_fragment_program_external_state state;
 	unsigned is_r500;
+	unsigned max_temp_regs;
     /* Register corresponding to the depthbuffer. */
 	unsigned OutputDepth;
     /* Registers corresponding to the four colorbuffers. */
diff --git a/src/mesa/drivers/dri/r300/compiler/radeon_pair_translate.c b/src/mesa/drivers/dri/r300/compiler/radeon_pair_translate.c
index 3a26e7daaf9..407a0a55ee2 100644
--- a/src/mesa/drivers/dri/r300/compiler/radeon_pair_translate.c
+++ b/src/mesa/drivers/dri/r300/compiler/radeon_pair_translate.c
@@ -156,7 +156,6 @@ static void set_pair_instruction(struct r300_fragment_program_compiler *c,
 	}
 
 	const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->Opcode);
-	int nargs = opcode->NumSrcRegs;
 	int i;
 
 	for(i = 0; i < opcode->NumSrcRegs; ++i) {
diff --git a/src/mesa/drivers/dri/r300/r300_blit.c b/src/mesa/drivers/dri/r300/r300_blit.c
index fa60628a5e0..f6c3a85e51b 100644
--- a/src/mesa/drivers/dri/r300/r300_blit.c
+++ b/src/mesa/drivers/dri/r300/r300_blit.c
@@ -118,6 +118,7 @@ static void create_fragment_program(struct r300_context *r300)
     compiler.OutputColor[0] = FRAG_RESULT_COLOR;
     compiler.OutputDepth = FRAG_RESULT_DEPTH;
     compiler.is_r500 = (r300->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515);
+    compiler.max_temp_regs = (compiler.is_r500) ? 128 : 32;
     compiler.code = &r300->blit.fp_code;
     compiler.AllocateHwInputs = fp_allocate_hw_inputs;
 
diff --git a/src/mesa/drivers/dri/r300/r300_context.c b/src/mesa/drivers/dri/r300/r300_context.c
index cfeb5407e91..4dce454c3a7 100644
--- a/src/mesa/drivers/dri/r300/r300_context.c
+++ b/src/mesa/drivers/dri/r300/r300_context.c
@@ -61,6 +61,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "r300_state.h"
 #include "r300_tex.h"
 #include "r300_emit.h"
+#include "r300_render.h"
 #include "r300_swtcl.h"
 #include "radeon_bocs_wrapper.h"
 #include "radeon_buffer_objects.h"
@@ -226,6 +227,8 @@ static void r300_fallback(GLcontext *ctx, GLuint bit, GLboolean mode)
 		r300->radeon.Fallback |= bit;
 	else
 		r300->radeon.Fallback &= ~bit;
+
+	r300SwitchFallback(ctx, R300_FALLBACK_RADEON_COMMON, mode);
 }
 
 static void r300_emit_query_finish(radeonContextPtr radeon)
diff --git a/src/mesa/drivers/dri/r300/r300_fragprog_common.c b/src/mesa/drivers/dri/r300/r300_fragprog_common.c
index 0646da46249..ba841229565 100644
--- a/src/mesa/drivers/dri/r300/r300_fragprog_common.c
+++ b/src/mesa/drivers/dri/r300/r300_fragprog_common.c
@@ -220,6 +220,7 @@ static void translate_fragment_program(GLcontext *ctx, struct r300_fragment_prog
 	compiler.code = &fp->code;
 	compiler.state = fp->state;
 	compiler.is_r500 = (r300->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) ? GL_TRUE : GL_FALSE;
+	compiler.max_temp_regs = (compiler.is_r500) ? 128 : 32;
 	compiler.OutputDepth = FRAG_RESULT_DEPTH;
 	memset(compiler.OutputColor, 0, 4 * sizeof(unsigned));
 	compiler.OutputColor[0] = FRAG_RESULT_COLOR;
diff --git a/src/mesa/drivers/dri/r300/r300_render.c b/src/mesa/drivers/dri/r300/r300_render.c
index 95961314863..bb8f91491f5 100644
--- a/src/mesa/drivers/dri/r300/r300_render.c
+++ b/src/mesa/drivers/dri/r300/r300_render.c
@@ -386,6 +386,14 @@ void r300RunRenderPrimitive(GLcontext * ctx, int start, int end, int prim)
 			WARN_ONCE("Fixme: can't handle spliting prim %d\n", prim);
 			return;
 		}
+
+		if (rmesa->radeon.radeonScreen->kernel_mm) {
+			BEGIN_BATCH_NO_AUTOSTATE(2);
+			OUT_BATCH_REGSEQ(R300_VAP_VF_MAX_VTX_INDX, 1);
+			OUT_BATCH(rmesa->radeon.tcl.aos[0].count);
+			END_BATCH();
+		}
+
 		r300_emit_scissor(rmesa->radeon.glCtx);
 		while (num_verts > 0) {
 			int nr;
@@ -400,8 +408,9 @@ void r300RunRenderPrimitive(GLcontext * ctx, int start, int end, int prim)
 	COMMIT_BATCH();
 }
 
-static const char *getFallbackString(uint32_t bit)
+static const char *getFallbackString(r300ContextPtr rmesa, uint32_t bit)
 {
+	static char common_fallback_str[32];
 	switch (bit) {
 		case R300_FALLBACK_VERTEX_PROGRAM :
 			return "vertex program";
@@ -421,6 +430,9 @@ static const char *getFallbackString(uint32_t bit)
 			return "render mode != GL_RENDER";
 		case R300_FALLBACK_FRAGMENT_PROGRAM:
 			return "fragment program";
+		case R300_FALLBACK_RADEON_COMMON:
+			snprintf(common_fallback_str, 32, "radeon common 0x%08x", rmesa->radeon.Fallback);
+			return common_fallback_str;
 		case R300_FALLBACK_AOS_LIMIT:
 			return "aos limit";
 		case R300_FALLBACK_INVALID_BUFFERS:
@@ -440,7 +452,7 @@ void r300SwitchFallback(GLcontext *ctx, uint32_t bit, GLboolean mode)
 	if (mode) {
 		if ((fallback_warn & bit) == 0) {
 			if (RADEON_DEBUG & RADEON_FALLBACKS)
-				fprintf(stderr, "WARNING! Falling back to software for %s\n", getFallbackString(bit));
+				fprintf(stderr, "WARNING! Falling back to software for %s\n", getFallbackString(rmesa, bit));
 			fallback_warn |= bit;
 		}
 		rmesa->fallback |= bit;
diff --git a/src/mesa/drivers/dri/r300/r300_render.h b/src/mesa/drivers/dri/r300/r300_render.h
index ec785474a67..581e9fa0ccd 100644
--- a/src/mesa/drivers/dri/r300/r300_render.h
+++ b/src/mesa/drivers/dri/r300/r300_render.h
@@ -41,6 +41,7 @@
 #define R300_FALLBACK_STENCIL_TWOSIDE   (1 << 21)
 #define R300_FALLBACK_RENDER_MODE       (1 << 22)
 #define R300_FALLBACK_FRAGMENT_PROGRAM  (1 << 23)
+#define R300_FALLBACK_RADEON_COMMON     (1 << 29)
 #define R300_FALLBACK_AOS_LIMIT         (1 << 30)
 #define R300_FALLBACK_INVALID_BUFFERS   (1 << 31)
 #define R300_RASTER_FALLBACK_MASK        0xffff0000
diff --git a/src/mesa/drivers/dri/r300/r300_state.c b/src/mesa/drivers/dri/r300/r300_state.c
index e660b1fb3bb..02ba300eb02 100644
--- a/src/mesa/drivers/dri/r300/r300_state.c
+++ b/src/mesa/drivers/dri/r300/r300_state.c
@@ -53,7 +53,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "shader/prog_statevars.h"
 #include "vbo/vbo.h"
 #include "tnl/tnl.h"
-#include "tnl/t_vp_build.h"
 
 #include "r300_context.h"
 #include "r300_state.h"
diff --git a/src/mesa/drivers/dri/radeon/radeon_chipset.h b/src/mesa/drivers/dri/radeon/radeon_chipset.h
index f17a305bce8..98732c810c5 100644
--- a/src/mesa/drivers/dri/radeon/radeon_chipset.h
+++ b/src/mesa/drivers/dri/radeon/radeon_chipset.h
@@ -357,6 +357,7 @@
 #define PCI_CHIP_RV770_9456             0x9456
 #define PCI_CHIP_RV770_945A             0x945A
 #define PCI_CHIP_RV770_945B             0x945B
+#define PCI_CHIP_RV770_945E             0x945E
 #define PCI_CHIP_RV790_9460             0x9460
 #define PCI_CHIP_RV790_9462             0x9462
 #define PCI_CHIP_RV770_946A             0x946A
@@ -368,6 +369,7 @@
 #define PCI_CHIP_RV730_9487             0x9487
 #define PCI_CHIP_RV730_9488             0x9488
 #define PCI_CHIP_RV730_9489             0x9489
+#define PCI_CHIP_RV730_948A             0x948A
 #define PCI_CHIP_RV730_948F             0x948F
 #define PCI_CHIP_RV730_9490             0x9490
 #define PCI_CHIP_RV730_9491             0x9491
@@ -386,6 +388,7 @@
 #define PCI_CHIP_RV710_9553             0x9553
 #define PCI_CHIP_RV710_9555             0x9555
 #define PCI_CHIP_RV710_9557             0x9557
+#define PCI_CHIP_RV710_955F             0x955F
 
 #define PCI_CHIP_RV740_94A0             0x94A0
 #define PCI_CHIP_RV740_94A1             0x94A1
diff --git a/src/mesa/drivers/dri/radeon/radeon_screen.c b/src/mesa/drivers/dri/radeon/radeon_screen.c
index 6415ec1239c..4d7255f47e7 100644
--- a/src/mesa/drivers/dri/radeon/radeon_screen.c
+++ b/src/mesa/drivers/dri/radeon/radeon_screen.c
@@ -846,6 +846,7 @@ static int radeon_set_screen_flags(radeonScreenPtr screen, int device_id)
    case PCI_CHIP_RV770_9456:
    case PCI_CHIP_RV770_945A:
    case PCI_CHIP_RV770_945B:
+   case PCI_CHIP_RV770_945E:
    case PCI_CHIP_RV790_9460:
    case PCI_CHIP_RV790_9462:
    case PCI_CHIP_RV770_946A:
@@ -860,6 +861,7 @@ static int radeon_set_screen_flags(radeonScreenPtr screen, int device_id)
    case PCI_CHIP_RV730_9487:
    case PCI_CHIP_RV730_9488:
    case PCI_CHIP_RV730_9489:
+   case PCI_CHIP_RV730_948A:
    case PCI_CHIP_RV730_948F:
    case PCI_CHIP_RV730_9490:
    case PCI_CHIP_RV730_9491:
@@ -881,6 +883,7 @@ static int radeon_set_screen_flags(radeonScreenPtr screen, int device_id)
    case PCI_CHIP_RV710_9553:
    case PCI_CHIP_RV710_9555:
    case PCI_CHIP_RV710_9557:
+   case PCI_CHIP_RV710_955F:
       screen->chip_family = CHIP_FAMILY_RV710;
       screen->chip_flags = RADEON_CHIPSET_TCL;
       break;
diff --git a/src/mesa/drivers/dri/radeon/radeon_tex_getimage.c b/src/mesa/drivers/dri/radeon/radeon_tex_getimage.c
index 7bf6dcc2e32..3ababb1ef53 100644
--- a/src/mesa/drivers/dri/radeon/radeon_tex_getimage.c
+++ b/src/mesa/drivers/dri/radeon/radeon_tex_getimage.c
@@ -31,7 +31,6 @@
 
 #include "radeon_common_context.h"
 #include "radeon_texture.h"
-#include "radeon_mipmap_tree.h"
 
 #include "main/texgetimage.h"
 
diff --git a/src/mesa/es/main/specials_es1.c b/src/mesa/es/main/specials_es1.c
index c842007c22e..92e24a03fe5 100644
--- a/src/mesa/es/main/specials_es1.c
+++ b/src/mesa/es/main/specials_es1.c
@@ -153,6 +153,11 @@ make_extension_string(const GLcontext *ctx, char *str)
    if (ctx->Extensions.EXT_multi_draw_arrays)
       len += append_extension(&str, "GL_EXT_multi_draw_arrays");
 
+#if FEATURE_OES_EGL_image
+   if (ctx->Extensions.OES_EGL_image)
+      len += append_extension(&str, "GL_OES_EGL_image");
+#endif
+
    return len;
 }
 
diff --git a/src/mesa/es/main/specials_es2.c b/src/mesa/es/main/specials_es2.c
index 10b4f25e0f0..046cda6fc18 100644
--- a/src/mesa/es/main/specials_es2.c
+++ b/src/mesa/es/main/specials_es2.c
@@ -124,6 +124,11 @@ make_extension_string(const GLcontext *ctx, char *str)
    if (ctx->Extensions.EXT_multi_draw_arrays)
       len += append_extension(&str, "GL_EXT_multi_draw_arrays");
 
+#if FEATURE_OES_EGL_image
+   if (ctx->Extensions.OES_EGL_image)
+      len += append_extension(&str, "GL_OES_EGL_image");
+#endif
+
    return len;
 }
 
diff --git a/src/mesa/es/state_tracker/st_cb_drawtex.c b/src/mesa/es/state_tracker/st_cb_drawtex.c
index f75f4861a2f..6d387d5ccf1 100644
--- a/src/mesa/es/state_tracker/st_cb_drawtex.c
+++ b/src/mesa/es/state_tracker/st_cb_drawtex.c
@@ -115,7 +115,8 @@ st_DrawTex(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z,
    struct st_context *st = ctx->st;
    struct pipe_context *pipe = st->pipe;
    struct cso_context *cso = ctx->st->cso_context;
-   struct pipe_buffer *vbuffer;
+   struct pipe_resource *vbuffer;
+   struct pipe_transfer *vbuffer_transfer;
    GLuint i, numTexCoords, numAttribs;
    GLboolean emitColor;
    uint semantic_names[2 + MAX_TEXTURE_UNITS];
@@ -145,7 +146,7 @@ st_DrawTex(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z,
 
 
    /* create the vertex buffer */
-   vbuffer = pipe_buffer_create(pipe->screen, 32, PIPE_BUFFER_USAGE_VERTEX,
+   vbuffer = pipe_buffer_create(pipe->screen, PIPE_BIND_VERTEX_BUFFER,
                                 numAttribs * 4 * 4 * sizeof(GLfloat));
 
    /* load vertex buffer */
@@ -161,8 +162,9 @@ st_DrawTex(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z,
       } while (0)
 
       const GLfloat x0 = x, y0 = y, x1 = x + width, y1 = y + height;
-      GLfloat *vbuf = (GLfloat *) pipe_buffer_map(pipe->screen, vbuffer,
-                                                  PIPE_BUFFER_USAGE_CPU_WRITE);
+      GLfloat *vbuf = (GLfloat *) pipe_buffer_map(pipe, vbuffer,
+                                                  PIPE_TRANSFER_WRITE,
+                                                  &vbuffer_transfer);
       GLuint attr;
       
       z = CLAMP(z, 0.0f, 1.0f);
@@ -227,7 +229,7 @@ st_DrawTex(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z,
          }
       }
 
-      pipe_buffer_unmap(pipe->screen, vbuffer);
+      pipe_buffer_unmap(pipe, vbuffer, vbuffer_transfer);
 
 #undef SET_ATTRIB
    }
@@ -277,7 +279,7 @@ st_DrawTex(GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z,
                            numAttribs); /* attribs/vert */
 
 
-   pipe_buffer_reference(&vbuffer, NULL);
+   pipe_resource_reference(&vbuffer, NULL);
 
    /* restore state */
    cso_restore_viewport(cso);
diff --git a/src/mesa/glapi/gen/ARB_draw_instanced.xml b/src/mesa/glapi/gen/ARB_draw_instanced.xml
new file mode 100644
index 00000000000..5741a588c9f
--- /dev/null
+++ b/src/mesa/glapi/gen/ARB_draw_instanced.xml
@@ -0,0 +1,69 @@
+<?xml version="1.0"?>
+<!DOCTYPE OpenGLAPI SYSTEM "gl_API.dtd">
+
+<!-- Note: no GLX protocol info yet. -->
+
+
+<OpenGLAPI>
+
+<category name="3.1">
+
+  <function name="DrawArraysInstanced" offset="assign">
+    <param name="mode" type="GLenum"/>
+    <param name="first" type="GLint"/>
+    <param name="count" type="GLsizei"/>
+    <param name="primcount" type="GLsizei"/>
+  </function>
+
+  <function name="DrawElementsInstanced" offset="assign">
+    <param name="mode" type="GLenum"/>
+    <param name="count" type="GLsizei"/>
+    <param name="type" type="GLenum"/>
+    <param name="indices" type="const GLvoid *"/>
+    <param name="primcount" type="GLsizei"/>
+  </function>
+
+</category>
+
+
+<category name="GL_ARB_draw_instanced" number="44">
+
+  <function name="DrawArraysInstancedARB" alias="DrawArraysInstanced">
+    <param name="mode" type="GLenum"/>
+    <param name="first" type="GLint"/>
+    <param name="count" type="GLsizei"/>
+    <param name="primcount" type="GLsizei"/>
+  </function>
+
+  <function name="DrawElementsInstancedARB" alias="DrawElementsInstanced">
+    <param name="mode" type="GLenum"/>
+    <param name="count" type="GLsizei"/>
+    <param name="type" type="GLenum"/>
+    <param name="indices" type="const GLvoid *"/>
+    <param name="primcount" type="GLsizei"/>
+  </function>
+
+</category>
+
+
+<category name="GL_EXT_draw_instanced" number="327">
+
+  <function name="DrawArraysInstancedEXT"  alias="DrawArraysInstanced">
+    <param name="mode" type="GLenum"/>
+    <param name="first" type="GLint"/>
+    <param name="count" type="GLsizei"/>
+    <param name="primcount" type="GLsizei"/>
+  </function>
+
+  <function name="DrawElementsInstancedEXT" alias="DrawElementsInstanced">
+    <param name="mode" type="GLenum"/>
+    <param name="count" type="GLsizei"/>
+    <param name="type" type="GLenum"/>
+    <param name="indices" type="const GLvoid *"/>
+    <param name="primcount" type="GLsizei"/>
+  </function>
+
+</category>
+
+
+</OpenGLAPI>
diff --git a/src/mesa/glapi/gen/EXT_transform_feedback.xml b/src/mesa/glapi/gen/EXT_transform_feedback.xml
new file mode 100644
index 00000000000..abbed9b25b3
--- /dev/null
+++ b/src/mesa/glapi/gen/EXT_transform_feedback.xml
@@ -0,0 +1,123 @@
+<?xml version="1.0"?>
+<!DOCTYPE OpenGLAPI SYSTEM "gl_API.dtd">
+
+<!-- Note: no GLX protocol info yet. -->
+
+
+<OpenGLAPI>
+
+<category name="GL_EXT_transform_feedback" number="352">
+
+  <enum name="TRANSFORM_FEEDBACK_BUFFER_EXT"                  value="0x8C8E"/>
+  <enum name="TRANSFORM_FEEDBACK_BUFFER_START_EXT"            value="0x8C84"/>
+  <enum name="TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT"             value="0x8C85"/>
+  <enum name="TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT"          value="0x8C8F"/>
+  <enum name="INTERLEAVED_ATTRIBS_EXT"                        value="0x8C8C"/>
+  <enum name="SEPARATE_ATTRIBS_EXT"                           value="0x8C8D"/>
+  <enum name="PRIMITIVES_GENERATED_EXT"                       value="0x8C87"/>
+  <enum name="TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT"      value="0x8C88"/>
+  <enum name="RASTERIZER_DISCARD_EXT"                         value="0x8C89"/>
+  <enum name="MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT" value="0x8C8A"/>
+  <enum name="MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT"    value="0x8C8B"/>
+  <enum name="MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT" value="0x8C80"/>
+  <enum name="TRANSFORM_FEEDBACK_VARYINGS_EXT"                value="0x8C83"/>
+  <enum name="TRANSFORM_FEEDBACK_BUFFER_MODE_EXT"             value="0x8C7F"/>
+  <enum name="TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT"      value="0x8C76"/>
+
+  <function name="BindBufferRangeEXT" offset="assign">
+    <param name="target" type="GLenum"/>
+    <param name="index" type="GLuint"/>
+    <param name="buffer" type="GLuint"/>
+    <param name="offset" type="GLintptr"/>
+    <param name="size" type="GLsizeiptr"/>
+  </function>
+
+  <function name="BindBufferOffsetEXT" offset="assign">
+    <param name="target" type="GLenum"/>
+    <param name="index" type="GLuint"/>
+    <param name="buffer" type="GLuint"/>
+    <param name="offset" type="GLintptr"/>
+  </function>
+
+  <function name="BindBufferBaseEXT" offset="assign">
+    <param name="target" type="GLenum"/>
+    <param name="index" type="GLuint"/>
+    <param name="buffer" type="GLuint"/>
+  </function>
+
+  <function name="BeginTransformFeedbackEXT" offset="assign">
+    <param name="mode" type="GLenum"/>
+  </function>
+
+  <function name="EndTransformFeedbackEXT" offset="assign">
+  </function>
+
+  <function name="TransformFeedbackVaryingsEXT" offset="assign">
+    <param name="program" type="GLuint"/>
+    <param name="count" type="GLsizei"/>
+    <param name="varyings" type="const char **"/>
+    <param name="bufferMode" type="GLenum"/>
+  </function>
+
+  <function name="GetTransformFeedbackVaryingEXT" offset="assign">
+    <param name="program" type="GLuint"/>
+    <param name="index" type="GLuint"/>
+    <param name="bufSize" type="GLsizei"/>
+    <param name="length" type="GLsizei *"/>
+    <param name="size" type="GLsizei *"/>
+    <param name="type" type="GLenum *"/>
+    <param name="name" type="GLchar *"/>
+  </function>
+
+  <!-- Note: the glGetIntegerIndexedvEXT() and glGetBooleanIndexedvEXT
+       functions are defined in the EXT_draw_buffers2.xml file -->
+
+</category>
+
+
+<!-- Note: these 3.0 entrypoints might get moved to a new file -->
+
+<category name="3.0">
+
+  <function name="BindBufferRange" alias="BindBufferRangeEXT">
+    <param name="target" type="GLenum"/>
+    <param name="index" type="GLuint"/>
+    <param name="buffer" type="GLuint"/>
+    <param name="offset" type="GLintptr"/>
+    <param name="size" type="GLsizeiptr"/>
+  </function>
+
+  <function name="BindBufferBase" alias="BindBufferBaseEXT">
+    <param name="target" type="GLenum"/>
+    <param name="index" type="GLuint"/>
+    <param name="buffer" type="GLuint"/>
+  </function>
+
+  <function name="BeginTransformFeedback" alias="BeginTransformFeedbackEXT">
+    <param name="mode" type="GLenum"/>
+  </function>
+
+  <function name="EndTransformFeedback" alias="EndTransformFeedbackEXT">
+  </function>
+
+  <function name="TransformFeedbackVaryings" alias="TransformFeedbackVaryingsEXT">
+    <param name="program" type="GLuint"/>
+    <param name="count" type="GLsizei"/>
+    <param name="varyings" type="const char **"/>
+    <param name="bufferMode" type="GLenum"/>
+  </function>
+
+  <function name="GetTransformFeedbackVarying" alias="GetTransformFeedbackVaryingEXT">
+    <param name="program" type="GLuint"/>
+    <param name="index" type="GLuint"/>
+    <param name="bufSize" type="GLsizei"/>
+    <param name="length" type="GLsizei *"/>
+    <param name="size" type="GLsizei *"/>
+    <param name="type" type="GLenum *"/>
+    <param name="name" type="GLchar *"/>
+  </function>
+
+</category>
+
+
+</OpenGLAPI>
diff --git a/src/mesa/glapi/gen/Makefile b/src/mesa/glapi/gen/Makefile
index 8aa74ce4343..84600bdd980 100644
--- a/src/mesa/glapi/gen/Makefile
+++ b/src/mesa/glapi/gen/Makefile
@@ -74,6 +74,7 @@ API_XML = \
 	ARB_copy_buffer.xml \
 	ARB_depth_clamp.xml \
 	ARB_draw_elements_base_vertex.xml \
+	ARB_draw_instanced.xml \
 	ARB_framebuffer_object.xml \
 	ARB_map_buffer_range.xml \
 	ARB_seamless_cube_map.xml \
@@ -86,6 +87,7 @@ API_XML = \
 	EXT_packed_depth_stencil.xml \
 	EXT_provoking_vertex.xml \
 	EXT_texture_array.xml \
+	EXT_transform_feedback.xml \
 	NV_conditional_render.xml \
 	OES_EGL_image.xml
 
@@ -103,7 +105,7 @@ xorg: check-xorg-source $(XORG_OUTPUTS)
 
 check-xorg-source:
 	@if ! test -d $(XORG_GLX_DIR); then \
-		echo "ERROR: Must specify path to xserver checkout; set XORG_BASE."; \
+		echo "ERROR: Must specify path to xserver/GL/GLX checkout; set XORG_GLX_DIR."; \
 		exit 1; \
 	fi
 
diff --git a/src/mesa/glapi/gen/gl_API.xml b/src/mesa/glapi/gen/gl_API.xml
index 4a4d0d5382e..31df7a5f801 100644
--- a/src/mesa/glapi/gen/gl_API.xml
+++ b/src/mesa/glapi/gen/gl_API.xml
@@ -7967,6 +7967,10 @@
 
 <xi:include href="NV_conditional_render.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
 
+<xi:include href="EXT_transform_feedback.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+
+<xi:include href="ARB_draw_instanced.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
+
 
 <!-- Non-ARB extensions sorted by extension number. -->
 
diff --git a/src/mesa/glapi/glapidispatch.h b/src/mesa/glapi/glapidispatch.h
index 7e0f21390ff..f66876fe8d2 100644
--- a/src/mesa/glapi/glapidispatch.h
+++ b/src/mesa/glapi/glapidispatch.h
@@ -1351,6 +1351,12 @@
 #define CALL_UniformMatrix4x3fv(disp, parameters) (*((disp)->UniformMatrix4x3fv)) parameters
 #define GET_UniformMatrix4x3fv(disp) ((disp)->UniformMatrix4x3fv)
 #define SET_UniformMatrix4x3fv(disp, fn) ((disp)->UniformMatrix4x3fv = fn)
+#define CALL_DrawArraysInstanced(disp, parameters) (*((disp)->DrawArraysInstanced)) parameters
+#define GET_DrawArraysInstanced(disp) ((disp)->DrawArraysInstanced)
+#define SET_DrawArraysInstanced(disp, fn) ((disp)->DrawArraysInstanced = fn)
+#define CALL_DrawElementsInstanced(disp, parameters) (*((disp)->DrawElementsInstanced)) parameters
+#define GET_DrawElementsInstanced(disp) ((disp)->DrawElementsInstanced)
+#define SET_DrawElementsInstanced(disp, fn) ((disp)->DrawElementsInstanced = fn)
 #define CALL_LoadTransposeMatrixdARB(disp, parameters) (*((disp)->LoadTransposeMatrixdARB)) parameters
 #define GET_LoadTransposeMatrixdARB(disp) ((disp)->LoadTransposeMatrixdARB)
 #define SET_LoadTransposeMatrixdARB(disp, fn) ((disp)->LoadTransposeMatrixdARB = fn)
@@ -2446,6 +2452,27 @@
 #define CALL_EndConditionalRenderNV(disp, parameters) (*((disp)->EndConditionalRenderNV)) parameters
 #define GET_EndConditionalRenderNV(disp) ((disp)->EndConditionalRenderNV)
 #define SET_EndConditionalRenderNV(disp, fn) ((disp)->EndConditionalRenderNV = fn)
+#define CALL_BeginTransformFeedbackEXT(disp, parameters) (*((disp)->BeginTransformFeedbackEXT)) parameters
+#define GET_BeginTransformFeedbackEXT(disp) ((disp)->BeginTransformFeedbackEXT)
+#define SET_BeginTransformFeedbackEXT(disp, fn) ((disp)->BeginTransformFeedbackEXT = fn)
+#define CALL_BindBufferBaseEXT(disp, parameters) (*((disp)->BindBufferBaseEXT)) parameters
+#define GET_BindBufferBaseEXT(disp) ((disp)->BindBufferBaseEXT)
+#define SET_BindBufferBaseEXT(disp, fn) ((disp)->BindBufferBaseEXT = fn)
+#define CALL_BindBufferOffsetEXT(disp, parameters) (*((disp)->BindBufferOffsetEXT)) parameters
+#define GET_BindBufferOffsetEXT(disp) ((disp)->BindBufferOffsetEXT)
+#define SET_BindBufferOffsetEXT(disp, fn) ((disp)->BindBufferOffsetEXT = fn)
+#define CALL_BindBufferRangeEXT(disp, parameters) (*((disp)->BindBufferRangeEXT)) parameters
+#define GET_BindBufferRangeEXT(disp) ((disp)->BindBufferRangeEXT)
+#define SET_BindBufferRangeEXT(disp, fn) ((disp)->BindBufferRangeEXT = fn)
+#define CALL_EndTransformFeedbackEXT(disp, parameters) (*((disp)->EndTransformFeedbackEXT)) parameters
+#define GET_EndTransformFeedbackEXT(disp) ((disp)->EndTransformFeedbackEXT)
+#define SET_EndTransformFeedbackEXT(disp, fn) ((disp)->EndTransformFeedbackEXT = fn)
+#define CALL_GetTransformFeedbackVaryingEXT(disp, parameters) (*((disp)->GetTransformFeedbackVaryingEXT)) parameters
+#define GET_GetTransformFeedbackVaryingEXT(disp) ((disp)->GetTransformFeedbackVaryingEXT)
+#define SET_GetTransformFeedbackVaryingEXT(disp, fn) ((disp)->GetTransformFeedbackVaryingEXT = fn)
+#define CALL_TransformFeedbackVaryingsEXT(disp, parameters) (*((disp)->TransformFeedbackVaryingsEXT)) parameters
+#define GET_TransformFeedbackVaryingsEXT(disp) ((disp)->TransformFeedbackVaryingsEXT)
+#define SET_TransformFeedbackVaryingsEXT(disp, fn) ((disp)->TransformFeedbackVaryingsEXT = fn)
 #define CALL_ProvokingVertexEXT(disp, parameters) (*((disp)->ProvokingVertexEXT)) parameters
 #define GET_ProvokingVertexEXT(disp) ((disp)->ProvokingVertexEXT)
 #define SET_ProvokingVertexEXT(disp, fn) ((disp)->ProvokingVertexEXT = fn)
@@ -2488,7 +2515,7 @@
 
 #else
 
-#define driDispatchRemapTable_size 400
+#define driDispatchRemapTable_size 409
 extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 
 #define AttachShader_remap_index 0
@@ -2513,384 +2540,393 @@ extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 #define UniformMatrix3x4fv_remap_index 19
 #define UniformMatrix4x2fv_remap_index 20
 #define UniformMatrix4x3fv_remap_index 21
-#define LoadTransposeMatrixdARB_remap_index 22
-#define LoadTransposeMatrixfARB_remap_index 23
-#define MultTransposeMatrixdARB_remap_index 24
-#define MultTransposeMatrixfARB_remap_index 25
-#define SampleCoverageARB_remap_index 26
-#define CompressedTexImage1DARB_remap_index 27
-#define CompressedTexImage2DARB_remap_index 28
-#define CompressedTexImage3DARB_remap_index 29
-#define CompressedTexSubImage1DARB_remap_index 30
-#define CompressedTexSubImage2DARB_remap_index 31
-#define CompressedTexSubImage3DARB_remap_index 32
-#define GetCompressedTexImageARB_remap_index 33
-#define DisableVertexAttribArrayARB_remap_index 34
-#define EnableVertexAttribArrayARB_remap_index 35
-#define GetProgramEnvParameterdvARB_remap_index 36
-#define GetProgramEnvParameterfvARB_remap_index 37
-#define GetProgramLocalParameterdvARB_remap_index 38
-#define GetProgramLocalParameterfvARB_remap_index 39
-#define GetProgramStringARB_remap_index 40
-#define GetProgramivARB_remap_index 41
-#define GetVertexAttribdvARB_remap_index 42
-#define GetVertexAttribfvARB_remap_index 43
-#define GetVertexAttribivARB_remap_index 44
-#define ProgramEnvParameter4dARB_remap_index 45
-#define ProgramEnvParameter4dvARB_remap_index 46
-#define ProgramEnvParameter4fARB_remap_index 47
-#define ProgramEnvParameter4fvARB_remap_index 48
-#define ProgramLocalParameter4dARB_remap_index 49
-#define ProgramLocalParameter4dvARB_remap_index 50
-#define ProgramLocalParameter4fARB_remap_index 51
-#define ProgramLocalParameter4fvARB_remap_index 52
-#define ProgramStringARB_remap_index 53
-#define VertexAttrib1dARB_remap_index 54
-#define VertexAttrib1dvARB_remap_index 55
-#define VertexAttrib1fARB_remap_index 56
-#define VertexAttrib1fvARB_remap_index 57
-#define VertexAttrib1sARB_remap_index 58
-#define VertexAttrib1svARB_remap_index 59
-#define VertexAttrib2dARB_remap_index 60
-#define VertexAttrib2dvARB_remap_index 61
-#define VertexAttrib2fARB_remap_index 62
-#define VertexAttrib2fvARB_remap_index 63
-#define VertexAttrib2sARB_remap_index 64
-#define VertexAttrib2svARB_remap_index 65
-#define VertexAttrib3dARB_remap_index 66
-#define VertexAttrib3dvARB_remap_index 67
-#define VertexAttrib3fARB_remap_index 68
-#define VertexAttrib3fvARB_remap_index 69
-#define VertexAttrib3sARB_remap_index 70
-#define VertexAttrib3svARB_remap_index 71
-#define VertexAttrib4NbvARB_remap_index 72
-#define VertexAttrib4NivARB_remap_index 73
-#define VertexAttrib4NsvARB_remap_index 74
-#define VertexAttrib4NubARB_remap_index 75
-#define VertexAttrib4NubvARB_remap_index 76
-#define VertexAttrib4NuivARB_remap_index 77
-#define VertexAttrib4NusvARB_remap_index 78
-#define VertexAttrib4bvARB_remap_index 79
-#define VertexAttrib4dARB_remap_index 80
-#define VertexAttrib4dvARB_remap_index 81
-#define VertexAttrib4fARB_remap_index 82
-#define VertexAttrib4fvARB_remap_index 83
-#define VertexAttrib4ivARB_remap_index 84
-#define VertexAttrib4sARB_remap_index 85
-#define VertexAttrib4svARB_remap_index 86
-#define VertexAttrib4ubvARB_remap_index 87
-#define VertexAttrib4uivARB_remap_index 88
-#define VertexAttrib4usvARB_remap_index 89
-#define VertexAttribPointerARB_remap_index 90
-#define BindBufferARB_remap_index 91
-#define BufferDataARB_remap_index 92
-#define BufferSubDataARB_remap_index 93
-#define DeleteBuffersARB_remap_index 94
-#define GenBuffersARB_remap_index 95
-#define GetBufferParameterivARB_remap_index 96
-#define GetBufferPointervARB_remap_index 97
-#define GetBufferSubDataARB_remap_index 98
-#define IsBufferARB_remap_index 99
-#define MapBufferARB_remap_index 100
-#define UnmapBufferARB_remap_index 101
-#define BeginQueryARB_remap_index 102
-#define DeleteQueriesARB_remap_index 103
-#define EndQueryARB_remap_index 104
-#define GenQueriesARB_remap_index 105
-#define GetQueryObjectivARB_remap_index 106
-#define GetQueryObjectuivARB_remap_index 107
-#define GetQueryivARB_remap_index 108
-#define IsQueryARB_remap_index 109
-#define AttachObjectARB_remap_index 110
-#define CompileShaderARB_remap_index 111
-#define CreateProgramObjectARB_remap_index 112
-#define CreateShaderObjectARB_remap_index 113
-#define DeleteObjectARB_remap_index 114
-#define DetachObjectARB_remap_index 115
-#define GetActiveUniformARB_remap_index 116
-#define GetAttachedObjectsARB_remap_index 117
-#define GetHandleARB_remap_index 118
-#define GetInfoLogARB_remap_index 119
-#define GetObjectParameterfvARB_remap_index 120
-#define GetObjectParameterivARB_remap_index 121
-#define GetShaderSourceARB_remap_index 122
-#define GetUniformLocationARB_remap_index 123
-#define GetUniformfvARB_remap_index 124
-#define GetUniformivARB_remap_index 125
-#define LinkProgramARB_remap_index 126
-#define ShaderSourceARB_remap_index 127
-#define Uniform1fARB_remap_index 128
-#define Uniform1fvARB_remap_index 129
-#define Uniform1iARB_remap_index 130
-#define Uniform1ivARB_remap_index 131
-#define Uniform2fARB_remap_index 132
-#define Uniform2fvARB_remap_index 133
-#define Uniform2iARB_remap_index 134
-#define Uniform2ivARB_remap_index 135
-#define Uniform3fARB_remap_index 136
-#define Uniform3fvARB_remap_index 137
-#define Uniform3iARB_remap_index 138
-#define Uniform3ivARB_remap_index 139
-#define Uniform4fARB_remap_index 140
-#define Uniform4fvARB_remap_index 141
-#define Uniform4iARB_remap_index 142
-#define Uniform4ivARB_remap_index 143
-#define UniformMatrix2fvARB_remap_index 144
-#define UniformMatrix3fvARB_remap_index 145
-#define UniformMatrix4fvARB_remap_index 146
-#define UseProgramObjectARB_remap_index 147
-#define ValidateProgramARB_remap_index 148
-#define BindAttribLocationARB_remap_index 149
-#define GetActiveAttribARB_remap_index 150
-#define GetAttribLocationARB_remap_index 151
-#define DrawBuffersARB_remap_index 152
-#define RenderbufferStorageMultisample_remap_index 153
-#define FlushMappedBufferRange_remap_index 154
-#define MapBufferRange_remap_index 155
-#define BindVertexArray_remap_index 156
-#define GenVertexArrays_remap_index 157
-#define CopyBufferSubData_remap_index 158
-#define ClientWaitSync_remap_index 159
-#define DeleteSync_remap_index 160
-#define FenceSync_remap_index 161
-#define GetInteger64v_remap_index 162
-#define GetSynciv_remap_index 163
-#define IsSync_remap_index 164
-#define WaitSync_remap_index 165
-#define DrawElementsBaseVertex_remap_index 166
-#define DrawRangeElementsBaseVertex_remap_index 167
-#define MultiDrawElementsBaseVertex_remap_index 168
-#define PolygonOffsetEXT_remap_index 169
-#define GetPixelTexGenParameterfvSGIS_remap_index 170
-#define GetPixelTexGenParameterivSGIS_remap_index 171
-#define PixelTexGenParameterfSGIS_remap_index 172
-#define PixelTexGenParameterfvSGIS_remap_index 173
-#define PixelTexGenParameteriSGIS_remap_index 174
-#define PixelTexGenParameterivSGIS_remap_index 175
-#define SampleMaskSGIS_remap_index 176
-#define SamplePatternSGIS_remap_index 177
-#define ColorPointerEXT_remap_index 178
-#define EdgeFlagPointerEXT_remap_index 179
-#define IndexPointerEXT_remap_index 180
-#define NormalPointerEXT_remap_index 181
-#define TexCoordPointerEXT_remap_index 182
-#define VertexPointerEXT_remap_index 183
-#define PointParameterfEXT_remap_index 184
-#define PointParameterfvEXT_remap_index 185
-#define LockArraysEXT_remap_index 186
-#define UnlockArraysEXT_remap_index 187
-#define CullParameterdvEXT_remap_index 188
-#define CullParameterfvEXT_remap_index 189
-#define SecondaryColor3bEXT_remap_index 190
-#define SecondaryColor3bvEXT_remap_index 191
-#define SecondaryColor3dEXT_remap_index 192
-#define SecondaryColor3dvEXT_remap_index 193
-#define SecondaryColor3fEXT_remap_index 194
-#define SecondaryColor3fvEXT_remap_index 195
-#define SecondaryColor3iEXT_remap_index 196
-#define SecondaryColor3ivEXT_remap_index 197
-#define SecondaryColor3sEXT_remap_index 198
-#define SecondaryColor3svEXT_remap_index 199
-#define SecondaryColor3ubEXT_remap_index 200
-#define SecondaryColor3ubvEXT_remap_index 201
-#define SecondaryColor3uiEXT_remap_index 202
-#define SecondaryColor3uivEXT_remap_index 203
-#define SecondaryColor3usEXT_remap_index 204
-#define SecondaryColor3usvEXT_remap_index 205
-#define SecondaryColorPointerEXT_remap_index 206
-#define MultiDrawArraysEXT_remap_index 207
-#define MultiDrawElementsEXT_remap_index 208
-#define FogCoordPointerEXT_remap_index 209
-#define FogCoorddEXT_remap_index 210
-#define FogCoorddvEXT_remap_index 211
-#define FogCoordfEXT_remap_index 212
-#define FogCoordfvEXT_remap_index 213
-#define PixelTexGenSGIX_remap_index 214
-#define BlendFuncSeparateEXT_remap_index 215
-#define FlushVertexArrayRangeNV_remap_index 216
-#define VertexArrayRangeNV_remap_index 217
-#define CombinerInputNV_remap_index 218
-#define CombinerOutputNV_remap_index 219
-#define CombinerParameterfNV_remap_index 220
-#define CombinerParameterfvNV_remap_index 221
-#define CombinerParameteriNV_remap_index 222
-#define CombinerParameterivNV_remap_index 223
-#define FinalCombinerInputNV_remap_index 224
-#define GetCombinerInputParameterfvNV_remap_index 225
-#define GetCombinerInputParameterivNV_remap_index 226
-#define GetCombinerOutputParameterfvNV_remap_index 227
-#define GetCombinerOutputParameterivNV_remap_index 228
-#define GetFinalCombinerInputParameterfvNV_remap_index 229
-#define GetFinalCombinerInputParameterivNV_remap_index 230
-#define ResizeBuffersMESA_remap_index 231
-#define WindowPos2dMESA_remap_index 232
-#define WindowPos2dvMESA_remap_index 233
-#define WindowPos2fMESA_remap_index 234
-#define WindowPos2fvMESA_remap_index 235
-#define WindowPos2iMESA_remap_index 236
-#define WindowPos2ivMESA_remap_index 237
-#define WindowPos2sMESA_remap_index 238
-#define WindowPos2svMESA_remap_index 239
-#define WindowPos3dMESA_remap_index 240
-#define WindowPos3dvMESA_remap_index 241
-#define WindowPos3fMESA_remap_index 242
-#define WindowPos3fvMESA_remap_index 243
-#define WindowPos3iMESA_remap_index 244
-#define WindowPos3ivMESA_remap_index 245
-#define WindowPos3sMESA_remap_index 246
-#define WindowPos3svMESA_remap_index 247
-#define WindowPos4dMESA_remap_index 248
-#define WindowPos4dvMESA_remap_index 249
-#define WindowPos4fMESA_remap_index 250
-#define WindowPos4fvMESA_remap_index 251
-#define WindowPos4iMESA_remap_index 252
-#define WindowPos4ivMESA_remap_index 253
-#define WindowPos4sMESA_remap_index 254
-#define WindowPos4svMESA_remap_index 255
-#define MultiModeDrawArraysIBM_remap_index 256
-#define MultiModeDrawElementsIBM_remap_index 257
-#define DeleteFencesNV_remap_index 258
-#define FinishFenceNV_remap_index 259
-#define GenFencesNV_remap_index 260
-#define GetFenceivNV_remap_index 261
-#define IsFenceNV_remap_index 262
-#define SetFenceNV_remap_index 263
-#define TestFenceNV_remap_index 264
-#define AreProgramsResidentNV_remap_index 265
-#define BindProgramNV_remap_index 266
-#define DeleteProgramsNV_remap_index 267
-#define ExecuteProgramNV_remap_index 268
-#define GenProgramsNV_remap_index 269
-#define GetProgramParameterdvNV_remap_index 270
-#define GetProgramParameterfvNV_remap_index 271
-#define GetProgramStringNV_remap_index 272
-#define GetProgramivNV_remap_index 273
-#define GetTrackMatrixivNV_remap_index 274
-#define GetVertexAttribPointervNV_remap_index 275
-#define GetVertexAttribdvNV_remap_index 276
-#define GetVertexAttribfvNV_remap_index 277
-#define GetVertexAttribivNV_remap_index 278
-#define IsProgramNV_remap_index 279
-#define LoadProgramNV_remap_index 280
-#define ProgramParameters4dvNV_remap_index 281
-#define ProgramParameters4fvNV_remap_index 282
-#define RequestResidentProgramsNV_remap_index 283
-#define TrackMatrixNV_remap_index 284
-#define VertexAttrib1dNV_remap_index 285
-#define VertexAttrib1dvNV_remap_index 286
-#define VertexAttrib1fNV_remap_index 287
-#define VertexAttrib1fvNV_remap_index 288
-#define VertexAttrib1sNV_remap_index 289
-#define VertexAttrib1svNV_remap_index 290
-#define VertexAttrib2dNV_remap_index 291
-#define VertexAttrib2dvNV_remap_index 292
-#define VertexAttrib2fNV_remap_index 293
-#define VertexAttrib2fvNV_remap_index 294
-#define VertexAttrib2sNV_remap_index 295
-#define VertexAttrib2svNV_remap_index 296
-#define VertexAttrib3dNV_remap_index 297
-#define VertexAttrib3dvNV_remap_index 298
-#define VertexAttrib3fNV_remap_index 299
-#define VertexAttrib3fvNV_remap_index 300
-#define VertexAttrib3sNV_remap_index 301
-#define VertexAttrib3svNV_remap_index 302
-#define VertexAttrib4dNV_remap_index 303
-#define VertexAttrib4dvNV_remap_index 304
-#define VertexAttrib4fNV_remap_index 305
-#define VertexAttrib4fvNV_remap_index 306
-#define VertexAttrib4sNV_remap_index 307
-#define VertexAttrib4svNV_remap_index 308
-#define VertexAttrib4ubNV_remap_index 309
-#define VertexAttrib4ubvNV_remap_index 310
-#define VertexAttribPointerNV_remap_index 311
-#define VertexAttribs1dvNV_remap_index 312
-#define VertexAttribs1fvNV_remap_index 313
-#define VertexAttribs1svNV_remap_index 314
-#define VertexAttribs2dvNV_remap_index 315
-#define VertexAttribs2fvNV_remap_index 316
-#define VertexAttribs2svNV_remap_index 317
-#define VertexAttribs3dvNV_remap_index 318
-#define VertexAttribs3fvNV_remap_index 319
-#define VertexAttribs3svNV_remap_index 320
-#define VertexAttribs4dvNV_remap_index 321
-#define VertexAttribs4fvNV_remap_index 322
-#define VertexAttribs4svNV_remap_index 323
-#define VertexAttribs4ubvNV_remap_index 324
-#define GetTexBumpParameterfvATI_remap_index 325
-#define GetTexBumpParameterivATI_remap_index 326
-#define TexBumpParameterfvATI_remap_index 327
-#define TexBumpParameterivATI_remap_index 328
-#define AlphaFragmentOp1ATI_remap_index 329
-#define AlphaFragmentOp2ATI_remap_index 330
-#define AlphaFragmentOp3ATI_remap_index 331
-#define BeginFragmentShaderATI_remap_index 332
-#define BindFragmentShaderATI_remap_index 333
-#define ColorFragmentOp1ATI_remap_index 334
-#define ColorFragmentOp2ATI_remap_index 335
-#define ColorFragmentOp3ATI_remap_index 336
-#define DeleteFragmentShaderATI_remap_index 337
-#define EndFragmentShaderATI_remap_index 338
-#define GenFragmentShadersATI_remap_index 339
-#define PassTexCoordATI_remap_index 340
-#define SampleMapATI_remap_index 341
-#define SetFragmentShaderConstantATI_remap_index 342
-#define PointParameteriNV_remap_index 343
-#define PointParameterivNV_remap_index 344
-#define ActiveStencilFaceEXT_remap_index 345
-#define BindVertexArrayAPPLE_remap_index 346
-#define DeleteVertexArraysAPPLE_remap_index 347
-#define GenVertexArraysAPPLE_remap_index 348
-#define IsVertexArrayAPPLE_remap_index 349
-#define GetProgramNamedParameterdvNV_remap_index 350
-#define GetProgramNamedParameterfvNV_remap_index 351
-#define ProgramNamedParameter4dNV_remap_index 352
-#define ProgramNamedParameter4dvNV_remap_index 353
-#define ProgramNamedParameter4fNV_remap_index 354
-#define ProgramNamedParameter4fvNV_remap_index 355
-#define DepthBoundsEXT_remap_index 356
-#define BlendEquationSeparateEXT_remap_index 357
-#define BindFramebufferEXT_remap_index 358
-#define BindRenderbufferEXT_remap_index 359
-#define CheckFramebufferStatusEXT_remap_index 360
-#define DeleteFramebuffersEXT_remap_index 361
-#define DeleteRenderbuffersEXT_remap_index 362
-#define FramebufferRenderbufferEXT_remap_index 363
-#define FramebufferTexture1DEXT_remap_index 364
-#define FramebufferTexture2DEXT_remap_index 365
-#define FramebufferTexture3DEXT_remap_index 366
-#define GenFramebuffersEXT_remap_index 367
-#define GenRenderbuffersEXT_remap_index 368
-#define GenerateMipmapEXT_remap_index 369
-#define GetFramebufferAttachmentParameterivEXT_remap_index 370
-#define GetRenderbufferParameterivEXT_remap_index 371
-#define IsFramebufferEXT_remap_index 372
-#define IsRenderbufferEXT_remap_index 373
-#define RenderbufferStorageEXT_remap_index 374
-#define BlitFramebufferEXT_remap_index 375
-#define BufferParameteriAPPLE_remap_index 376
-#define FlushMappedBufferRangeAPPLE_remap_index 377
-#define FramebufferTextureLayerEXT_remap_index 378
-#define ColorMaskIndexedEXT_remap_index 379
-#define DisableIndexedEXT_remap_index 380
-#define EnableIndexedEXT_remap_index 381
-#define GetBooleanIndexedvEXT_remap_index 382
-#define GetIntegerIndexedvEXT_remap_index 383
-#define IsEnabledIndexedEXT_remap_index 384
-#define BeginConditionalRenderNV_remap_index 385
-#define EndConditionalRenderNV_remap_index 386
-#define ProvokingVertexEXT_remap_index 387
-#define GetTexParameterPointervAPPLE_remap_index 388
-#define TextureRangeAPPLE_remap_index 389
-#define GetObjectParameterivAPPLE_remap_index 390
-#define ObjectPurgeableAPPLE_remap_index 391
-#define ObjectUnpurgeableAPPLE_remap_index 392
-#define StencilFuncSeparateATI_remap_index 393
-#define ProgramEnvParameters4fvEXT_remap_index 394
-#define ProgramLocalParameters4fvEXT_remap_index 395
-#define GetQueryObjecti64vEXT_remap_index 396
-#define GetQueryObjectui64vEXT_remap_index 397
-#define EGLImageTargetRenderbufferStorageOES_remap_index 398
-#define EGLImageTargetTexture2DOES_remap_index 399
+#define DrawArraysInstanced_remap_index 22
+#define DrawElementsInstanced_remap_index 23
+#define LoadTransposeMatrixdARB_remap_index 24
+#define LoadTransposeMatrixfARB_remap_index 25
+#define MultTransposeMatrixdARB_remap_index 26
+#define MultTransposeMatrixfARB_remap_index 27
+#define SampleCoverageARB_remap_index 28
+#define CompressedTexImage1DARB_remap_index 29
+#define CompressedTexImage2DARB_remap_index 30
+#define CompressedTexImage3DARB_remap_index 31
+#define CompressedTexSubImage1DARB_remap_index 32
+#define CompressedTexSubImage2DARB_remap_index 33
+#define CompressedTexSubImage3DARB_remap_index 34
+#define GetCompressedTexImageARB_remap_index 35
+#define DisableVertexAttribArrayARB_remap_index 36
+#define EnableVertexAttribArrayARB_remap_index 37
+#define GetProgramEnvParameterdvARB_remap_index 38
+#define GetProgramEnvParameterfvARB_remap_index 39
+#define GetProgramLocalParameterdvARB_remap_index 40
+#define GetProgramLocalParameterfvARB_remap_index 41
+#define GetProgramStringARB_remap_index 42
+#define GetProgramivARB_remap_index 43
+#define GetVertexAttribdvARB_remap_index 44
+#define GetVertexAttribfvARB_remap_index 45
+#define GetVertexAttribivARB_remap_index 46
+#define ProgramEnvParameter4dARB_remap_index 47
+#define ProgramEnvParameter4dvARB_remap_index 48
+#define ProgramEnvParameter4fARB_remap_index 49
+#define ProgramEnvParameter4fvARB_remap_index 50
+#define ProgramLocalParameter4dARB_remap_index 51
+#define ProgramLocalParameter4dvARB_remap_index 52
+#define ProgramLocalParameter4fARB_remap_index 53
+#define ProgramLocalParameter4fvARB_remap_index 54
+#define ProgramStringARB_remap_index 55
+#define VertexAttrib1dARB_remap_index 56
+#define VertexAttrib1dvARB_remap_index 57
+#define VertexAttrib1fARB_remap_index 58
+#define VertexAttrib1fvARB_remap_index 59
+#define VertexAttrib1sARB_remap_index 60
+#define VertexAttrib1svARB_remap_index 61
+#define VertexAttrib2dARB_remap_index 62
+#define VertexAttrib2dvARB_remap_index 63
+#define VertexAttrib2fARB_remap_index 64
+#define VertexAttrib2fvARB_remap_index 65
+#define VertexAttrib2sARB_remap_index 66
+#define VertexAttrib2svARB_remap_index 67
+#define VertexAttrib3dARB_remap_index 68
+#define VertexAttrib3dvARB_remap_index 69
+#define VertexAttrib3fARB_remap_index 70
+#define VertexAttrib3fvARB_remap_index 71
+#define VertexAttrib3sARB_remap_index 72
+#define VertexAttrib3svARB_remap_index 73
+#define VertexAttrib4NbvARB_remap_index 74
+#define VertexAttrib4NivARB_remap_index 75
+#define VertexAttrib4NsvARB_remap_index 76
+#define VertexAttrib4NubARB_remap_index 77
+#define VertexAttrib4NubvARB_remap_index 78
+#define VertexAttrib4NuivARB_remap_index 79
+#define VertexAttrib4NusvARB_remap_index 80
+#define VertexAttrib4bvARB_remap_index 81
+#define VertexAttrib4dARB_remap_index 82
+#define VertexAttrib4dvARB_remap_index 83
+#define VertexAttrib4fARB_remap_index 84
+#define VertexAttrib4fvARB_remap_index 85
+#define VertexAttrib4ivARB_remap_index 86
+#define VertexAttrib4sARB_remap_index 87
+#define VertexAttrib4svARB_remap_index 88
+#define VertexAttrib4ubvARB_remap_index 89
+#define VertexAttrib4uivARB_remap_index 90
+#define VertexAttrib4usvARB_remap_index 91
+#define VertexAttribPointerARB_remap_index 92
+#define BindBufferARB_remap_index 93
+#define BufferDataARB_remap_index 94
+#define BufferSubDataARB_remap_index 95
+#define DeleteBuffersARB_remap_index 96
+#define GenBuffersARB_remap_index 97
+#define GetBufferParameterivARB_remap_index 98
+#define GetBufferPointervARB_remap_index 99
+#define GetBufferSubDataARB_remap_index 100
+#define IsBufferARB_remap_index 101
+#define MapBufferARB_remap_index 102
+#define UnmapBufferARB_remap_index 103
+#define BeginQueryARB_remap_index 104
+#define DeleteQueriesARB_remap_index 105
+#define EndQueryARB_remap_index 106
+#define GenQueriesARB_remap_index 107
+#define GetQueryObjectivARB_remap_index 108
+#define GetQueryObjectuivARB_remap_index 109
+#define GetQueryivARB_remap_index 110
+#define IsQueryARB_remap_index 111
+#define AttachObjectARB_remap_index 112
+#define CompileShaderARB_remap_index 113
+#define CreateProgramObjectARB_remap_index 114
+#define CreateShaderObjectARB_remap_index 115
+#define DeleteObjectARB_remap_index 116
+#define DetachObjectARB_remap_index 117
+#define GetActiveUniformARB_remap_index 118
+#define GetAttachedObjectsARB_remap_index 119
+#define GetHandleARB_remap_index 120
+#define GetInfoLogARB_remap_index 121
+#define GetObjectParameterfvARB_remap_index 122
+#define GetObjectParameterivARB_remap_index 123
+#define GetShaderSourceARB_remap_index 124
+#define GetUniformLocationARB_remap_index 125
+#define GetUniformfvARB_remap_index 126
+#define GetUniformivARB_remap_index 127
+#define LinkProgramARB_remap_index 128
+#define ShaderSourceARB_remap_index 129
+#define Uniform1fARB_remap_index 130
+#define Uniform1fvARB_remap_index 131
+#define Uniform1iARB_remap_index 132
+#define Uniform1ivARB_remap_index 133
+#define Uniform2fARB_remap_index 134
+#define Uniform2fvARB_remap_index 135
+#define Uniform2iARB_remap_index 136
+#define Uniform2ivARB_remap_index 137
+#define Uniform3fARB_remap_index 138
+#define Uniform3fvARB_remap_index 139
+#define Uniform3iARB_remap_index 140
+#define Uniform3ivARB_remap_index 141
+#define Uniform4fARB_remap_index 142
+#define Uniform4fvARB_remap_index 143
+#define Uniform4iARB_remap_index 144
+#define Uniform4ivARB_remap_index 145
+#define UniformMatrix2fvARB_remap_index 146
+#define UniformMatrix3fvARB_remap_index 147
+#define UniformMatrix4fvARB_remap_index 148
+#define UseProgramObjectARB_remap_index 149
+#define ValidateProgramARB_remap_index 150
+#define BindAttribLocationARB_remap_index 151
+#define GetActiveAttribARB_remap_index 152
+#define GetAttribLocationARB_remap_index 153
+#define DrawBuffersARB_remap_index 154
+#define RenderbufferStorageMultisample_remap_index 155
+#define FlushMappedBufferRange_remap_index 156
+#define MapBufferRange_remap_index 157
+#define BindVertexArray_remap_index 158
+#define GenVertexArrays_remap_index 159
+#define CopyBufferSubData_remap_index 160
+#define ClientWaitSync_remap_index 161
+#define DeleteSync_remap_index 162
+#define FenceSync_remap_index 163
+#define GetInteger64v_remap_index 164
+#define GetSynciv_remap_index 165
+#define IsSync_remap_index 166
+#define WaitSync_remap_index 167
+#define DrawElementsBaseVertex_remap_index 168
+#define DrawRangeElementsBaseVertex_remap_index 169
+#define MultiDrawElementsBaseVertex_remap_index 170
+#define PolygonOffsetEXT_remap_index 171
+#define GetPixelTexGenParameterfvSGIS_remap_index 172
+#define GetPixelTexGenParameterivSGIS_remap_index 173
+#define PixelTexGenParameterfSGIS_remap_index 174
+#define PixelTexGenParameterfvSGIS_remap_index 175
+#define PixelTexGenParameteriSGIS_remap_index 176
+#define PixelTexGenParameterivSGIS_remap_index 177
+#define SampleMaskSGIS_remap_index 178
+#define SamplePatternSGIS_remap_index 179
+#define ColorPointerEXT_remap_index 180
+#define EdgeFlagPointerEXT_remap_index 181
+#define IndexPointerEXT_remap_index 182
+#define NormalPointerEXT_remap_index 183
+#define TexCoordPointerEXT_remap_index 184
+#define VertexPointerEXT_remap_index 185
+#define PointParameterfEXT_remap_index 186
+#define PointParameterfvEXT_remap_index 187
+#define LockArraysEXT_remap_index 188
+#define UnlockArraysEXT_remap_index 189
+#define CullParameterdvEXT_remap_index 190
+#define CullParameterfvEXT_remap_index 191
+#define SecondaryColor3bEXT_remap_index 192
+#define SecondaryColor3bvEXT_remap_index 193
+#define SecondaryColor3dEXT_remap_index 194
+#define SecondaryColor3dvEXT_remap_index 195
+#define SecondaryColor3fEXT_remap_index 196
+#define SecondaryColor3fvEXT_remap_index 197
+#define SecondaryColor3iEXT_remap_index 198
+#define SecondaryColor3ivEXT_remap_index 199
+#define SecondaryColor3sEXT_remap_index 200
+#define SecondaryColor3svEXT_remap_index 201
+#define SecondaryColor3ubEXT_remap_index 202
+#define SecondaryColor3ubvEXT_remap_index 203
+#define SecondaryColor3uiEXT_remap_index 204
+#define SecondaryColor3uivEXT_remap_index 205
+#define SecondaryColor3usEXT_remap_index 206
+#define SecondaryColor3usvEXT_remap_index 207
+#define SecondaryColorPointerEXT_remap_index 208
+#define MultiDrawArraysEXT_remap_index 209
+#define MultiDrawElementsEXT_remap_index 210
+#define FogCoordPointerEXT_remap_index 211
+#define FogCoorddEXT_remap_index 212
+#define FogCoorddvEXT_remap_index 213
+#define FogCoordfEXT_remap_index 214
+#define FogCoordfvEXT_remap_index 215
+#define PixelTexGenSGIX_remap_index 216
+#define BlendFuncSeparateEXT_remap_index 217
+#define FlushVertexArrayRangeNV_remap_index 218
+#define VertexArrayRangeNV_remap_index 219
+#define CombinerInputNV_remap_index 220
+#define CombinerOutputNV_remap_index 221
+#define CombinerParameterfNV_remap_index 222
+#define CombinerParameterfvNV_remap_index 223
+#define CombinerParameteriNV_remap_index 224
+#define CombinerParameterivNV_remap_index 225
+#define FinalCombinerInputNV_remap_index 226
+#define GetCombinerInputParameterfvNV_remap_index 227
+#define GetCombinerInputParameterivNV_remap_index 228
+#define GetCombinerOutputParameterfvNV_remap_index 229
+#define GetCombinerOutputParameterivNV_remap_index 230
+#define GetFinalCombinerInputParameterfvNV_remap_index 231
+#define GetFinalCombinerInputParameterivNV_remap_index 232
+#define ResizeBuffersMESA_remap_index 233
+#define WindowPos2dMESA_remap_index 234
+#define WindowPos2dvMESA_remap_index 235
+#define WindowPos2fMESA_remap_index 236
+#define WindowPos2fvMESA_remap_index 237
+#define WindowPos2iMESA_remap_index 238
+#define WindowPos2ivMESA_remap_index 239
+#define WindowPos2sMESA_remap_index 240
+#define WindowPos2svMESA_remap_index 241
+#define WindowPos3dMESA_remap_index 242
+#define WindowPos3dvMESA_remap_index 243
+#define WindowPos3fMESA_remap_index 244
+#define WindowPos3fvMESA_remap_index 245
+#define WindowPos3iMESA_remap_index 246
+#define WindowPos3ivMESA_remap_index 247
+#define WindowPos3sMESA_remap_index 248
+#define WindowPos3svMESA_remap_index 249
+#define WindowPos4dMESA_remap_index 250
+#define WindowPos4dvMESA_remap_index 251
+#define WindowPos4fMESA_remap_index 252
+#define WindowPos4fvMESA_remap_index 253
+#define WindowPos4iMESA_remap_index 254
+#define WindowPos4ivMESA_remap_index 255
+#define WindowPos4sMESA_remap_index 256
+#define WindowPos4svMESA_remap_index 257
+#define MultiModeDrawArraysIBM_remap_index 258
+#define MultiModeDrawElementsIBM_remap_index 259
+#define DeleteFencesNV_remap_index 260
+#define FinishFenceNV_remap_index 261
+#define GenFencesNV_remap_index 262
+#define GetFenceivNV_remap_index 263
+#define IsFenceNV_remap_index 264
+#define SetFenceNV_remap_index 265
+#define TestFenceNV_remap_index 266
+#define AreProgramsResidentNV_remap_index 267
+#define BindProgramNV_remap_index 268
+#define DeleteProgramsNV_remap_index 269
+#define ExecuteProgramNV_remap_index 270
+#define GenProgramsNV_remap_index 271
+#define GetProgramParameterdvNV_remap_index 272
+#define GetProgramParameterfvNV_remap_index 273
+#define GetProgramStringNV_remap_index 274
+#define GetProgramivNV_remap_index 275
+#define GetTrackMatrixivNV_remap_index 276
+#define GetVertexAttribPointervNV_remap_index 277
+#define GetVertexAttribdvNV_remap_index 278
+#define GetVertexAttribfvNV_remap_index 279
+#define GetVertexAttribivNV_remap_index 280
+#define IsProgramNV_remap_index 281
+#define LoadProgramNV_remap_index 282
+#define ProgramParameters4dvNV_remap_index 283
+#define ProgramParameters4fvNV_remap_index 284
+#define RequestResidentProgramsNV_remap_index 285
+#define TrackMatrixNV_remap_index 286
+#define VertexAttrib1dNV_remap_index 287
+#define VertexAttrib1dvNV_remap_index 288
+#define VertexAttrib1fNV_remap_index 289
+#define VertexAttrib1fvNV_remap_index 290
+#define VertexAttrib1sNV_remap_index 291
+#define VertexAttrib1svNV_remap_index 292
+#define VertexAttrib2dNV_remap_index 293
+#define VertexAttrib2dvNV_remap_index 294
+#define VertexAttrib2fNV_remap_index 295
+#define VertexAttrib2fvNV_remap_index 296
+#define VertexAttrib2sNV_remap_index 297
+#define VertexAttrib2svNV_remap_index 298
+#define VertexAttrib3dNV_remap_index 299
+#define VertexAttrib3dvNV_remap_index 300
+#define VertexAttrib3fNV_remap_index 301
+#define VertexAttrib3fvNV_remap_index 302
+#define VertexAttrib3sNV_remap_index 303
+#define VertexAttrib3svNV_remap_index 304
+#define VertexAttrib4dNV_remap_index 305
+#define VertexAttrib4dvNV_remap_index 306
+#define VertexAttrib4fNV_remap_index 307
+#define VertexAttrib4fvNV_remap_index 308
+#define VertexAttrib4sNV_remap_index 309
+#define VertexAttrib4svNV_remap_index 310
+#define VertexAttrib4ubNV_remap_index 311
+#define VertexAttrib4ubvNV_remap_index 312
+#define VertexAttribPointerNV_remap_index 313
+#define VertexAttribs1dvNV_remap_index 314
+#define VertexAttribs1fvNV_remap_index 315
+#define VertexAttribs1svNV_remap_index 316
+#define VertexAttribs2dvNV_remap_index 317
+#define VertexAttribs2fvNV_remap_index 318
+#define VertexAttribs2svNV_remap_index 319
+#define VertexAttribs3dvNV_remap_index 320
+#define VertexAttribs3fvNV_remap_index 321
+#define VertexAttribs3svNV_remap_index 322
+#define VertexAttribs4dvNV_remap_index 323
+#define VertexAttribs4fvNV_remap_index 324
+#define VertexAttribs4svNV_remap_index 325
+#define VertexAttribs4ubvNV_remap_index 326
+#define GetTexBumpParameterfvATI_remap_index 327
+#define GetTexBumpParameterivATI_remap_index 328
+#define TexBumpParameterfvATI_remap_index 329
+#define TexBumpParameterivATI_remap_index 330
+#define AlphaFragmentOp1ATI_remap_index 331
+#define AlphaFragmentOp2ATI_remap_index 332
+#define AlphaFragmentOp3ATI_remap_index 333
+#define BeginFragmentShaderATI_remap_index 334
+#define BindFragmentShaderATI_remap_index 335
+#define ColorFragmentOp1ATI_remap_index 336
+#define ColorFragmentOp2ATI_remap_index 337
+#define ColorFragmentOp3ATI_remap_index 338
+#define DeleteFragmentShaderATI_remap_index 339
+#define EndFragmentShaderATI_remap_index 340
+#define GenFragmentShadersATI_remap_index 341
+#define PassTexCoordATI_remap_index 342
+#define SampleMapATI_remap_index 343
+#define SetFragmentShaderConstantATI_remap_index 344
+#define PointParameteriNV_remap_index 345
+#define PointParameterivNV_remap_index 346
+#define ActiveStencilFaceEXT_remap_index 347
+#define BindVertexArrayAPPLE_remap_index 348
+#define DeleteVertexArraysAPPLE_remap_index 349
+#define GenVertexArraysAPPLE_remap_index 350
+#define IsVertexArrayAPPLE_remap_index 351
+#define GetProgramNamedParameterdvNV_remap_index 352
+#define GetProgramNamedParameterfvNV_remap_index 353
+#define ProgramNamedParameter4dNV_remap_index 354
+#define ProgramNamedParameter4dvNV_remap_index 355
+#define ProgramNamedParameter4fNV_remap_index 356
+#define ProgramNamedParameter4fvNV_remap_index 357
+#define DepthBoundsEXT_remap_index 358
+#define BlendEquationSeparateEXT_remap_index 359
+#define BindFramebufferEXT_remap_index 360
+#define BindRenderbufferEXT_remap_index 361
+#define CheckFramebufferStatusEXT_remap_index 362
+#define DeleteFramebuffersEXT_remap_index 363
+#define DeleteRenderbuffersEXT_remap_index 364
+#define FramebufferRenderbufferEXT_remap_index 365
+#define FramebufferTexture1DEXT_remap_index 366
+#define FramebufferTexture2DEXT_remap_index 367
+#define FramebufferTexture3DEXT_remap_index 368
+#define GenFramebuffersEXT_remap_index 369
+#define GenRenderbuffersEXT_remap_index 370
+#define GenerateMipmapEXT_remap_index 371
+#define GetFramebufferAttachmentParameterivEXT_remap_index 372
+#define GetRenderbufferParameterivEXT_remap_index 373
+#define IsFramebufferEXT_remap_index 374
+#define IsRenderbufferEXT_remap_index 375
+#define RenderbufferStorageEXT_remap_index 376
+#define BlitFramebufferEXT_remap_index 377
+#define BufferParameteriAPPLE_remap_index 378
+#define FlushMappedBufferRangeAPPLE_remap_index 379
+#define FramebufferTextureLayerEXT_remap_index 380
+#define ColorMaskIndexedEXT_remap_index 381
+#define DisableIndexedEXT_remap_index 382
+#define EnableIndexedEXT_remap_index 383
+#define GetBooleanIndexedvEXT_remap_index 384
+#define GetIntegerIndexedvEXT_remap_index 385
+#define IsEnabledIndexedEXT_remap_index 386
+#define BeginConditionalRenderNV_remap_index 387
+#define EndConditionalRenderNV_remap_index 388
+#define BeginTransformFeedbackEXT_remap_index 389
+#define BindBufferBaseEXT_remap_index 390
+#define BindBufferOffsetEXT_remap_index 391
+#define BindBufferRangeEXT_remap_index 392
+#define EndTransformFeedbackEXT_remap_index 393
+#define GetTransformFeedbackVaryingEXT_remap_index 394
+#define TransformFeedbackVaryingsEXT_remap_index 395
+#define ProvokingVertexEXT_remap_index 396
+#define GetTexParameterPointervAPPLE_remap_index 397
+#define TextureRangeAPPLE_remap_index 398
+#define GetObjectParameterivAPPLE_remap_index 399
+#define ObjectPurgeableAPPLE_remap_index 400
+#define ObjectUnpurgeableAPPLE_remap_index 401
+#define StencilFuncSeparateATI_remap_index 402
+#define ProgramEnvParameters4fvEXT_remap_index 403
+#define ProgramLocalParameters4fvEXT_remap_index 404
+#define GetQueryObjecti64vEXT_remap_index 405
+#define GetQueryObjectui64vEXT_remap_index 406
+#define EGLImageTargetRenderbufferStorageOES_remap_index 407
+#define EGLImageTargetTexture2DOES_remap_index 408
 
 #define CALL_AttachShader(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint)), driDispatchRemapTable[AttachShader_remap_index], parameters)
 #define GET_AttachShader(disp) GET_by_offset(disp, driDispatchRemapTable[AttachShader_remap_index])
@@ -2958,6 +2994,12 @@ extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 #define CALL_UniformMatrix4x3fv(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), driDispatchRemapTable[UniformMatrix4x3fv_remap_index], parameters)
 #define GET_UniformMatrix4x3fv(disp) GET_by_offset(disp, driDispatchRemapTable[UniformMatrix4x3fv_remap_index])
 #define SET_UniformMatrix4x3fv(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UniformMatrix4x3fv_remap_index], fn)
+#define CALL_DrawArraysInstanced(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLsizei, GLsizei)), driDispatchRemapTable[DrawArraysInstanced_remap_index], parameters)
+#define GET_DrawArraysInstanced(disp) GET_by_offset(disp, driDispatchRemapTable[DrawArraysInstanced_remap_index])
+#define SET_DrawArraysInstanced(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DrawArraysInstanced_remap_index], fn)
+#define CALL_DrawElementsInstanced(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLenum, const GLvoid *, GLsizei)), driDispatchRemapTable[DrawElementsInstanced_remap_index], parameters)
+#define GET_DrawElementsInstanced(disp) GET_by_offset(disp, driDispatchRemapTable[DrawElementsInstanced_remap_index])
+#define SET_DrawElementsInstanced(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DrawElementsInstanced_remap_index], fn)
 #define CALL_LoadTransposeMatrixdARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index], parameters)
 #define GET_LoadTransposeMatrixdARB(disp) GET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index])
 #define SET_LoadTransposeMatrixdARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index], fn)
@@ -4053,6 +4095,27 @@ extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 #define CALL_EndConditionalRenderNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[EndConditionalRenderNV_remap_index], parameters)
 #define GET_EndConditionalRenderNV(disp) GET_by_offset(disp, driDispatchRemapTable[EndConditionalRenderNV_remap_index])
 #define SET_EndConditionalRenderNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EndConditionalRenderNV_remap_index], fn)
+#define CALL_BeginTransformFeedbackEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[BeginTransformFeedbackEXT_remap_index], parameters)
+#define GET_BeginTransformFeedbackEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BeginTransformFeedbackEXT_remap_index])
+#define SET_BeginTransformFeedbackEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BeginTransformFeedbackEXT_remap_index], fn)
+#define CALL_BindBufferBaseEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint)), driDispatchRemapTable[BindBufferBaseEXT_remap_index], parameters)
+#define GET_BindBufferBaseEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BindBufferBaseEXT_remap_index])
+#define SET_BindBufferBaseEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindBufferBaseEXT_remap_index], fn)
+#define CALL_BindBufferOffsetEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLintptr)), driDispatchRemapTable[BindBufferOffsetEXT_remap_index], parameters)
+#define GET_BindBufferOffsetEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BindBufferOffsetEXT_remap_index])
+#define SET_BindBufferOffsetEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindBufferOffsetEXT_remap_index], fn)
+#define CALL_BindBufferRangeEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLintptr, GLsizeiptr)), driDispatchRemapTable[BindBufferRangeEXT_remap_index], parameters)
+#define GET_BindBufferRangeEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BindBufferRangeEXT_remap_index])
+#define SET_BindBufferRangeEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindBufferRangeEXT_remap_index], fn)
+#define CALL_EndTransformFeedbackEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[EndTransformFeedbackEXT_remap_index], parameters)
+#define GET_EndTransformFeedbackEXT(disp) GET_by_offset(disp, driDispatchRemapTable[EndTransformFeedbackEXT_remap_index])
+#define SET_EndTransformFeedbackEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EndTransformFeedbackEXT_remap_index], fn)
+#define CALL_GetTransformFeedbackVaryingEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLsizei, GLsizei *, GLsizei *, GLenum *, GLchar *)), driDispatchRemapTable[GetTransformFeedbackVaryingEXT_remap_index], parameters)
+#define GET_GetTransformFeedbackVaryingEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetTransformFeedbackVaryingEXT_remap_index])
+#define SET_GetTransformFeedbackVaryingEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetTransformFeedbackVaryingEXT_remap_index], fn)
+#define CALL_TransformFeedbackVaryingsEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const char **, GLenum)), driDispatchRemapTable[TransformFeedbackVaryingsEXT_remap_index], parameters)
+#define GET_TransformFeedbackVaryingsEXT(disp) GET_by_offset(disp, driDispatchRemapTable[TransformFeedbackVaryingsEXT_remap_index])
+#define SET_TransformFeedbackVaryingsEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TransformFeedbackVaryingsEXT_remap_index], fn)
 #define CALL_ProvokingVertexEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[ProvokingVertexEXT_remap_index], parameters)
 #define GET_ProvokingVertexEXT(disp) GET_by_offset(disp, driDispatchRemapTable[ProvokingVertexEXT_remap_index])
 #define SET_ProvokingVertexEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProvokingVertexEXT_remap_index], fn)
diff --git a/src/mesa/glapi/glapioffsets.h b/src/mesa/glapi/glapioffsets.h
index 6d7bc2a0fa9..a8133b40737 100644
--- a/src/mesa/glapi/glapioffsets.h
+++ b/src/mesa/glapi/glapioffsets.h
@@ -464,385 +464,394 @@
 #define _gloffset_UniformMatrix3x4fv 427
 #define _gloffset_UniformMatrix4x2fv 428
 #define _gloffset_UniformMatrix4x3fv 429
-#define _gloffset_LoadTransposeMatrixdARB 430
-#define _gloffset_LoadTransposeMatrixfARB 431
-#define _gloffset_MultTransposeMatrixdARB 432
-#define _gloffset_MultTransposeMatrixfARB 433
-#define _gloffset_SampleCoverageARB 434
-#define _gloffset_CompressedTexImage1DARB 435
-#define _gloffset_CompressedTexImage2DARB 436
-#define _gloffset_CompressedTexImage3DARB 437
-#define _gloffset_CompressedTexSubImage1DARB 438
-#define _gloffset_CompressedTexSubImage2DARB 439
-#define _gloffset_CompressedTexSubImage3DARB 440
-#define _gloffset_GetCompressedTexImageARB 441
-#define _gloffset_DisableVertexAttribArrayARB 442
-#define _gloffset_EnableVertexAttribArrayARB 443
-#define _gloffset_GetProgramEnvParameterdvARB 444
-#define _gloffset_GetProgramEnvParameterfvARB 445
-#define _gloffset_GetProgramLocalParameterdvARB 446
-#define _gloffset_GetProgramLocalParameterfvARB 447
-#define _gloffset_GetProgramStringARB 448
-#define _gloffset_GetProgramivARB 449
-#define _gloffset_GetVertexAttribdvARB 450
-#define _gloffset_GetVertexAttribfvARB 451
-#define _gloffset_GetVertexAttribivARB 452
-#define _gloffset_ProgramEnvParameter4dARB 453
-#define _gloffset_ProgramEnvParameter4dvARB 454
-#define _gloffset_ProgramEnvParameter4fARB 455
-#define _gloffset_ProgramEnvParameter4fvARB 456
-#define _gloffset_ProgramLocalParameter4dARB 457
-#define _gloffset_ProgramLocalParameter4dvARB 458
-#define _gloffset_ProgramLocalParameter4fARB 459
-#define _gloffset_ProgramLocalParameter4fvARB 460
-#define _gloffset_ProgramStringARB 461
-#define _gloffset_VertexAttrib1dARB 462
-#define _gloffset_VertexAttrib1dvARB 463
-#define _gloffset_VertexAttrib1fARB 464
-#define _gloffset_VertexAttrib1fvARB 465
-#define _gloffset_VertexAttrib1sARB 466
-#define _gloffset_VertexAttrib1svARB 467
-#define _gloffset_VertexAttrib2dARB 468
-#define _gloffset_VertexAttrib2dvARB 469
-#define _gloffset_VertexAttrib2fARB 470
-#define _gloffset_VertexAttrib2fvARB 471
-#define _gloffset_VertexAttrib2sARB 472
-#define _gloffset_VertexAttrib2svARB 473
-#define _gloffset_VertexAttrib3dARB 474
-#define _gloffset_VertexAttrib3dvARB 475
-#define _gloffset_VertexAttrib3fARB 476
-#define _gloffset_VertexAttrib3fvARB 477
-#define _gloffset_VertexAttrib3sARB 478
-#define _gloffset_VertexAttrib3svARB 479
-#define _gloffset_VertexAttrib4NbvARB 480
-#define _gloffset_VertexAttrib4NivARB 481
-#define _gloffset_VertexAttrib4NsvARB 482
-#define _gloffset_VertexAttrib4NubARB 483
-#define _gloffset_VertexAttrib4NubvARB 484
-#define _gloffset_VertexAttrib4NuivARB 485
-#define _gloffset_VertexAttrib4NusvARB 486
-#define _gloffset_VertexAttrib4bvARB 487
-#define _gloffset_VertexAttrib4dARB 488
-#define _gloffset_VertexAttrib4dvARB 489
-#define _gloffset_VertexAttrib4fARB 490
-#define _gloffset_VertexAttrib4fvARB 491
-#define _gloffset_VertexAttrib4ivARB 492
-#define _gloffset_VertexAttrib4sARB 493
-#define _gloffset_VertexAttrib4svARB 494
-#define _gloffset_VertexAttrib4ubvARB 495
-#define _gloffset_VertexAttrib4uivARB 496
-#define _gloffset_VertexAttrib4usvARB 497
-#define _gloffset_VertexAttribPointerARB 498
-#define _gloffset_BindBufferARB 499
-#define _gloffset_BufferDataARB 500
-#define _gloffset_BufferSubDataARB 501
-#define _gloffset_DeleteBuffersARB 502
-#define _gloffset_GenBuffersARB 503
-#define _gloffset_GetBufferParameterivARB 504
-#define _gloffset_GetBufferPointervARB 505
-#define _gloffset_GetBufferSubDataARB 506
-#define _gloffset_IsBufferARB 507
-#define _gloffset_MapBufferARB 508
-#define _gloffset_UnmapBufferARB 509
-#define _gloffset_BeginQueryARB 510
-#define _gloffset_DeleteQueriesARB 511
-#define _gloffset_EndQueryARB 512
-#define _gloffset_GenQueriesARB 513
-#define _gloffset_GetQueryObjectivARB 514
-#define _gloffset_GetQueryObjectuivARB 515
-#define _gloffset_GetQueryivARB 516
-#define _gloffset_IsQueryARB 517
-#define _gloffset_AttachObjectARB 518
-#define _gloffset_CompileShaderARB 519
-#define _gloffset_CreateProgramObjectARB 520
-#define _gloffset_CreateShaderObjectARB 521
-#define _gloffset_DeleteObjectARB 522
-#define _gloffset_DetachObjectARB 523
-#define _gloffset_GetActiveUniformARB 524
-#define _gloffset_GetAttachedObjectsARB 525
-#define _gloffset_GetHandleARB 526
-#define _gloffset_GetInfoLogARB 527
-#define _gloffset_GetObjectParameterfvARB 528
-#define _gloffset_GetObjectParameterivARB 529
-#define _gloffset_GetShaderSourceARB 530
-#define _gloffset_GetUniformLocationARB 531
-#define _gloffset_GetUniformfvARB 532
-#define _gloffset_GetUniformivARB 533
-#define _gloffset_LinkProgramARB 534
-#define _gloffset_ShaderSourceARB 535
-#define _gloffset_Uniform1fARB 536
-#define _gloffset_Uniform1fvARB 537
-#define _gloffset_Uniform1iARB 538
-#define _gloffset_Uniform1ivARB 539
-#define _gloffset_Uniform2fARB 540
-#define _gloffset_Uniform2fvARB 541
-#define _gloffset_Uniform2iARB 542
-#define _gloffset_Uniform2ivARB 543
-#define _gloffset_Uniform3fARB 544
-#define _gloffset_Uniform3fvARB 545
-#define _gloffset_Uniform3iARB 546
-#define _gloffset_Uniform3ivARB 547
-#define _gloffset_Uniform4fARB 548
-#define _gloffset_Uniform4fvARB 549
-#define _gloffset_Uniform4iARB 550
-#define _gloffset_Uniform4ivARB 551
-#define _gloffset_UniformMatrix2fvARB 552
-#define _gloffset_UniformMatrix3fvARB 553
-#define _gloffset_UniformMatrix4fvARB 554
-#define _gloffset_UseProgramObjectARB 555
-#define _gloffset_ValidateProgramARB 556
-#define _gloffset_BindAttribLocationARB 557
-#define _gloffset_GetActiveAttribARB 558
-#define _gloffset_GetAttribLocationARB 559
-#define _gloffset_DrawBuffersARB 560
-#define _gloffset_RenderbufferStorageMultisample 561
-#define _gloffset_FlushMappedBufferRange 562
-#define _gloffset_MapBufferRange 563
-#define _gloffset_BindVertexArray 564
-#define _gloffset_GenVertexArrays 565
-#define _gloffset_CopyBufferSubData 566
-#define _gloffset_ClientWaitSync 567
-#define _gloffset_DeleteSync 568
-#define _gloffset_FenceSync 569
-#define _gloffset_GetInteger64v 570
-#define _gloffset_GetSynciv 571
-#define _gloffset_IsSync 572
-#define _gloffset_WaitSync 573
-#define _gloffset_DrawElementsBaseVertex 574
-#define _gloffset_DrawRangeElementsBaseVertex 575
-#define _gloffset_MultiDrawElementsBaseVertex 576
-#define _gloffset_PolygonOffsetEXT 577
-#define _gloffset_GetPixelTexGenParameterfvSGIS 578
-#define _gloffset_GetPixelTexGenParameterivSGIS 579
-#define _gloffset_PixelTexGenParameterfSGIS 580
-#define _gloffset_PixelTexGenParameterfvSGIS 581
-#define _gloffset_PixelTexGenParameteriSGIS 582
-#define _gloffset_PixelTexGenParameterivSGIS 583
-#define _gloffset_SampleMaskSGIS 584
-#define _gloffset_SamplePatternSGIS 585
-#define _gloffset_ColorPointerEXT 586
-#define _gloffset_EdgeFlagPointerEXT 587
-#define _gloffset_IndexPointerEXT 588
-#define _gloffset_NormalPointerEXT 589
-#define _gloffset_TexCoordPointerEXT 590
-#define _gloffset_VertexPointerEXT 591
-#define _gloffset_PointParameterfEXT 592
-#define _gloffset_PointParameterfvEXT 593
-#define _gloffset_LockArraysEXT 594
-#define _gloffset_UnlockArraysEXT 595
-#define _gloffset_CullParameterdvEXT 596
-#define _gloffset_CullParameterfvEXT 597
-#define _gloffset_SecondaryColor3bEXT 598
-#define _gloffset_SecondaryColor3bvEXT 599
-#define _gloffset_SecondaryColor3dEXT 600
-#define _gloffset_SecondaryColor3dvEXT 601
-#define _gloffset_SecondaryColor3fEXT 602
-#define _gloffset_SecondaryColor3fvEXT 603
-#define _gloffset_SecondaryColor3iEXT 604
-#define _gloffset_SecondaryColor3ivEXT 605
-#define _gloffset_SecondaryColor3sEXT 606
-#define _gloffset_SecondaryColor3svEXT 607
-#define _gloffset_SecondaryColor3ubEXT 608
-#define _gloffset_SecondaryColor3ubvEXT 609
-#define _gloffset_SecondaryColor3uiEXT 610
-#define _gloffset_SecondaryColor3uivEXT 611
-#define _gloffset_SecondaryColor3usEXT 612
-#define _gloffset_SecondaryColor3usvEXT 613
-#define _gloffset_SecondaryColorPointerEXT 614
-#define _gloffset_MultiDrawArraysEXT 615
-#define _gloffset_MultiDrawElementsEXT 616
-#define _gloffset_FogCoordPointerEXT 617
-#define _gloffset_FogCoorddEXT 618
-#define _gloffset_FogCoorddvEXT 619
-#define _gloffset_FogCoordfEXT 620
-#define _gloffset_FogCoordfvEXT 621
-#define _gloffset_PixelTexGenSGIX 622
-#define _gloffset_BlendFuncSeparateEXT 623
-#define _gloffset_FlushVertexArrayRangeNV 624
-#define _gloffset_VertexArrayRangeNV 625
-#define _gloffset_CombinerInputNV 626
-#define _gloffset_CombinerOutputNV 627
-#define _gloffset_CombinerParameterfNV 628
-#define _gloffset_CombinerParameterfvNV 629
-#define _gloffset_CombinerParameteriNV 630
-#define _gloffset_CombinerParameterivNV 631
-#define _gloffset_FinalCombinerInputNV 632
-#define _gloffset_GetCombinerInputParameterfvNV 633
-#define _gloffset_GetCombinerInputParameterivNV 634
-#define _gloffset_GetCombinerOutputParameterfvNV 635
-#define _gloffset_GetCombinerOutputParameterivNV 636
-#define _gloffset_GetFinalCombinerInputParameterfvNV 637
-#define _gloffset_GetFinalCombinerInputParameterivNV 638
-#define _gloffset_ResizeBuffersMESA 639
-#define _gloffset_WindowPos2dMESA 640
-#define _gloffset_WindowPos2dvMESA 641
-#define _gloffset_WindowPos2fMESA 642
-#define _gloffset_WindowPos2fvMESA 643
-#define _gloffset_WindowPos2iMESA 644
-#define _gloffset_WindowPos2ivMESA 645
-#define _gloffset_WindowPos2sMESA 646
-#define _gloffset_WindowPos2svMESA 647
-#define _gloffset_WindowPos3dMESA 648
-#define _gloffset_WindowPos3dvMESA 649
-#define _gloffset_WindowPos3fMESA 650
-#define _gloffset_WindowPos3fvMESA 651
-#define _gloffset_WindowPos3iMESA 652
-#define _gloffset_WindowPos3ivMESA 653
-#define _gloffset_WindowPos3sMESA 654
-#define _gloffset_WindowPos3svMESA 655
-#define _gloffset_WindowPos4dMESA 656
-#define _gloffset_WindowPos4dvMESA 657
-#define _gloffset_WindowPos4fMESA 658
-#define _gloffset_WindowPos4fvMESA 659
-#define _gloffset_WindowPos4iMESA 660
-#define _gloffset_WindowPos4ivMESA 661
-#define _gloffset_WindowPos4sMESA 662
-#define _gloffset_WindowPos4svMESA 663
-#define _gloffset_MultiModeDrawArraysIBM 664
-#define _gloffset_MultiModeDrawElementsIBM 665
-#define _gloffset_DeleteFencesNV 666
-#define _gloffset_FinishFenceNV 667
-#define _gloffset_GenFencesNV 668
-#define _gloffset_GetFenceivNV 669
-#define _gloffset_IsFenceNV 670
-#define _gloffset_SetFenceNV 671
-#define _gloffset_TestFenceNV 672
-#define _gloffset_AreProgramsResidentNV 673
-#define _gloffset_BindProgramNV 674
-#define _gloffset_DeleteProgramsNV 675
-#define _gloffset_ExecuteProgramNV 676
-#define _gloffset_GenProgramsNV 677
-#define _gloffset_GetProgramParameterdvNV 678
-#define _gloffset_GetProgramParameterfvNV 679
-#define _gloffset_GetProgramStringNV 680
-#define _gloffset_GetProgramivNV 681
-#define _gloffset_GetTrackMatrixivNV 682
-#define _gloffset_GetVertexAttribPointervNV 683
-#define _gloffset_GetVertexAttribdvNV 684
-#define _gloffset_GetVertexAttribfvNV 685
-#define _gloffset_GetVertexAttribivNV 686
-#define _gloffset_IsProgramNV 687
-#define _gloffset_LoadProgramNV 688
-#define _gloffset_ProgramParameters4dvNV 689
-#define _gloffset_ProgramParameters4fvNV 690
-#define _gloffset_RequestResidentProgramsNV 691
-#define _gloffset_TrackMatrixNV 692
-#define _gloffset_VertexAttrib1dNV 693
-#define _gloffset_VertexAttrib1dvNV 694
-#define _gloffset_VertexAttrib1fNV 695
-#define _gloffset_VertexAttrib1fvNV 696
-#define _gloffset_VertexAttrib1sNV 697
-#define _gloffset_VertexAttrib1svNV 698
-#define _gloffset_VertexAttrib2dNV 699
-#define _gloffset_VertexAttrib2dvNV 700
-#define _gloffset_VertexAttrib2fNV 701
-#define _gloffset_VertexAttrib2fvNV 702
-#define _gloffset_VertexAttrib2sNV 703
-#define _gloffset_VertexAttrib2svNV 704
-#define _gloffset_VertexAttrib3dNV 705
-#define _gloffset_VertexAttrib3dvNV 706
-#define _gloffset_VertexAttrib3fNV 707
-#define _gloffset_VertexAttrib3fvNV 708
-#define _gloffset_VertexAttrib3sNV 709
-#define _gloffset_VertexAttrib3svNV 710
-#define _gloffset_VertexAttrib4dNV 711
-#define _gloffset_VertexAttrib4dvNV 712
-#define _gloffset_VertexAttrib4fNV 713
-#define _gloffset_VertexAttrib4fvNV 714
-#define _gloffset_VertexAttrib4sNV 715
-#define _gloffset_VertexAttrib4svNV 716
-#define _gloffset_VertexAttrib4ubNV 717
-#define _gloffset_VertexAttrib4ubvNV 718
-#define _gloffset_VertexAttribPointerNV 719
-#define _gloffset_VertexAttribs1dvNV 720
-#define _gloffset_VertexAttribs1fvNV 721
-#define _gloffset_VertexAttribs1svNV 722
-#define _gloffset_VertexAttribs2dvNV 723
-#define _gloffset_VertexAttribs2fvNV 724
-#define _gloffset_VertexAttribs2svNV 725
-#define _gloffset_VertexAttribs3dvNV 726
-#define _gloffset_VertexAttribs3fvNV 727
-#define _gloffset_VertexAttribs3svNV 728
-#define _gloffset_VertexAttribs4dvNV 729
-#define _gloffset_VertexAttribs4fvNV 730
-#define _gloffset_VertexAttribs4svNV 731
-#define _gloffset_VertexAttribs4ubvNV 732
-#define _gloffset_GetTexBumpParameterfvATI 733
-#define _gloffset_GetTexBumpParameterivATI 734
-#define _gloffset_TexBumpParameterfvATI 735
-#define _gloffset_TexBumpParameterivATI 736
-#define _gloffset_AlphaFragmentOp1ATI 737
-#define _gloffset_AlphaFragmentOp2ATI 738
-#define _gloffset_AlphaFragmentOp3ATI 739
-#define _gloffset_BeginFragmentShaderATI 740
-#define _gloffset_BindFragmentShaderATI 741
-#define _gloffset_ColorFragmentOp1ATI 742
-#define _gloffset_ColorFragmentOp2ATI 743
-#define _gloffset_ColorFragmentOp3ATI 744
-#define _gloffset_DeleteFragmentShaderATI 745
-#define _gloffset_EndFragmentShaderATI 746
-#define _gloffset_GenFragmentShadersATI 747
-#define _gloffset_PassTexCoordATI 748
-#define _gloffset_SampleMapATI 749
-#define _gloffset_SetFragmentShaderConstantATI 750
-#define _gloffset_PointParameteriNV 751
-#define _gloffset_PointParameterivNV 752
-#define _gloffset_ActiveStencilFaceEXT 753
-#define _gloffset_BindVertexArrayAPPLE 754
-#define _gloffset_DeleteVertexArraysAPPLE 755
-#define _gloffset_GenVertexArraysAPPLE 756
-#define _gloffset_IsVertexArrayAPPLE 757
-#define _gloffset_GetProgramNamedParameterdvNV 758
-#define _gloffset_GetProgramNamedParameterfvNV 759
-#define _gloffset_ProgramNamedParameter4dNV 760
-#define _gloffset_ProgramNamedParameter4dvNV 761
-#define _gloffset_ProgramNamedParameter4fNV 762
-#define _gloffset_ProgramNamedParameter4fvNV 763
-#define _gloffset_DepthBoundsEXT 764
-#define _gloffset_BlendEquationSeparateEXT 765
-#define _gloffset_BindFramebufferEXT 766
-#define _gloffset_BindRenderbufferEXT 767
-#define _gloffset_CheckFramebufferStatusEXT 768
-#define _gloffset_DeleteFramebuffersEXT 769
-#define _gloffset_DeleteRenderbuffersEXT 770
-#define _gloffset_FramebufferRenderbufferEXT 771
-#define _gloffset_FramebufferTexture1DEXT 772
-#define _gloffset_FramebufferTexture2DEXT 773
-#define _gloffset_FramebufferTexture3DEXT 774
-#define _gloffset_GenFramebuffersEXT 775
-#define _gloffset_GenRenderbuffersEXT 776
-#define _gloffset_GenerateMipmapEXT 777
-#define _gloffset_GetFramebufferAttachmentParameterivEXT 778
-#define _gloffset_GetRenderbufferParameterivEXT 779
-#define _gloffset_IsFramebufferEXT 780
-#define _gloffset_IsRenderbufferEXT 781
-#define _gloffset_RenderbufferStorageEXT 782
-#define _gloffset_BlitFramebufferEXT 783
-#define _gloffset_BufferParameteriAPPLE 784
-#define _gloffset_FlushMappedBufferRangeAPPLE 785
-#define _gloffset_FramebufferTextureLayerEXT 786
-#define _gloffset_ColorMaskIndexedEXT 787
-#define _gloffset_DisableIndexedEXT 788
-#define _gloffset_EnableIndexedEXT 789
-#define _gloffset_GetBooleanIndexedvEXT 790
-#define _gloffset_GetIntegerIndexedvEXT 791
-#define _gloffset_IsEnabledIndexedEXT 792
-#define _gloffset_BeginConditionalRenderNV 793
-#define _gloffset_EndConditionalRenderNV 794
-#define _gloffset_ProvokingVertexEXT 795
-#define _gloffset_GetTexParameterPointervAPPLE 796
-#define _gloffset_TextureRangeAPPLE 797
-#define _gloffset_GetObjectParameterivAPPLE 798
-#define _gloffset_ObjectPurgeableAPPLE 799
-#define _gloffset_ObjectUnpurgeableAPPLE 800
-#define _gloffset_StencilFuncSeparateATI 801
-#define _gloffset_ProgramEnvParameters4fvEXT 802
-#define _gloffset_ProgramLocalParameters4fvEXT 803
-#define _gloffset_GetQueryObjecti64vEXT 804
-#define _gloffset_GetQueryObjectui64vEXT 805
-#define _gloffset_EGLImageTargetRenderbufferStorageOES 806
-#define _gloffset_EGLImageTargetTexture2DOES 807
-#define _gloffset_FIRST_DYNAMIC 808
+#define _gloffset_DrawArraysInstanced 430
+#define _gloffset_DrawElementsInstanced 431
+#define _gloffset_LoadTransposeMatrixdARB 432
+#define _gloffset_LoadTransposeMatrixfARB 433
+#define _gloffset_MultTransposeMatrixdARB 434
+#define _gloffset_MultTransposeMatrixfARB 435
+#define _gloffset_SampleCoverageARB 436
+#define _gloffset_CompressedTexImage1DARB 437
+#define _gloffset_CompressedTexImage2DARB 438
+#define _gloffset_CompressedTexImage3DARB 439
+#define _gloffset_CompressedTexSubImage1DARB 440
+#define _gloffset_CompressedTexSubImage2DARB 441
+#define _gloffset_CompressedTexSubImage3DARB 442
+#define _gloffset_GetCompressedTexImageARB 443
+#define _gloffset_DisableVertexAttribArrayARB 444
+#define _gloffset_EnableVertexAttribArrayARB 445
+#define _gloffset_GetProgramEnvParameterdvARB 446
+#define _gloffset_GetProgramEnvParameterfvARB 447
+#define _gloffset_GetProgramLocalParameterdvARB 448
+#define _gloffset_GetProgramLocalParameterfvARB 449
+#define _gloffset_GetProgramStringARB 450
+#define _gloffset_GetProgramivARB 451
+#define _gloffset_GetVertexAttribdvARB 452
+#define _gloffset_GetVertexAttribfvARB 453
+#define _gloffset_GetVertexAttribivARB 454
+#define _gloffset_ProgramEnvParameter4dARB 455
+#define _gloffset_ProgramEnvParameter4dvARB 456
+#define _gloffset_ProgramEnvParameter4fARB 457
+#define _gloffset_ProgramEnvParameter4fvARB 458
+#define _gloffset_ProgramLocalParameter4dARB 459
+#define _gloffset_ProgramLocalParameter4dvARB 460
+#define _gloffset_ProgramLocalParameter4fARB 461
+#define _gloffset_ProgramLocalParameter4fvARB 462
+#define _gloffset_ProgramStringARB 463
+#define _gloffset_VertexAttrib1dARB 464
+#define _gloffset_VertexAttrib1dvARB 465
+#define _gloffset_VertexAttrib1fARB 466
+#define _gloffset_VertexAttrib1fvARB 467
+#define _gloffset_VertexAttrib1sARB 468
+#define _gloffset_VertexAttrib1svARB 469
+#define _gloffset_VertexAttrib2dARB 470
+#define _gloffset_VertexAttrib2dvARB 471
+#define _gloffset_VertexAttrib2fARB 472
+#define _gloffset_VertexAttrib2fvARB 473
+#define _gloffset_VertexAttrib2sARB 474
+#define _gloffset_VertexAttrib2svARB 475
+#define _gloffset_VertexAttrib3dARB 476
+#define _gloffset_VertexAttrib3dvARB 477
+#define _gloffset_VertexAttrib3fARB 478
+#define _gloffset_VertexAttrib3fvARB 479
+#define _gloffset_VertexAttrib3sARB 480
+#define _gloffset_VertexAttrib3svARB 481
+#define _gloffset_VertexAttrib4NbvARB 482
+#define _gloffset_VertexAttrib4NivARB 483
+#define _gloffset_VertexAttrib4NsvARB 484
+#define _gloffset_VertexAttrib4NubARB 485
+#define _gloffset_VertexAttrib4NubvARB 486
+#define _gloffset_VertexAttrib4NuivARB 487
+#define _gloffset_VertexAttrib4NusvARB 488
+#define _gloffset_VertexAttrib4bvARB 489
+#define _gloffset_VertexAttrib4dARB 490
+#define _gloffset_VertexAttrib4dvARB 491
+#define _gloffset_VertexAttrib4fARB 492
+#define _gloffset_VertexAttrib4fvARB 493
+#define _gloffset_VertexAttrib4ivARB 494
+#define _gloffset_VertexAttrib4sARB 495
+#define _gloffset_VertexAttrib4svARB 496
+#define _gloffset_VertexAttrib4ubvARB 497
+#define _gloffset_VertexAttrib4uivARB 498
+#define _gloffset_VertexAttrib4usvARB 499
+#define _gloffset_VertexAttribPointerARB 500
+#define _gloffset_BindBufferARB 501
+#define _gloffset_BufferDataARB 502
+#define _gloffset_BufferSubDataARB 503
+#define _gloffset_DeleteBuffersARB 504
+#define _gloffset_GenBuffersARB 505
+#define _gloffset_GetBufferParameterivARB 506
+#define _gloffset_GetBufferPointervARB 507
+#define _gloffset_GetBufferSubDataARB 508
+#define _gloffset_IsBufferARB 509
+#define _gloffset_MapBufferARB 510
+#define _gloffset_UnmapBufferARB 511
+#define _gloffset_BeginQueryARB 512
+#define _gloffset_DeleteQueriesARB 513
+#define _gloffset_EndQueryARB 514
+#define _gloffset_GenQueriesARB 515
+#define _gloffset_GetQueryObjectivARB 516
+#define _gloffset_GetQueryObjectuivARB 517
+#define _gloffset_GetQueryivARB 518
+#define _gloffset_IsQueryARB 519
+#define _gloffset_AttachObjectARB 520
+#define _gloffset_CompileShaderARB 521
+#define _gloffset_CreateProgramObjectARB 522
+#define _gloffset_CreateShaderObjectARB 523
+#define _gloffset_DeleteObjectARB 524
+#define _gloffset_DetachObjectARB 525
+#define _gloffset_GetActiveUniformARB 526
+#define _gloffset_GetAttachedObjectsARB 527
+#define _gloffset_GetHandleARB 528
+#define _gloffset_GetInfoLogARB 529
+#define _gloffset_GetObjectParameterfvARB 530
+#define _gloffset_GetObjectParameterivARB 531
+#define _gloffset_GetShaderSourceARB 532
+#define _gloffset_GetUniformLocationARB 533
+#define _gloffset_GetUniformfvARB 534
+#define _gloffset_GetUniformivARB 535
+#define _gloffset_LinkProgramARB 536
+#define _gloffset_ShaderSourceARB 537
+#define _gloffset_Uniform1fARB 538
+#define _gloffset_Uniform1fvARB 539
+#define _gloffset_Uniform1iARB 540
+#define _gloffset_Uniform1ivARB 541
+#define _gloffset_Uniform2fARB 542
+#define _gloffset_Uniform2fvARB 543
+#define _gloffset_Uniform2iARB 544
+#define _gloffset_Uniform2ivARB 545
+#define _gloffset_Uniform3fARB 546
+#define _gloffset_Uniform3fvARB 547
+#define _gloffset_Uniform3iARB 548
+#define _gloffset_Uniform3ivARB 549
+#define _gloffset_Uniform4fARB 550
+#define _gloffset_Uniform4fvARB 551
+#define _gloffset_Uniform4iARB 552
+#define _gloffset_Uniform4ivARB 553
+#define _gloffset_UniformMatrix2fvARB 554
+#define _gloffset_UniformMatrix3fvARB 555
+#define _gloffset_UniformMatrix4fvARB 556
+#define _gloffset_UseProgramObjectARB 557
+#define _gloffset_ValidateProgramARB 558
+#define _gloffset_BindAttribLocationARB 559
+#define _gloffset_GetActiveAttribARB 560
+#define _gloffset_GetAttribLocationARB 561
+#define _gloffset_DrawBuffersARB 562
+#define _gloffset_RenderbufferStorageMultisample 563
+#define _gloffset_FlushMappedBufferRange 564
+#define _gloffset_MapBufferRange 565
+#define _gloffset_BindVertexArray 566
+#define _gloffset_GenVertexArrays 567
+#define _gloffset_CopyBufferSubData 568
+#define _gloffset_ClientWaitSync 569
+#define _gloffset_DeleteSync 570
+#define _gloffset_FenceSync 571
+#define _gloffset_GetInteger64v 572
+#define _gloffset_GetSynciv 573
+#define _gloffset_IsSync 574
+#define _gloffset_WaitSync 575
+#define _gloffset_DrawElementsBaseVertex 576
+#define _gloffset_DrawRangeElementsBaseVertex 577
+#define _gloffset_MultiDrawElementsBaseVertex 578
+#define _gloffset_PolygonOffsetEXT 579
+#define _gloffset_GetPixelTexGenParameterfvSGIS 580
+#define _gloffset_GetPixelTexGenParameterivSGIS 581
+#define _gloffset_PixelTexGenParameterfSGIS 582
+#define _gloffset_PixelTexGenParameterfvSGIS 583
+#define _gloffset_PixelTexGenParameteriSGIS 584
+#define _gloffset_PixelTexGenParameterivSGIS 585
+#define _gloffset_SampleMaskSGIS 586
+#define _gloffset_SamplePatternSGIS 587
+#define _gloffset_ColorPointerEXT 588
+#define _gloffset_EdgeFlagPointerEXT 589
+#define _gloffset_IndexPointerEXT 590
+#define _gloffset_NormalPointerEXT 591
+#define _gloffset_TexCoordPointerEXT 592
+#define _gloffset_VertexPointerEXT 593
+#define _gloffset_PointParameterfEXT 594
+#define _gloffset_PointParameterfvEXT 595
+#define _gloffset_LockArraysEXT 596
+#define _gloffset_UnlockArraysEXT 597
+#define _gloffset_CullParameterdvEXT 598
+#define _gloffset_CullParameterfvEXT 599
+#define _gloffset_SecondaryColor3bEXT 600
+#define _gloffset_SecondaryColor3bvEXT 601
+#define _gloffset_SecondaryColor3dEXT 602
+#define _gloffset_SecondaryColor3dvEXT 603
+#define _gloffset_SecondaryColor3fEXT 604
+#define _gloffset_SecondaryColor3fvEXT 605
+#define _gloffset_SecondaryColor3iEXT 606
+#define _gloffset_SecondaryColor3ivEXT 607
+#define _gloffset_SecondaryColor3sEXT 608
+#define _gloffset_SecondaryColor3svEXT 609
+#define _gloffset_SecondaryColor3ubEXT 610
+#define _gloffset_SecondaryColor3ubvEXT 611
+#define _gloffset_SecondaryColor3uiEXT 612
+#define _gloffset_SecondaryColor3uivEXT 613
+#define _gloffset_SecondaryColor3usEXT 614
+#define _gloffset_SecondaryColor3usvEXT 615
+#define _gloffset_SecondaryColorPointerEXT 616
+#define _gloffset_MultiDrawArraysEXT 617
+#define _gloffset_MultiDrawElementsEXT 618
+#define _gloffset_FogCoordPointerEXT 619
+#define _gloffset_FogCoorddEXT 620
+#define _gloffset_FogCoorddvEXT 621
+#define _gloffset_FogCoordfEXT 622
+#define _gloffset_FogCoordfvEXT 623
+#define _gloffset_PixelTexGenSGIX 624
+#define _gloffset_BlendFuncSeparateEXT 625
+#define _gloffset_FlushVertexArrayRangeNV 626
+#define _gloffset_VertexArrayRangeNV 627
+#define _gloffset_CombinerInputNV 628
+#define _gloffset_CombinerOutputNV 629
+#define _gloffset_CombinerParameterfNV 630
+#define _gloffset_CombinerParameterfvNV 631
+#define _gloffset_CombinerParameteriNV 632
+#define _gloffset_CombinerParameterivNV 633
+#define _gloffset_FinalCombinerInputNV 634
+#define _gloffset_GetCombinerInputParameterfvNV 635
+#define _gloffset_GetCombinerInputParameterivNV 636
+#define _gloffset_GetCombinerOutputParameterfvNV 637
+#define _gloffset_GetCombinerOutputParameterivNV 638
+#define _gloffset_GetFinalCombinerInputParameterfvNV 639
+#define _gloffset_GetFinalCombinerInputParameterivNV 640
+#define _gloffset_ResizeBuffersMESA 641
+#define _gloffset_WindowPos2dMESA 642
+#define _gloffset_WindowPos2dvMESA 643
+#define _gloffset_WindowPos2fMESA 644
+#define _gloffset_WindowPos2fvMESA 645
+#define _gloffset_WindowPos2iMESA 646
+#define _gloffset_WindowPos2ivMESA 647
+#define _gloffset_WindowPos2sMESA 648
+#define _gloffset_WindowPos2svMESA 649
+#define _gloffset_WindowPos3dMESA 650
+#define _gloffset_WindowPos3dvMESA 651
+#define _gloffset_WindowPos3fMESA 652
+#define _gloffset_WindowPos3fvMESA 653
+#define _gloffset_WindowPos3iMESA 654
+#define _gloffset_WindowPos3ivMESA 655
+#define _gloffset_WindowPos3sMESA 656
+#define _gloffset_WindowPos3svMESA 657
+#define _gloffset_WindowPos4dMESA 658
+#define _gloffset_WindowPos4dvMESA 659
+#define _gloffset_WindowPos4fMESA 660
+#define _gloffset_WindowPos4fvMESA 661
+#define _gloffset_WindowPos4iMESA 662
+#define _gloffset_WindowPos4ivMESA 663
+#define _gloffset_WindowPos4sMESA 664
+#define _gloffset_WindowPos4svMESA 665
+#define _gloffset_MultiModeDrawArraysIBM 666
+#define _gloffset_MultiModeDrawElementsIBM 667
+#define _gloffset_DeleteFencesNV 668
+#define _gloffset_FinishFenceNV 669
+#define _gloffset_GenFencesNV 670
+#define _gloffset_GetFenceivNV 671
+#define _gloffset_IsFenceNV 672
+#define _gloffset_SetFenceNV 673
+#define _gloffset_TestFenceNV 674
+#define _gloffset_AreProgramsResidentNV 675
+#define _gloffset_BindProgramNV 676
+#define _gloffset_DeleteProgramsNV 677
+#define _gloffset_ExecuteProgramNV 678
+#define _gloffset_GenProgramsNV 679
+#define _gloffset_GetProgramParameterdvNV 680
+#define _gloffset_GetProgramParameterfvNV 681
+#define _gloffset_GetProgramStringNV 682
+#define _gloffset_GetProgramivNV 683
+#define _gloffset_GetTrackMatrixivNV 684
+#define _gloffset_GetVertexAttribPointervNV 685
+#define _gloffset_GetVertexAttribdvNV 686
+#define _gloffset_GetVertexAttribfvNV 687
+#define _gloffset_GetVertexAttribivNV 688
+#define _gloffset_IsProgramNV 689
+#define _gloffset_LoadProgramNV 690
+#define _gloffset_ProgramParameters4dvNV 691
+#define _gloffset_ProgramParameters4fvNV 692
+#define _gloffset_RequestResidentProgramsNV 693
+#define _gloffset_TrackMatrixNV 694
+#define _gloffset_VertexAttrib1dNV 695
+#define _gloffset_VertexAttrib1dvNV 696
+#define _gloffset_VertexAttrib1fNV 697
+#define _gloffset_VertexAttrib1fvNV 698
+#define _gloffset_VertexAttrib1sNV 699
+#define _gloffset_VertexAttrib1svNV 700
+#define _gloffset_VertexAttrib2dNV 701
+#define _gloffset_VertexAttrib2dvNV 702
+#define _gloffset_VertexAttrib2fNV 703
+#define _gloffset_VertexAttrib2fvNV 704
+#define _gloffset_VertexAttrib2sNV 705
+#define _gloffset_VertexAttrib2svNV 706
+#define _gloffset_VertexAttrib3dNV 707
+#define _gloffset_VertexAttrib3dvNV 708
+#define _gloffset_VertexAttrib3fNV 709
+#define _gloffset_VertexAttrib3fvNV 710
+#define _gloffset_VertexAttrib3sNV 711
+#define _gloffset_VertexAttrib3svNV 712
+#define _gloffset_VertexAttrib4dNV 713
+#define _gloffset_VertexAttrib4dvNV 714
+#define _gloffset_VertexAttrib4fNV 715
+#define _gloffset_VertexAttrib4fvNV 716
+#define _gloffset_VertexAttrib4sNV 717
+#define _gloffset_VertexAttrib4svNV 718
+#define _gloffset_VertexAttrib4ubNV 719
+#define _gloffset_VertexAttrib4ubvNV 720
+#define _gloffset_VertexAttribPointerNV 721
+#define _gloffset_VertexAttribs1dvNV 722
+#define _gloffset_VertexAttribs1fvNV 723
+#define _gloffset_VertexAttribs1svNV 724
+#define _gloffset_VertexAttribs2dvNV 725
+#define _gloffset_VertexAttribs2fvNV 726
+#define _gloffset_VertexAttribs2svNV 727
+#define _gloffset_VertexAttribs3dvNV 728
+#define _gloffset_VertexAttribs3fvNV 729
+#define _gloffset_VertexAttribs3svNV 730
+#define _gloffset_VertexAttribs4dvNV 731
+#define _gloffset_VertexAttribs4fvNV 732
+#define _gloffset_VertexAttribs4svNV 733
+#define _gloffset_VertexAttribs4ubvNV 734
+#define _gloffset_GetTexBumpParameterfvATI 735
+#define _gloffset_GetTexBumpParameterivATI 736
+#define _gloffset_TexBumpParameterfvATI 737
+#define _gloffset_TexBumpParameterivATI 738
+#define _gloffset_AlphaFragmentOp1ATI 739
+#define _gloffset_AlphaFragmentOp2ATI 740
+#define _gloffset_AlphaFragmentOp3ATI 741
+#define _gloffset_BeginFragmentShaderATI 742
+#define _gloffset_BindFragmentShaderATI 743
+#define _gloffset_ColorFragmentOp1ATI 744
+#define _gloffset_ColorFragmentOp2ATI 745
+#define _gloffset_ColorFragmentOp3ATI 746
+#define _gloffset_DeleteFragmentShaderATI 747
+#define _gloffset_EndFragmentShaderATI 748
+#define _gloffset_GenFragmentShadersATI 749
+#define _gloffset_PassTexCoordATI 750
+#define _gloffset_SampleMapATI 751
+#define _gloffset_SetFragmentShaderConstantATI 752
+#define _gloffset_PointParameteriNV 753
+#define _gloffset_PointParameterivNV 754
+#define _gloffset_ActiveStencilFaceEXT 755
+#define _gloffset_BindVertexArrayAPPLE 756
+#define _gloffset_DeleteVertexArraysAPPLE 757
+#define _gloffset_GenVertexArraysAPPLE 758
+#define _gloffset_IsVertexArrayAPPLE 759
+#define _gloffset_GetProgramNamedParameterdvNV 760
+#define _gloffset_GetProgramNamedParameterfvNV 761
+#define _gloffset_ProgramNamedParameter4dNV 762
+#define _gloffset_ProgramNamedParameter4dvNV 763
+#define _gloffset_ProgramNamedParameter4fNV 764
+#define _gloffset_ProgramNamedParameter4fvNV 765
+#define _gloffset_DepthBoundsEXT 766
+#define _gloffset_BlendEquationSeparateEXT 767
+#define _gloffset_BindFramebufferEXT 768
+#define _gloffset_BindRenderbufferEXT 769
+#define _gloffset_CheckFramebufferStatusEXT 770
+#define _gloffset_DeleteFramebuffersEXT 771
+#define _gloffset_DeleteRenderbuffersEXT 772
+#define _gloffset_FramebufferRenderbufferEXT 773
+#define _gloffset_FramebufferTexture1DEXT 774
+#define _gloffset_FramebufferTexture2DEXT 775
+#define _gloffset_FramebufferTexture3DEXT 776
+#define _gloffset_GenFramebuffersEXT 777
+#define _gloffset_GenRenderbuffersEXT 778
+#define _gloffset_GenerateMipmapEXT 779
+#define _gloffset_GetFramebufferAttachmentParameterivEXT 780
+#define _gloffset_GetRenderbufferParameterivEXT 781
+#define _gloffset_IsFramebufferEXT 782
+#define _gloffset_IsRenderbufferEXT 783
+#define _gloffset_RenderbufferStorageEXT 784
+#define _gloffset_BlitFramebufferEXT 785
+#define _gloffset_BufferParameteriAPPLE 786
+#define _gloffset_FlushMappedBufferRangeAPPLE 787
+#define _gloffset_FramebufferTextureLayerEXT 788
+#define _gloffset_ColorMaskIndexedEXT 789
+#define _gloffset_DisableIndexedEXT 790
+#define _gloffset_EnableIndexedEXT 791
+#define _gloffset_GetBooleanIndexedvEXT 792
+#define _gloffset_GetIntegerIndexedvEXT 793
+#define _gloffset_IsEnabledIndexedEXT 794
+#define _gloffset_BeginConditionalRenderNV 795
+#define _gloffset_EndConditionalRenderNV 796
+#define _gloffset_BeginTransformFeedbackEXT 797
+#define _gloffset_BindBufferBaseEXT 798
+#define _gloffset_BindBufferOffsetEXT 799
+#define _gloffset_BindBufferRangeEXT 800
+#define _gloffset_EndTransformFeedbackEXT 801
+#define _gloffset_GetTransformFeedbackVaryingEXT 802
+#define _gloffset_TransformFeedbackVaryingsEXT 803
+#define _gloffset_ProvokingVertexEXT 804
+#define _gloffset_GetTexParameterPointervAPPLE 805
+#define _gloffset_TextureRangeAPPLE 806
+#define _gloffset_GetObjectParameterivAPPLE 807
+#define _gloffset_ObjectPurgeableAPPLE 808
+#define _gloffset_ObjectUnpurgeableAPPLE 809
+#define _gloffset_StencilFuncSeparateATI 810
+#define _gloffset_ProgramEnvParameters4fvEXT 811
+#define _gloffset_ProgramLocalParameters4fvEXT 812
+#define _gloffset_GetQueryObjecti64vEXT 813
+#define _gloffset_GetQueryObjectui64vEXT 814
+#define _gloffset_EGLImageTargetRenderbufferStorageOES 815
+#define _gloffset_EGLImageTargetTexture2DOES 816
+#define _gloffset_FIRST_DYNAMIC 817
 
 #else
 
@@ -868,6 +877,8 @@
 #define _gloffset_UniformMatrix3x4fv driDispatchRemapTable[UniformMatrix3x4fv_remap_index]
 #define _gloffset_UniformMatrix4x2fv driDispatchRemapTable[UniformMatrix4x2fv_remap_index]
 #define _gloffset_UniformMatrix4x3fv driDispatchRemapTable[UniformMatrix4x3fv_remap_index]
+#define _gloffset_DrawArraysInstanced driDispatchRemapTable[DrawArraysInstanced_remap_index]
+#define _gloffset_DrawElementsInstanced driDispatchRemapTable[DrawElementsInstanced_remap_index]
 #define _gloffset_LoadTransposeMatrixdARB driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index]
 #define _gloffset_LoadTransposeMatrixfARB driDispatchRemapTable[LoadTransposeMatrixfARB_remap_index]
 #define _gloffset_MultTransposeMatrixdARB driDispatchRemapTable[MultTransposeMatrixdARB_remap_index]
@@ -1233,6 +1244,13 @@
 #define _gloffset_IsEnabledIndexedEXT driDispatchRemapTable[IsEnabledIndexedEXT_remap_index]
 #define _gloffset_BeginConditionalRenderNV driDispatchRemapTable[BeginConditionalRenderNV_remap_index]
 #define _gloffset_EndConditionalRenderNV driDispatchRemapTable[EndConditionalRenderNV_remap_index]
+#define _gloffset_BeginTransformFeedbackEXT driDispatchRemapTable[BeginTransformFeedbackEXT_remap_index]
+#define _gloffset_BindBufferBaseEXT driDispatchRemapTable[BindBufferBaseEXT_remap_index]
+#define _gloffset_BindBufferOffsetEXT driDispatchRemapTable[BindBufferOffsetEXT_remap_index]
+#define _gloffset_BindBufferRangeEXT driDispatchRemapTable[BindBufferRangeEXT_remap_index]
+#define _gloffset_EndTransformFeedbackEXT driDispatchRemapTable[EndTransformFeedbackEXT_remap_index]
+#define _gloffset_GetTransformFeedbackVaryingEXT driDispatchRemapTable[GetTransformFeedbackVaryingEXT_remap_index]
+#define _gloffset_TransformFeedbackVaryingsEXT driDispatchRemapTable[TransformFeedbackVaryingsEXT_remap_index]
 #define _gloffset_ProvokingVertexEXT driDispatchRemapTable[ProvokingVertexEXT_remap_index]
 #define _gloffset_GetTexParameterPointervAPPLE driDispatchRemapTable[GetTexParameterPointervAPPLE_remap_index]
 #define _gloffset_TextureRangeAPPLE driDispatchRemapTable[TextureRangeAPPLE_remap_index]
diff --git a/src/mesa/glapi/glapitable.h b/src/mesa/glapi/glapitable.h
index 149ff3f3c4e..faf274f2704 100644
--- a/src/mesa/glapi/glapitable.h
+++ b/src/mesa/glapi/glapitable.h
@@ -470,384 +470,393 @@ struct _glapi_table
    void (GLAPIENTRYP UniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 427 */
    void (GLAPIENTRYP UniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 428 */
    void (GLAPIENTRYP UniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 429 */
-   void (GLAPIENTRYP LoadTransposeMatrixdARB)(const GLdouble * m); /* 430 */
-   void (GLAPIENTRYP LoadTransposeMatrixfARB)(const GLfloat * m); /* 431 */
-   void (GLAPIENTRYP MultTransposeMatrixdARB)(const GLdouble * m); /* 432 */
-   void (GLAPIENTRYP MultTransposeMatrixfARB)(const GLfloat * m); /* 433 */
-   void (GLAPIENTRYP SampleCoverageARB)(GLclampf value, GLboolean invert); /* 434 */
-   void (GLAPIENTRYP CompressedTexImage1DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data); /* 435 */
-   void (GLAPIENTRYP CompressedTexImage2DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data); /* 436 */
-   void (GLAPIENTRYP CompressedTexImage3DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data); /* 437 */
-   void (GLAPIENTRYP CompressedTexSubImage1DARB)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data); /* 438 */
-   void (GLAPIENTRYP CompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data); /* 439 */
-   void (GLAPIENTRYP CompressedTexSubImage3DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data); /* 440 */
-   void (GLAPIENTRYP GetCompressedTexImageARB)(GLenum target, GLint level, GLvoid * img); /* 441 */
-   void (GLAPIENTRYP DisableVertexAttribArrayARB)(GLuint index); /* 442 */
-   void (GLAPIENTRYP EnableVertexAttribArrayARB)(GLuint index); /* 443 */
-   void (GLAPIENTRYP GetProgramEnvParameterdvARB)(GLenum target, GLuint index, GLdouble * params); /* 444 */
-   void (GLAPIENTRYP GetProgramEnvParameterfvARB)(GLenum target, GLuint index, GLfloat * params); /* 445 */
-   void (GLAPIENTRYP GetProgramLocalParameterdvARB)(GLenum target, GLuint index, GLdouble * params); /* 446 */
-   void (GLAPIENTRYP GetProgramLocalParameterfvARB)(GLenum target, GLuint index, GLfloat * params); /* 447 */
-   void (GLAPIENTRYP GetProgramStringARB)(GLenum target, GLenum pname, GLvoid * string); /* 448 */
-   void (GLAPIENTRYP GetProgramivARB)(GLenum target, GLenum pname, GLint * params); /* 449 */
-   void (GLAPIENTRYP GetVertexAttribdvARB)(GLuint index, GLenum pname, GLdouble * params); /* 450 */
-   void (GLAPIENTRYP GetVertexAttribfvARB)(GLuint index, GLenum pname, GLfloat * params); /* 451 */
-   void (GLAPIENTRYP GetVertexAttribivARB)(GLuint index, GLenum pname, GLint * params); /* 452 */
-   void (GLAPIENTRYP ProgramEnvParameter4dARB)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 453 */
-   void (GLAPIENTRYP ProgramEnvParameter4dvARB)(GLenum target, GLuint index, const GLdouble * params); /* 454 */
-   void (GLAPIENTRYP ProgramEnvParameter4fARB)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 455 */
-   void (GLAPIENTRYP ProgramEnvParameter4fvARB)(GLenum target, GLuint index, const GLfloat * params); /* 456 */
-   void (GLAPIENTRYP ProgramLocalParameter4dARB)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 457 */
-   void (GLAPIENTRYP ProgramLocalParameter4dvARB)(GLenum target, GLuint index, const GLdouble * params); /* 458 */
-   void (GLAPIENTRYP ProgramLocalParameter4fARB)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 459 */
-   void (GLAPIENTRYP ProgramLocalParameter4fvARB)(GLenum target, GLuint index, const GLfloat * params); /* 460 */
-   void (GLAPIENTRYP ProgramStringARB)(GLenum target, GLenum format, GLsizei len, const GLvoid * string); /* 461 */
-   void (GLAPIENTRYP VertexAttrib1dARB)(GLuint index, GLdouble x); /* 462 */
-   void (GLAPIENTRYP VertexAttrib1dvARB)(GLuint index, const GLdouble * v); /* 463 */
-   void (GLAPIENTRYP VertexAttrib1fARB)(GLuint index, GLfloat x); /* 464 */
-   void (GLAPIENTRYP VertexAttrib1fvARB)(GLuint index, const GLfloat * v); /* 465 */
-   void (GLAPIENTRYP VertexAttrib1sARB)(GLuint index, GLshort x); /* 466 */
-   void (GLAPIENTRYP VertexAttrib1svARB)(GLuint index, const GLshort * v); /* 467 */
-   void (GLAPIENTRYP VertexAttrib2dARB)(GLuint index, GLdouble x, GLdouble y); /* 468 */
-   void (GLAPIENTRYP VertexAttrib2dvARB)(GLuint index, const GLdouble * v); /* 469 */
-   void (GLAPIENTRYP VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y); /* 470 */
-   void (GLAPIENTRYP VertexAttrib2fvARB)(GLuint index, const GLfloat * v); /* 471 */
-   void (GLAPIENTRYP VertexAttrib2sARB)(GLuint index, GLshort x, GLshort y); /* 472 */
-   void (GLAPIENTRYP VertexAttrib2svARB)(GLuint index, const GLshort * v); /* 473 */
-   void (GLAPIENTRYP VertexAttrib3dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 474 */
-   void (GLAPIENTRYP VertexAttrib3dvARB)(GLuint index, const GLdouble * v); /* 475 */
-   void (GLAPIENTRYP VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 476 */
-   void (GLAPIENTRYP VertexAttrib3fvARB)(GLuint index, const GLfloat * v); /* 477 */
-   void (GLAPIENTRYP VertexAttrib3sARB)(GLuint index, GLshort x, GLshort y, GLshort z); /* 478 */
-   void (GLAPIENTRYP VertexAttrib3svARB)(GLuint index, const GLshort * v); /* 479 */
-   void (GLAPIENTRYP VertexAttrib4NbvARB)(GLuint index, const GLbyte * v); /* 480 */
-   void (GLAPIENTRYP VertexAttrib4NivARB)(GLuint index, const GLint * v); /* 481 */
-   void (GLAPIENTRYP VertexAttrib4NsvARB)(GLuint index, const GLshort * v); /* 482 */
-   void (GLAPIENTRYP VertexAttrib4NubARB)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 483 */
-   void (GLAPIENTRYP VertexAttrib4NubvARB)(GLuint index, const GLubyte * v); /* 484 */
-   void (GLAPIENTRYP VertexAttrib4NuivARB)(GLuint index, const GLuint * v); /* 485 */
-   void (GLAPIENTRYP VertexAttrib4NusvARB)(GLuint index, const GLushort * v); /* 486 */
-   void (GLAPIENTRYP VertexAttrib4bvARB)(GLuint index, const GLbyte * v); /* 487 */
-   void (GLAPIENTRYP VertexAttrib4dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 488 */
-   void (GLAPIENTRYP VertexAttrib4dvARB)(GLuint index, const GLdouble * v); /* 489 */
-   void (GLAPIENTRYP VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 490 */
-   void (GLAPIENTRYP VertexAttrib4fvARB)(GLuint index, const GLfloat * v); /* 491 */
-   void (GLAPIENTRYP VertexAttrib4ivARB)(GLuint index, const GLint * v); /* 492 */
-   void (GLAPIENTRYP VertexAttrib4sARB)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 493 */
-   void (GLAPIENTRYP VertexAttrib4svARB)(GLuint index, const GLshort * v); /* 494 */
-   void (GLAPIENTRYP VertexAttrib4ubvARB)(GLuint index, const GLubyte * v); /* 495 */
-   void (GLAPIENTRYP VertexAttrib4uivARB)(GLuint index, const GLuint * v); /* 496 */
-   void (GLAPIENTRYP VertexAttrib4usvARB)(GLuint index, const GLushort * v); /* 497 */
-   void (GLAPIENTRYP VertexAttribPointerARB)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer); /* 498 */
-   void (GLAPIENTRYP BindBufferARB)(GLenum target, GLuint buffer); /* 499 */
-   void (GLAPIENTRYP BufferDataARB)(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage); /* 500 */
-   void (GLAPIENTRYP BufferSubDataARB)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data); /* 501 */
-   void (GLAPIENTRYP DeleteBuffersARB)(GLsizei n, const GLuint * buffer); /* 502 */
-   void (GLAPIENTRYP GenBuffersARB)(GLsizei n, GLuint * buffer); /* 503 */
-   void (GLAPIENTRYP GetBufferParameterivARB)(GLenum target, GLenum pname, GLint * params); /* 504 */
-   void (GLAPIENTRYP GetBufferPointervARB)(GLenum target, GLenum pname, GLvoid ** params); /* 505 */
-   void (GLAPIENTRYP GetBufferSubDataARB)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data); /* 506 */
-   GLboolean (GLAPIENTRYP IsBufferARB)(GLuint buffer); /* 507 */
-   GLvoid * (GLAPIENTRYP MapBufferARB)(GLenum target, GLenum access); /* 508 */
-   GLboolean (GLAPIENTRYP UnmapBufferARB)(GLenum target); /* 509 */
-   void (GLAPIENTRYP BeginQueryARB)(GLenum target, GLuint id); /* 510 */
-   void (GLAPIENTRYP DeleteQueriesARB)(GLsizei n, const GLuint * ids); /* 511 */
-   void (GLAPIENTRYP EndQueryARB)(GLenum target); /* 512 */
-   void (GLAPIENTRYP GenQueriesARB)(GLsizei n, GLuint * ids); /* 513 */
-   void (GLAPIENTRYP GetQueryObjectivARB)(GLuint id, GLenum pname, GLint * params); /* 514 */
-   void (GLAPIENTRYP GetQueryObjectuivARB)(GLuint id, GLenum pname, GLuint * params); /* 515 */
-   void (GLAPIENTRYP GetQueryivARB)(GLenum target, GLenum pname, GLint * params); /* 516 */
-   GLboolean (GLAPIENTRYP IsQueryARB)(GLuint id); /* 517 */
-   void (GLAPIENTRYP AttachObjectARB)(GLhandleARB containerObj, GLhandleARB obj); /* 518 */
-   void (GLAPIENTRYP CompileShaderARB)(GLhandleARB shader); /* 519 */
-   GLhandleARB (GLAPIENTRYP CreateProgramObjectARB)(void); /* 520 */
-   GLhandleARB (GLAPIENTRYP CreateShaderObjectARB)(GLenum shaderType); /* 521 */
-   void (GLAPIENTRYP DeleteObjectARB)(GLhandleARB obj); /* 522 */
-   void (GLAPIENTRYP DetachObjectARB)(GLhandleARB containerObj, GLhandleARB attachedObj); /* 523 */
-   void (GLAPIENTRYP GetActiveUniformARB)(GLhandleARB program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name); /* 524 */
-   void (GLAPIENTRYP GetAttachedObjectsARB)(GLhandleARB containerObj, GLsizei maxLength, GLsizei * length, GLhandleARB * infoLog); /* 525 */
-   GLhandleARB (GLAPIENTRYP GetHandleARB)(GLenum pname); /* 526 */
-   void (GLAPIENTRYP GetInfoLogARB)(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog); /* 527 */
-   void (GLAPIENTRYP GetObjectParameterfvARB)(GLhandleARB obj, GLenum pname, GLfloat * params); /* 528 */
-   void (GLAPIENTRYP GetObjectParameterivARB)(GLhandleARB obj, GLenum pname, GLint * params); /* 529 */
-   void (GLAPIENTRYP GetShaderSourceARB)(GLhandleARB shader, GLsizei bufSize, GLsizei * length, GLcharARB * source); /* 530 */
-   GLint (GLAPIENTRYP GetUniformLocationARB)(GLhandleARB program, const GLcharARB * name); /* 531 */
-   void (GLAPIENTRYP GetUniformfvARB)(GLhandleARB program, GLint location, GLfloat * params); /* 532 */
-   void (GLAPIENTRYP GetUniformivARB)(GLhandleARB program, GLint location, GLint * params); /* 533 */
-   void (GLAPIENTRYP LinkProgramARB)(GLhandleARB program); /* 534 */
-   void (GLAPIENTRYP ShaderSourceARB)(GLhandleARB shader, GLsizei count, const GLcharARB ** string, const GLint * length); /* 535 */
-   void (GLAPIENTRYP Uniform1fARB)(GLint location, GLfloat v0); /* 536 */
-   void (GLAPIENTRYP Uniform1fvARB)(GLint location, GLsizei count, const GLfloat * value); /* 537 */
-   void (GLAPIENTRYP Uniform1iARB)(GLint location, GLint v0); /* 538 */
-   void (GLAPIENTRYP Uniform1ivARB)(GLint location, GLsizei count, const GLint * value); /* 539 */
-   void (GLAPIENTRYP Uniform2fARB)(GLint location, GLfloat v0, GLfloat v1); /* 540 */
-   void (GLAPIENTRYP Uniform2fvARB)(GLint location, GLsizei count, const GLfloat * value); /* 541 */
-   void (GLAPIENTRYP Uniform2iARB)(GLint location, GLint v0, GLint v1); /* 542 */
-   void (GLAPIENTRYP Uniform2ivARB)(GLint location, GLsizei count, const GLint * value); /* 543 */
-   void (GLAPIENTRYP Uniform3fARB)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); /* 544 */
-   void (GLAPIENTRYP Uniform3fvARB)(GLint location, GLsizei count, const GLfloat * value); /* 545 */
-   void (GLAPIENTRYP Uniform3iARB)(GLint location, GLint v0, GLint v1, GLint v2); /* 546 */
-   void (GLAPIENTRYP Uniform3ivARB)(GLint location, GLsizei count, const GLint * value); /* 547 */
-   void (GLAPIENTRYP Uniform4fARB)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); /* 548 */
-   void (GLAPIENTRYP Uniform4fvARB)(GLint location, GLsizei count, const GLfloat * value); /* 549 */
-   void (GLAPIENTRYP Uniform4iARB)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); /* 550 */
-   void (GLAPIENTRYP Uniform4ivARB)(GLint location, GLsizei count, const GLint * value); /* 551 */
-   void (GLAPIENTRYP UniformMatrix2fvARB)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 552 */
-   void (GLAPIENTRYP UniformMatrix3fvARB)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 553 */
-   void (GLAPIENTRYP UniformMatrix4fvARB)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 554 */
-   void (GLAPIENTRYP UseProgramObjectARB)(GLhandleARB program); /* 555 */
-   void (GLAPIENTRYP ValidateProgramARB)(GLhandleARB program); /* 556 */
-   void (GLAPIENTRYP BindAttribLocationARB)(GLhandleARB program, GLuint index, const GLcharARB * name); /* 557 */
-   void (GLAPIENTRYP GetActiveAttribARB)(GLhandleARB program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name); /* 558 */
-   GLint (GLAPIENTRYP GetAttribLocationARB)(GLhandleARB program, const GLcharARB * name); /* 559 */
-   void (GLAPIENTRYP DrawBuffersARB)(GLsizei n, const GLenum * bufs); /* 560 */
-   void (GLAPIENTRYP RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); /* 561 */
-   void (GLAPIENTRYP FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length); /* 562 */
-   GLvoid * (GLAPIENTRYP MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); /* 563 */
-   void (GLAPIENTRYP BindVertexArray)(GLuint array); /* 564 */
-   void (GLAPIENTRYP GenVertexArrays)(GLsizei n, GLuint * arrays); /* 565 */
-   void (GLAPIENTRYP CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); /* 566 */
-   GLenum (GLAPIENTRYP ClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); /* 567 */
-   void (GLAPIENTRYP DeleteSync)(GLsync sync); /* 568 */
-   GLsync (GLAPIENTRYP FenceSync)(GLenum condition, GLbitfield flags); /* 569 */
-   void (GLAPIENTRYP GetInteger64v)(GLenum pname, GLint64 * params); /* 570 */
-   void (GLAPIENTRYP GetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values); /* 571 */
-   GLboolean (GLAPIENTRYP IsSync)(GLsync sync); /* 572 */
-   void (GLAPIENTRYP WaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); /* 573 */
-   void (GLAPIENTRYP DrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex); /* 574 */
-   void (GLAPIENTRYP DrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex); /* 575 */
-   void (GLAPIENTRYP MultiDrawElementsBaseVertex)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount, const GLint * basevertex); /* 576 */
-   void (GLAPIENTRYP PolygonOffsetEXT)(GLfloat factor, GLfloat bias); /* 577 */
-   void (GLAPIENTRYP GetPixelTexGenParameterfvSGIS)(GLenum pname, GLfloat * params); /* 578 */
-   void (GLAPIENTRYP GetPixelTexGenParameterivSGIS)(GLenum pname, GLint * params); /* 579 */
-   void (GLAPIENTRYP PixelTexGenParameterfSGIS)(GLenum pname, GLfloat param); /* 580 */
-   void (GLAPIENTRYP PixelTexGenParameterfvSGIS)(GLenum pname, const GLfloat * params); /* 581 */
-   void (GLAPIENTRYP PixelTexGenParameteriSGIS)(GLenum pname, GLint param); /* 582 */
-   void (GLAPIENTRYP PixelTexGenParameterivSGIS)(GLenum pname, const GLint * params); /* 583 */
-   void (GLAPIENTRYP SampleMaskSGIS)(GLclampf value, GLboolean invert); /* 584 */
-   void (GLAPIENTRYP SamplePatternSGIS)(GLenum pattern); /* 585 */
-   void (GLAPIENTRYP ColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 586 */
-   void (GLAPIENTRYP EdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean * pointer); /* 587 */
-   void (GLAPIENTRYP IndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 588 */
-   void (GLAPIENTRYP NormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 589 */
-   void (GLAPIENTRYP TexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 590 */
-   void (GLAPIENTRYP VertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 591 */
-   void (GLAPIENTRYP PointParameterfEXT)(GLenum pname, GLfloat param); /* 592 */
-   void (GLAPIENTRYP PointParameterfvEXT)(GLenum pname, const GLfloat * params); /* 593 */
-   void (GLAPIENTRYP LockArraysEXT)(GLint first, GLsizei count); /* 594 */
-   void (GLAPIENTRYP UnlockArraysEXT)(void); /* 595 */
-   void (GLAPIENTRYP CullParameterdvEXT)(GLenum pname, GLdouble * params); /* 596 */
-   void (GLAPIENTRYP CullParameterfvEXT)(GLenum pname, GLfloat * params); /* 597 */
-   void (GLAPIENTRYP SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue); /* 598 */
-   void (GLAPIENTRYP SecondaryColor3bvEXT)(const GLbyte * v); /* 599 */
-   void (GLAPIENTRYP SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue); /* 600 */
-   void (GLAPIENTRYP SecondaryColor3dvEXT)(const GLdouble * v); /* 601 */
-   void (GLAPIENTRYP SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue); /* 602 */
-   void (GLAPIENTRYP SecondaryColor3fvEXT)(const GLfloat * v); /* 603 */
-   void (GLAPIENTRYP SecondaryColor3iEXT)(GLint red, GLint green, GLint blue); /* 604 */
-   void (GLAPIENTRYP SecondaryColor3ivEXT)(const GLint * v); /* 605 */
-   void (GLAPIENTRYP SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue); /* 606 */
-   void (GLAPIENTRYP SecondaryColor3svEXT)(const GLshort * v); /* 607 */
-   void (GLAPIENTRYP SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue); /* 608 */
-   void (GLAPIENTRYP SecondaryColor3ubvEXT)(const GLubyte * v); /* 609 */
-   void (GLAPIENTRYP SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue); /* 610 */
-   void (GLAPIENTRYP SecondaryColor3uivEXT)(const GLuint * v); /* 611 */
-   void (GLAPIENTRYP SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue); /* 612 */
-   void (GLAPIENTRYP SecondaryColor3usvEXT)(const GLushort * v); /* 613 */
-   void (GLAPIENTRYP SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 614 */
-   void (GLAPIENTRYP MultiDrawArraysEXT)(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount); /* 615 */
-   void (GLAPIENTRYP MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); /* 616 */
-   void (GLAPIENTRYP FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 617 */
-   void (GLAPIENTRYP FogCoorddEXT)(GLdouble coord); /* 618 */
-   void (GLAPIENTRYP FogCoorddvEXT)(const GLdouble * coord); /* 619 */
-   void (GLAPIENTRYP FogCoordfEXT)(GLfloat coord); /* 620 */
-   void (GLAPIENTRYP FogCoordfvEXT)(const GLfloat * coord); /* 621 */
-   void (GLAPIENTRYP PixelTexGenSGIX)(GLenum mode); /* 622 */
-   void (GLAPIENTRYP BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); /* 623 */
-   void (GLAPIENTRYP FlushVertexArrayRangeNV)(void); /* 624 */
-   void (GLAPIENTRYP VertexArrayRangeNV)(GLsizei length, const GLvoid * pointer); /* 625 */
-   void (GLAPIENTRYP CombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 626 */
-   void (GLAPIENTRYP CombinerOutputNV)(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); /* 627 */
-   void (GLAPIENTRYP CombinerParameterfNV)(GLenum pname, GLfloat param); /* 628 */
-   void (GLAPIENTRYP CombinerParameterfvNV)(GLenum pname, const GLfloat * params); /* 629 */
-   void (GLAPIENTRYP CombinerParameteriNV)(GLenum pname, GLint param); /* 630 */
-   void (GLAPIENTRYP CombinerParameterivNV)(GLenum pname, const GLint * params); /* 631 */
-   void (GLAPIENTRYP FinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 632 */
-   void (GLAPIENTRYP GetCombinerInputParameterfvNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params); /* 633 */
-   void (GLAPIENTRYP GetCombinerInputParameterivNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params); /* 634 */
-   void (GLAPIENTRYP GetCombinerOutputParameterfvNV)(GLenum stage, GLenum portion, GLenum pname, GLfloat * params); /* 635 */
-   void (GLAPIENTRYP GetCombinerOutputParameterivNV)(GLenum stage, GLenum portion, GLenum pname, GLint * params); /* 636 */
-   void (GLAPIENTRYP GetFinalCombinerInputParameterfvNV)(GLenum variable, GLenum pname, GLfloat * params); /* 637 */
-   void (GLAPIENTRYP GetFinalCombinerInputParameterivNV)(GLenum variable, GLenum pname, GLint * params); /* 638 */
-   void (GLAPIENTRYP ResizeBuffersMESA)(void); /* 639 */
-   void (GLAPIENTRYP WindowPos2dMESA)(GLdouble x, GLdouble y); /* 640 */
-   void (GLAPIENTRYP WindowPos2dvMESA)(const GLdouble * v); /* 641 */
-   void (GLAPIENTRYP WindowPos2fMESA)(GLfloat x, GLfloat y); /* 642 */
-   void (GLAPIENTRYP WindowPos2fvMESA)(const GLfloat * v); /* 643 */
-   void (GLAPIENTRYP WindowPos2iMESA)(GLint x, GLint y); /* 644 */
-   void (GLAPIENTRYP WindowPos2ivMESA)(const GLint * v); /* 645 */
-   void (GLAPIENTRYP WindowPos2sMESA)(GLshort x, GLshort y); /* 646 */
-   void (GLAPIENTRYP WindowPos2svMESA)(const GLshort * v); /* 647 */
-   void (GLAPIENTRYP WindowPos3dMESA)(GLdouble x, GLdouble y, GLdouble z); /* 648 */
-   void (GLAPIENTRYP WindowPos3dvMESA)(const GLdouble * v); /* 649 */
-   void (GLAPIENTRYP WindowPos3fMESA)(GLfloat x, GLfloat y, GLfloat z); /* 650 */
-   void (GLAPIENTRYP WindowPos3fvMESA)(const GLfloat * v); /* 651 */
-   void (GLAPIENTRYP WindowPos3iMESA)(GLint x, GLint y, GLint z); /* 652 */
-   void (GLAPIENTRYP WindowPos3ivMESA)(const GLint * v); /* 653 */
-   void (GLAPIENTRYP WindowPos3sMESA)(GLshort x, GLshort y, GLshort z); /* 654 */
-   void (GLAPIENTRYP WindowPos3svMESA)(const GLshort * v); /* 655 */
-   void (GLAPIENTRYP WindowPos4dMESA)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 656 */
-   void (GLAPIENTRYP WindowPos4dvMESA)(const GLdouble * v); /* 657 */
-   void (GLAPIENTRYP WindowPos4fMESA)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 658 */
-   void (GLAPIENTRYP WindowPos4fvMESA)(const GLfloat * v); /* 659 */
-   void (GLAPIENTRYP WindowPos4iMESA)(GLint x, GLint y, GLint z, GLint w); /* 660 */
-   void (GLAPIENTRYP WindowPos4ivMESA)(const GLint * v); /* 661 */
-   void (GLAPIENTRYP WindowPos4sMESA)(GLshort x, GLshort y, GLshort z, GLshort w); /* 662 */
-   void (GLAPIENTRYP WindowPos4svMESA)(const GLshort * v); /* 663 */
-   void (GLAPIENTRYP MultiModeDrawArraysIBM)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride); /* 664 */
-   void (GLAPIENTRYP MultiModeDrawElementsIBM)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride); /* 665 */
-   void (GLAPIENTRYP DeleteFencesNV)(GLsizei n, const GLuint * fences); /* 666 */
-   void (GLAPIENTRYP FinishFenceNV)(GLuint fence); /* 667 */
-   void (GLAPIENTRYP GenFencesNV)(GLsizei n, GLuint * fences); /* 668 */
-   void (GLAPIENTRYP GetFenceivNV)(GLuint fence, GLenum pname, GLint * params); /* 669 */
-   GLboolean (GLAPIENTRYP IsFenceNV)(GLuint fence); /* 670 */
-   void (GLAPIENTRYP SetFenceNV)(GLuint fence, GLenum condition); /* 671 */
-   GLboolean (GLAPIENTRYP TestFenceNV)(GLuint fence); /* 672 */
-   GLboolean (GLAPIENTRYP AreProgramsResidentNV)(GLsizei n, const GLuint * ids, GLboolean * residences); /* 673 */
-   void (GLAPIENTRYP BindProgramNV)(GLenum target, GLuint program); /* 674 */
-   void (GLAPIENTRYP DeleteProgramsNV)(GLsizei n, const GLuint * programs); /* 675 */
-   void (GLAPIENTRYP ExecuteProgramNV)(GLenum target, GLuint id, const GLfloat * params); /* 676 */
-   void (GLAPIENTRYP GenProgramsNV)(GLsizei n, GLuint * programs); /* 677 */
-   void (GLAPIENTRYP GetProgramParameterdvNV)(GLenum target, GLuint index, GLenum pname, GLdouble * params); /* 678 */
-   void (GLAPIENTRYP GetProgramParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat * params); /* 679 */
-   void (GLAPIENTRYP GetProgramStringNV)(GLuint id, GLenum pname, GLubyte * program); /* 680 */
-   void (GLAPIENTRYP GetProgramivNV)(GLuint id, GLenum pname, GLint * params); /* 681 */
-   void (GLAPIENTRYP GetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint * params); /* 682 */
-   void (GLAPIENTRYP GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer); /* 683 */
-   void (GLAPIENTRYP GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params); /* 684 */
-   void (GLAPIENTRYP GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params); /* 685 */
-   void (GLAPIENTRYP GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params); /* 686 */
-   GLboolean (GLAPIENTRYP IsProgramNV)(GLuint program); /* 687 */
-   void (GLAPIENTRYP LoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte * program); /* 688 */
-   void (GLAPIENTRYP ProgramParameters4dvNV)(GLenum target, GLuint index, GLuint num, const GLdouble * params); /* 689 */
-   void (GLAPIENTRYP ProgramParameters4fvNV)(GLenum target, GLuint index, GLuint num, const GLfloat * params); /* 690 */
-   void (GLAPIENTRYP RequestResidentProgramsNV)(GLsizei n, const GLuint * ids); /* 691 */
-   void (GLAPIENTRYP TrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform); /* 692 */
-   void (GLAPIENTRYP VertexAttrib1dNV)(GLuint index, GLdouble x); /* 693 */
-   void (GLAPIENTRYP VertexAttrib1dvNV)(GLuint index, const GLdouble * v); /* 694 */
-   void (GLAPIENTRYP VertexAttrib1fNV)(GLuint index, GLfloat x); /* 695 */
-   void (GLAPIENTRYP VertexAttrib1fvNV)(GLuint index, const GLfloat * v); /* 696 */
-   void (GLAPIENTRYP VertexAttrib1sNV)(GLuint index, GLshort x); /* 697 */
-   void (GLAPIENTRYP VertexAttrib1svNV)(GLuint index, const GLshort * v); /* 698 */
-   void (GLAPIENTRYP VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y); /* 699 */
-   void (GLAPIENTRYP VertexAttrib2dvNV)(GLuint index, const GLdouble * v); /* 700 */
-   void (GLAPIENTRYP VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y); /* 701 */
-   void (GLAPIENTRYP VertexAttrib2fvNV)(GLuint index, const GLfloat * v); /* 702 */
-   void (GLAPIENTRYP VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y); /* 703 */
-   void (GLAPIENTRYP VertexAttrib2svNV)(GLuint index, const GLshort * v); /* 704 */
-   void (GLAPIENTRYP VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 705 */
-   void (GLAPIENTRYP VertexAttrib3dvNV)(GLuint index, const GLdouble * v); /* 706 */
-   void (GLAPIENTRYP VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 707 */
-   void (GLAPIENTRYP VertexAttrib3fvNV)(GLuint index, const GLfloat * v); /* 708 */
-   void (GLAPIENTRYP VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z); /* 709 */
-   void (GLAPIENTRYP VertexAttrib3svNV)(GLuint index, const GLshort * v); /* 710 */
-   void (GLAPIENTRYP VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 711 */
-   void (GLAPIENTRYP VertexAttrib4dvNV)(GLuint index, const GLdouble * v); /* 712 */
-   void (GLAPIENTRYP VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 713 */
-   void (GLAPIENTRYP VertexAttrib4fvNV)(GLuint index, const GLfloat * v); /* 714 */
-   void (GLAPIENTRYP VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 715 */
-   void (GLAPIENTRYP VertexAttrib4svNV)(GLuint index, const GLshort * v); /* 716 */
-   void (GLAPIENTRYP VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 717 */
-   void (GLAPIENTRYP VertexAttrib4ubvNV)(GLuint index, const GLubyte * v); /* 718 */
-   void (GLAPIENTRYP VertexAttribPointerNV)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 719 */
-   void (GLAPIENTRYP VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 720 */
-   void (GLAPIENTRYP VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 721 */
-   void (GLAPIENTRYP VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort * v); /* 722 */
-   void (GLAPIENTRYP VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 723 */
-   void (GLAPIENTRYP VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 724 */
-   void (GLAPIENTRYP VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort * v); /* 725 */
-   void (GLAPIENTRYP VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 726 */
-   void (GLAPIENTRYP VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 727 */
-   void (GLAPIENTRYP VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort * v); /* 728 */
-   void (GLAPIENTRYP VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 729 */
-   void (GLAPIENTRYP VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 730 */
-   void (GLAPIENTRYP VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort * v); /* 731 */
-   void (GLAPIENTRYP VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte * v); /* 732 */
-   void (GLAPIENTRYP GetTexBumpParameterfvATI)(GLenum pname, GLfloat * param); /* 733 */
-   void (GLAPIENTRYP GetTexBumpParameterivATI)(GLenum pname, GLint * param); /* 734 */
-   void (GLAPIENTRYP TexBumpParameterfvATI)(GLenum pname, const GLfloat * param); /* 735 */
-   void (GLAPIENTRYP TexBumpParameterivATI)(GLenum pname, const GLint * param); /* 736 */
-   void (GLAPIENTRYP AlphaFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 737 */
-   void (GLAPIENTRYP AlphaFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 738 */
-   void (GLAPIENTRYP AlphaFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 739 */
-   void (GLAPIENTRYP BeginFragmentShaderATI)(void); /* 740 */
-   void (GLAPIENTRYP BindFragmentShaderATI)(GLuint id); /* 741 */
-   void (GLAPIENTRYP ColorFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 742 */
-   void (GLAPIENTRYP ColorFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 743 */
-   void (GLAPIENTRYP ColorFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 744 */
-   void (GLAPIENTRYP DeleteFragmentShaderATI)(GLuint id); /* 745 */
-   void (GLAPIENTRYP EndFragmentShaderATI)(void); /* 746 */
-   GLuint (GLAPIENTRYP GenFragmentShadersATI)(GLuint range); /* 747 */
-   void (GLAPIENTRYP PassTexCoordATI)(GLuint dst, GLuint coord, GLenum swizzle); /* 748 */
-   void (GLAPIENTRYP SampleMapATI)(GLuint dst, GLuint interp, GLenum swizzle); /* 749 */
-   void (GLAPIENTRYP SetFragmentShaderConstantATI)(GLuint dst, const GLfloat * value); /* 750 */
-   void (GLAPIENTRYP PointParameteriNV)(GLenum pname, GLint param); /* 751 */
-   void (GLAPIENTRYP PointParameterivNV)(GLenum pname, const GLint * params); /* 752 */
-   void (GLAPIENTRYP ActiveStencilFaceEXT)(GLenum face); /* 753 */
-   void (GLAPIENTRYP BindVertexArrayAPPLE)(GLuint array); /* 754 */
-   void (GLAPIENTRYP DeleteVertexArraysAPPLE)(GLsizei n, const GLuint * arrays); /* 755 */
-   void (GLAPIENTRYP GenVertexArraysAPPLE)(GLsizei n, GLuint * arrays); /* 756 */
-   GLboolean (GLAPIENTRYP IsVertexArrayAPPLE)(GLuint array); /* 757 */
-   void (GLAPIENTRYP GetProgramNamedParameterdvNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params); /* 758 */
-   void (GLAPIENTRYP GetProgramNamedParameterfvNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params); /* 759 */
-   void (GLAPIENTRYP ProgramNamedParameter4dNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 760 */
-   void (GLAPIENTRYP ProgramNamedParameter4dvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v); /* 761 */
-   void (GLAPIENTRYP ProgramNamedParameter4fNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 762 */
-   void (GLAPIENTRYP ProgramNamedParameter4fvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v); /* 763 */
-   void (GLAPIENTRYP DepthBoundsEXT)(GLclampd zmin, GLclampd zmax); /* 764 */
-   void (GLAPIENTRYP BlendEquationSeparateEXT)(GLenum modeRGB, GLenum modeA); /* 765 */
-   void (GLAPIENTRYP BindFramebufferEXT)(GLenum target, GLuint framebuffer); /* 766 */
-   void (GLAPIENTRYP BindRenderbufferEXT)(GLenum target, GLuint renderbuffer); /* 767 */
-   GLenum (GLAPIENTRYP CheckFramebufferStatusEXT)(GLenum target); /* 768 */
-   void (GLAPIENTRYP DeleteFramebuffersEXT)(GLsizei n, const GLuint * framebuffers); /* 769 */
-   void (GLAPIENTRYP DeleteRenderbuffersEXT)(GLsizei n, const GLuint * renderbuffers); /* 770 */
-   void (GLAPIENTRYP FramebufferRenderbufferEXT)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); /* 771 */
-   void (GLAPIENTRYP FramebufferTexture1DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 772 */
-   void (GLAPIENTRYP FramebufferTexture2DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 773 */
-   void (GLAPIENTRYP FramebufferTexture3DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); /* 774 */
-   void (GLAPIENTRYP GenFramebuffersEXT)(GLsizei n, GLuint * framebuffers); /* 775 */
-   void (GLAPIENTRYP GenRenderbuffersEXT)(GLsizei n, GLuint * renderbuffers); /* 776 */
-   void (GLAPIENTRYP GenerateMipmapEXT)(GLenum target); /* 777 */
-   void (GLAPIENTRYP GetFramebufferAttachmentParameterivEXT)(GLenum target, GLenum attachment, GLenum pname, GLint * params); /* 778 */
-   void (GLAPIENTRYP GetRenderbufferParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 779 */
-   GLboolean (GLAPIENTRYP IsFramebufferEXT)(GLuint framebuffer); /* 780 */
-   GLboolean (GLAPIENTRYP IsRenderbufferEXT)(GLuint renderbuffer); /* 781 */
-   void (GLAPIENTRYP RenderbufferStorageEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); /* 782 */
-   void (GLAPIENTRYP BlitFramebufferEXT)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); /* 783 */
-   void (GLAPIENTRYP BufferParameteriAPPLE)(GLenum target, GLenum pname, GLint param); /* 784 */
-   void (GLAPIENTRYP FlushMappedBufferRangeAPPLE)(GLenum target, GLintptr offset, GLsizeiptr size); /* 785 */
-   void (GLAPIENTRYP FramebufferTextureLayerEXT)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); /* 786 */
-   void (GLAPIENTRYP ColorMaskIndexedEXT)(GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a); /* 787 */
-   void (GLAPIENTRYP DisableIndexedEXT)(GLenum target, GLuint index); /* 788 */
-   void (GLAPIENTRYP EnableIndexedEXT)(GLenum target, GLuint index); /* 789 */
-   void (GLAPIENTRYP GetBooleanIndexedvEXT)(GLenum value, GLuint index, GLboolean * data); /* 790 */
-   void (GLAPIENTRYP GetIntegerIndexedvEXT)(GLenum value, GLuint index, GLint * data); /* 791 */
-   GLboolean (GLAPIENTRYP IsEnabledIndexedEXT)(GLenum target, GLuint index); /* 792 */
-   void (GLAPIENTRYP BeginConditionalRenderNV)(GLuint query, GLenum mode); /* 793 */
-   void (GLAPIENTRYP EndConditionalRenderNV)(void); /* 794 */
-   void (GLAPIENTRYP ProvokingVertexEXT)(GLenum mode); /* 795 */
-   void (GLAPIENTRYP GetTexParameterPointervAPPLE)(GLenum target, GLenum pname, GLvoid ** params); /* 796 */
-   void (GLAPIENTRYP TextureRangeAPPLE)(GLenum target, GLsizei length, GLvoid * pointer); /* 797 */
-   void (GLAPIENTRYP GetObjectParameterivAPPLE)(GLenum objectType, GLuint name, GLenum pname, GLint * value); /* 798 */
-   GLenum (GLAPIENTRYP ObjectPurgeableAPPLE)(GLenum objectType, GLuint name, GLenum option); /* 799 */
-   GLenum (GLAPIENTRYP ObjectUnpurgeableAPPLE)(GLenum objectType, GLuint name, GLenum option); /* 800 */
-   void (GLAPIENTRYP StencilFuncSeparateATI)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); /* 801 */
-   void (GLAPIENTRYP ProgramEnvParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 802 */
-   void (GLAPIENTRYP ProgramLocalParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 803 */
-   void (GLAPIENTRYP GetQueryObjecti64vEXT)(GLuint id, GLenum pname, GLint64EXT * params); /* 804 */
-   void (GLAPIENTRYP GetQueryObjectui64vEXT)(GLuint id, GLenum pname, GLuint64EXT * params); /* 805 */
-   void (GLAPIENTRYP EGLImageTargetRenderbufferStorageOES)(GLenum target, GLvoid * writeOffset); /* 806 */
-   void (GLAPIENTRYP EGLImageTargetTexture2DOES)(GLenum target, GLvoid * writeOffset); /* 807 */
+   void (GLAPIENTRYP DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei primcount); /* 430 */
+   void (GLAPIENTRYP DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount); /* 431 */
+   void (GLAPIENTRYP LoadTransposeMatrixdARB)(const GLdouble * m); /* 432 */
+   void (GLAPIENTRYP LoadTransposeMatrixfARB)(const GLfloat * m); /* 433 */
+   void (GLAPIENTRYP MultTransposeMatrixdARB)(const GLdouble * m); /* 434 */
+   void (GLAPIENTRYP MultTransposeMatrixfARB)(const GLfloat * m); /* 435 */
+   void (GLAPIENTRYP SampleCoverageARB)(GLclampf value, GLboolean invert); /* 436 */
+   void (GLAPIENTRYP CompressedTexImage1DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data); /* 437 */
+   void (GLAPIENTRYP CompressedTexImage2DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data); /* 438 */
+   void (GLAPIENTRYP CompressedTexImage3DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data); /* 439 */
+   void (GLAPIENTRYP CompressedTexSubImage1DARB)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data); /* 440 */
+   void (GLAPIENTRYP CompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data); /* 441 */
+   void (GLAPIENTRYP CompressedTexSubImage3DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data); /* 442 */
+   void (GLAPIENTRYP GetCompressedTexImageARB)(GLenum target, GLint level, GLvoid * img); /* 443 */
+   void (GLAPIENTRYP DisableVertexAttribArrayARB)(GLuint index); /* 444 */
+   void (GLAPIENTRYP EnableVertexAttribArrayARB)(GLuint index); /* 445 */
+   void (GLAPIENTRYP GetProgramEnvParameterdvARB)(GLenum target, GLuint index, GLdouble * params); /* 446 */
+   void (GLAPIENTRYP GetProgramEnvParameterfvARB)(GLenum target, GLuint index, GLfloat * params); /* 447 */
+   void (GLAPIENTRYP GetProgramLocalParameterdvARB)(GLenum target, GLuint index, GLdouble * params); /* 448 */
+   void (GLAPIENTRYP GetProgramLocalParameterfvARB)(GLenum target, GLuint index, GLfloat * params); /* 449 */
+   void (GLAPIENTRYP GetProgramStringARB)(GLenum target, GLenum pname, GLvoid * string); /* 450 */
+   void (GLAPIENTRYP GetProgramivARB)(GLenum target, GLenum pname, GLint * params); /* 451 */
+   void (GLAPIENTRYP GetVertexAttribdvARB)(GLuint index, GLenum pname, GLdouble * params); /* 452 */
+   void (GLAPIENTRYP GetVertexAttribfvARB)(GLuint index, GLenum pname, GLfloat * params); /* 453 */
+   void (GLAPIENTRYP GetVertexAttribivARB)(GLuint index, GLenum pname, GLint * params); /* 454 */
+   void (GLAPIENTRYP ProgramEnvParameter4dARB)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 455 */
+   void (GLAPIENTRYP ProgramEnvParameter4dvARB)(GLenum target, GLuint index, const GLdouble * params); /* 456 */
+   void (GLAPIENTRYP ProgramEnvParameter4fARB)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 457 */
+   void (GLAPIENTRYP ProgramEnvParameter4fvARB)(GLenum target, GLuint index, const GLfloat * params); /* 458 */
+   void (GLAPIENTRYP ProgramLocalParameter4dARB)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 459 */
+   void (GLAPIENTRYP ProgramLocalParameter4dvARB)(GLenum target, GLuint index, const GLdouble * params); /* 460 */
+   void (GLAPIENTRYP ProgramLocalParameter4fARB)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 461 */
+   void (GLAPIENTRYP ProgramLocalParameter4fvARB)(GLenum target, GLuint index, const GLfloat * params); /* 462 */
+   void (GLAPIENTRYP ProgramStringARB)(GLenum target, GLenum format, GLsizei len, const GLvoid * string); /* 463 */
+   void (GLAPIENTRYP VertexAttrib1dARB)(GLuint index, GLdouble x); /* 464 */
+   void (GLAPIENTRYP VertexAttrib1dvARB)(GLuint index, const GLdouble * v); /* 465 */
+   void (GLAPIENTRYP VertexAttrib1fARB)(GLuint index, GLfloat x); /* 466 */
+   void (GLAPIENTRYP VertexAttrib1fvARB)(GLuint index, const GLfloat * v); /* 467 */
+   void (GLAPIENTRYP VertexAttrib1sARB)(GLuint index, GLshort x); /* 468 */
+   void (GLAPIENTRYP VertexAttrib1svARB)(GLuint index, const GLshort * v); /* 469 */
+   void (GLAPIENTRYP VertexAttrib2dARB)(GLuint index, GLdouble x, GLdouble y); /* 470 */
+   void (GLAPIENTRYP VertexAttrib2dvARB)(GLuint index, const GLdouble * v); /* 471 */
+   void (GLAPIENTRYP VertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y); /* 472 */
+   void (GLAPIENTRYP VertexAttrib2fvARB)(GLuint index, const GLfloat * v); /* 473 */
+   void (GLAPIENTRYP VertexAttrib2sARB)(GLuint index, GLshort x, GLshort y); /* 474 */
+   void (GLAPIENTRYP VertexAttrib2svARB)(GLuint index, const GLshort * v); /* 475 */
+   void (GLAPIENTRYP VertexAttrib3dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 476 */
+   void (GLAPIENTRYP VertexAttrib3dvARB)(GLuint index, const GLdouble * v); /* 477 */
+   void (GLAPIENTRYP VertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 478 */
+   void (GLAPIENTRYP VertexAttrib3fvARB)(GLuint index, const GLfloat * v); /* 479 */
+   void (GLAPIENTRYP VertexAttrib3sARB)(GLuint index, GLshort x, GLshort y, GLshort z); /* 480 */
+   void (GLAPIENTRYP VertexAttrib3svARB)(GLuint index, const GLshort * v); /* 481 */
+   void (GLAPIENTRYP VertexAttrib4NbvARB)(GLuint index, const GLbyte * v); /* 482 */
+   void (GLAPIENTRYP VertexAttrib4NivARB)(GLuint index, const GLint * v); /* 483 */
+   void (GLAPIENTRYP VertexAttrib4NsvARB)(GLuint index, const GLshort * v); /* 484 */
+   void (GLAPIENTRYP VertexAttrib4NubARB)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 485 */
+   void (GLAPIENTRYP VertexAttrib4NubvARB)(GLuint index, const GLubyte * v); /* 486 */
+   void (GLAPIENTRYP VertexAttrib4NuivARB)(GLuint index, const GLuint * v); /* 487 */
+   void (GLAPIENTRYP VertexAttrib4NusvARB)(GLuint index, const GLushort * v); /* 488 */
+   void (GLAPIENTRYP VertexAttrib4bvARB)(GLuint index, const GLbyte * v); /* 489 */
+   void (GLAPIENTRYP VertexAttrib4dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 490 */
+   void (GLAPIENTRYP VertexAttrib4dvARB)(GLuint index, const GLdouble * v); /* 491 */
+   void (GLAPIENTRYP VertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 492 */
+   void (GLAPIENTRYP VertexAttrib4fvARB)(GLuint index, const GLfloat * v); /* 493 */
+   void (GLAPIENTRYP VertexAttrib4ivARB)(GLuint index, const GLint * v); /* 494 */
+   void (GLAPIENTRYP VertexAttrib4sARB)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 495 */
+   void (GLAPIENTRYP VertexAttrib4svARB)(GLuint index, const GLshort * v); /* 496 */
+   void (GLAPIENTRYP VertexAttrib4ubvARB)(GLuint index, const GLubyte * v); /* 497 */
+   void (GLAPIENTRYP VertexAttrib4uivARB)(GLuint index, const GLuint * v); /* 498 */
+   void (GLAPIENTRYP VertexAttrib4usvARB)(GLuint index, const GLushort * v); /* 499 */
+   void (GLAPIENTRYP VertexAttribPointerARB)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer); /* 500 */
+   void (GLAPIENTRYP BindBufferARB)(GLenum target, GLuint buffer); /* 501 */
+   void (GLAPIENTRYP BufferDataARB)(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage); /* 502 */
+   void (GLAPIENTRYP BufferSubDataARB)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data); /* 503 */
+   void (GLAPIENTRYP DeleteBuffersARB)(GLsizei n, const GLuint * buffer); /* 504 */
+   void (GLAPIENTRYP GenBuffersARB)(GLsizei n, GLuint * buffer); /* 505 */
+   void (GLAPIENTRYP GetBufferParameterivARB)(GLenum target, GLenum pname, GLint * params); /* 506 */
+   void (GLAPIENTRYP GetBufferPointervARB)(GLenum target, GLenum pname, GLvoid ** params); /* 507 */
+   void (GLAPIENTRYP GetBufferSubDataARB)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data); /* 508 */
+   GLboolean (GLAPIENTRYP IsBufferARB)(GLuint buffer); /* 509 */
+   GLvoid * (GLAPIENTRYP MapBufferARB)(GLenum target, GLenum access); /* 510 */
+   GLboolean (GLAPIENTRYP UnmapBufferARB)(GLenum target); /* 511 */
+   void (GLAPIENTRYP BeginQueryARB)(GLenum target, GLuint id); /* 512 */
+   void (GLAPIENTRYP DeleteQueriesARB)(GLsizei n, const GLuint * ids); /* 513 */
+   void (GLAPIENTRYP EndQueryARB)(GLenum target); /* 514 */
+   void (GLAPIENTRYP GenQueriesARB)(GLsizei n, GLuint * ids); /* 515 */
+   void (GLAPIENTRYP GetQueryObjectivARB)(GLuint id, GLenum pname, GLint * params); /* 516 */
+   void (GLAPIENTRYP GetQueryObjectuivARB)(GLuint id, GLenum pname, GLuint * params); /* 517 */
+   void (GLAPIENTRYP GetQueryivARB)(GLenum target, GLenum pname, GLint * params); /* 518 */
+   GLboolean (GLAPIENTRYP IsQueryARB)(GLuint id); /* 519 */
+   void (GLAPIENTRYP AttachObjectARB)(GLhandleARB containerObj, GLhandleARB obj); /* 520 */
+   void (GLAPIENTRYP CompileShaderARB)(GLhandleARB shader); /* 521 */
+   GLhandleARB (GLAPIENTRYP CreateProgramObjectARB)(void); /* 522 */
+   GLhandleARB (GLAPIENTRYP CreateShaderObjectARB)(GLenum shaderType); /* 523 */
+   void (GLAPIENTRYP DeleteObjectARB)(GLhandleARB obj); /* 524 */
+   void (GLAPIENTRYP DetachObjectARB)(GLhandleARB containerObj, GLhandleARB attachedObj); /* 525 */
+   void (GLAPIENTRYP GetActiveUniformARB)(GLhandleARB program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name); /* 526 */
+   void (GLAPIENTRYP GetAttachedObjectsARB)(GLhandleARB containerObj, GLsizei maxLength, GLsizei * length, GLhandleARB * infoLog); /* 527 */
+   GLhandleARB (GLAPIENTRYP GetHandleARB)(GLenum pname); /* 528 */
+   void (GLAPIENTRYP GetInfoLogARB)(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog); /* 529 */
+   void (GLAPIENTRYP GetObjectParameterfvARB)(GLhandleARB obj, GLenum pname, GLfloat * params); /* 530 */
+   void (GLAPIENTRYP GetObjectParameterivARB)(GLhandleARB obj, GLenum pname, GLint * params); /* 531 */
+   void (GLAPIENTRYP GetShaderSourceARB)(GLhandleARB shader, GLsizei bufSize, GLsizei * length, GLcharARB * source); /* 532 */
+   GLint (GLAPIENTRYP GetUniformLocationARB)(GLhandleARB program, const GLcharARB * name); /* 533 */
+   void (GLAPIENTRYP GetUniformfvARB)(GLhandleARB program, GLint location, GLfloat * params); /* 534 */
+   void (GLAPIENTRYP GetUniformivARB)(GLhandleARB program, GLint location, GLint * params); /* 535 */
+   void (GLAPIENTRYP LinkProgramARB)(GLhandleARB program); /* 536 */
+   void (GLAPIENTRYP ShaderSourceARB)(GLhandleARB shader, GLsizei count, const GLcharARB ** string, const GLint * length); /* 537 */
+   void (GLAPIENTRYP Uniform1fARB)(GLint location, GLfloat v0); /* 538 */
+   void (GLAPIENTRYP Uniform1fvARB)(GLint location, GLsizei count, const GLfloat * value); /* 539 */
+   void (GLAPIENTRYP Uniform1iARB)(GLint location, GLint v0); /* 540 */
+   void (GLAPIENTRYP Uniform1ivARB)(GLint location, GLsizei count, const GLint * value); /* 541 */
+   void (GLAPIENTRYP Uniform2fARB)(GLint location, GLfloat v0, GLfloat v1); /* 542 */
+   void (GLAPIENTRYP Uniform2fvARB)(GLint location, GLsizei count, const GLfloat * value); /* 543 */
+   void (GLAPIENTRYP Uniform2iARB)(GLint location, GLint v0, GLint v1); /* 544 */
+   void (GLAPIENTRYP Uniform2ivARB)(GLint location, GLsizei count, const GLint * value); /* 545 */
+   void (GLAPIENTRYP Uniform3fARB)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); /* 546 */
+   void (GLAPIENTRYP Uniform3fvARB)(GLint location, GLsizei count, const GLfloat * value); /* 547 */
+   void (GLAPIENTRYP Uniform3iARB)(GLint location, GLint v0, GLint v1, GLint v2); /* 548 */
+   void (GLAPIENTRYP Uniform3ivARB)(GLint location, GLsizei count, const GLint * value); /* 549 */
+   void (GLAPIENTRYP Uniform4fARB)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); /* 550 */
+   void (GLAPIENTRYP Uniform4fvARB)(GLint location, GLsizei count, const GLfloat * value); /* 551 */
+   void (GLAPIENTRYP Uniform4iARB)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); /* 552 */
+   void (GLAPIENTRYP Uniform4ivARB)(GLint location, GLsizei count, const GLint * value); /* 553 */
+   void (GLAPIENTRYP UniformMatrix2fvARB)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 554 */
+   void (GLAPIENTRYP UniformMatrix3fvARB)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 555 */
+   void (GLAPIENTRYP UniformMatrix4fvARB)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); /* 556 */
+   void (GLAPIENTRYP UseProgramObjectARB)(GLhandleARB program); /* 557 */
+   void (GLAPIENTRYP ValidateProgramARB)(GLhandleARB program); /* 558 */
+   void (GLAPIENTRYP BindAttribLocationARB)(GLhandleARB program, GLuint index, const GLcharARB * name); /* 559 */
+   void (GLAPIENTRYP GetActiveAttribARB)(GLhandleARB program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name); /* 560 */
+   GLint (GLAPIENTRYP GetAttribLocationARB)(GLhandleARB program, const GLcharARB * name); /* 561 */
+   void (GLAPIENTRYP DrawBuffersARB)(GLsizei n, const GLenum * bufs); /* 562 */
+   void (GLAPIENTRYP RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); /* 563 */
+   void (GLAPIENTRYP FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length); /* 564 */
+   GLvoid * (GLAPIENTRYP MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); /* 565 */
+   void (GLAPIENTRYP BindVertexArray)(GLuint array); /* 566 */
+   void (GLAPIENTRYP GenVertexArrays)(GLsizei n, GLuint * arrays); /* 567 */
+   void (GLAPIENTRYP CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); /* 568 */
+   GLenum (GLAPIENTRYP ClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); /* 569 */
+   void (GLAPIENTRYP DeleteSync)(GLsync sync); /* 570 */
+   GLsync (GLAPIENTRYP FenceSync)(GLenum condition, GLbitfield flags); /* 571 */
+   void (GLAPIENTRYP GetInteger64v)(GLenum pname, GLint64 * params); /* 572 */
+   void (GLAPIENTRYP GetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values); /* 573 */
+   GLboolean (GLAPIENTRYP IsSync)(GLsync sync); /* 574 */
+   void (GLAPIENTRYP WaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); /* 575 */
+   void (GLAPIENTRYP DrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex); /* 576 */
+   void (GLAPIENTRYP DrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex); /* 577 */
+   void (GLAPIENTRYP MultiDrawElementsBaseVertex)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount, const GLint * basevertex); /* 578 */
+   void (GLAPIENTRYP PolygonOffsetEXT)(GLfloat factor, GLfloat bias); /* 579 */
+   void (GLAPIENTRYP GetPixelTexGenParameterfvSGIS)(GLenum pname, GLfloat * params); /* 580 */
+   void (GLAPIENTRYP GetPixelTexGenParameterivSGIS)(GLenum pname, GLint * params); /* 581 */
+   void (GLAPIENTRYP PixelTexGenParameterfSGIS)(GLenum pname, GLfloat param); /* 582 */
+   void (GLAPIENTRYP PixelTexGenParameterfvSGIS)(GLenum pname, const GLfloat * params); /* 583 */
+   void (GLAPIENTRYP PixelTexGenParameteriSGIS)(GLenum pname, GLint param); /* 584 */
+   void (GLAPIENTRYP PixelTexGenParameterivSGIS)(GLenum pname, const GLint * params); /* 585 */
+   void (GLAPIENTRYP SampleMaskSGIS)(GLclampf value, GLboolean invert); /* 586 */
+   void (GLAPIENTRYP SamplePatternSGIS)(GLenum pattern); /* 587 */
+   void (GLAPIENTRYP ColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 588 */
+   void (GLAPIENTRYP EdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean * pointer); /* 589 */
+   void (GLAPIENTRYP IndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 590 */
+   void (GLAPIENTRYP NormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 591 */
+   void (GLAPIENTRYP TexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 592 */
+   void (GLAPIENTRYP VertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer); /* 593 */
+   void (GLAPIENTRYP PointParameterfEXT)(GLenum pname, GLfloat param); /* 594 */
+   void (GLAPIENTRYP PointParameterfvEXT)(GLenum pname, const GLfloat * params); /* 595 */
+   void (GLAPIENTRYP LockArraysEXT)(GLint first, GLsizei count); /* 596 */
+   void (GLAPIENTRYP UnlockArraysEXT)(void); /* 597 */
+   void (GLAPIENTRYP CullParameterdvEXT)(GLenum pname, GLdouble * params); /* 598 */
+   void (GLAPIENTRYP CullParameterfvEXT)(GLenum pname, GLfloat * params); /* 599 */
+   void (GLAPIENTRYP SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue); /* 600 */
+   void (GLAPIENTRYP SecondaryColor3bvEXT)(const GLbyte * v); /* 601 */
+   void (GLAPIENTRYP SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue); /* 602 */
+   void (GLAPIENTRYP SecondaryColor3dvEXT)(const GLdouble * v); /* 603 */
+   void (GLAPIENTRYP SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue); /* 604 */
+   void (GLAPIENTRYP SecondaryColor3fvEXT)(const GLfloat * v); /* 605 */
+   void (GLAPIENTRYP SecondaryColor3iEXT)(GLint red, GLint green, GLint blue); /* 606 */
+   void (GLAPIENTRYP SecondaryColor3ivEXT)(const GLint * v); /* 607 */
+   void (GLAPIENTRYP SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue); /* 608 */
+   void (GLAPIENTRYP SecondaryColor3svEXT)(const GLshort * v); /* 609 */
+   void (GLAPIENTRYP SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue); /* 610 */
+   void (GLAPIENTRYP SecondaryColor3ubvEXT)(const GLubyte * v); /* 611 */
+   void (GLAPIENTRYP SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue); /* 612 */
+   void (GLAPIENTRYP SecondaryColor3uivEXT)(const GLuint * v); /* 613 */
+   void (GLAPIENTRYP SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue); /* 614 */
+   void (GLAPIENTRYP SecondaryColor3usvEXT)(const GLushort * v); /* 615 */
+   void (GLAPIENTRYP SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 616 */
+   void (GLAPIENTRYP MultiDrawArraysEXT)(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount); /* 617 */
+   void (GLAPIENTRYP MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount); /* 618 */
+   void (GLAPIENTRYP FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer); /* 619 */
+   void (GLAPIENTRYP FogCoorddEXT)(GLdouble coord); /* 620 */
+   void (GLAPIENTRYP FogCoorddvEXT)(const GLdouble * coord); /* 621 */
+   void (GLAPIENTRYP FogCoordfEXT)(GLfloat coord); /* 622 */
+   void (GLAPIENTRYP FogCoordfvEXT)(const GLfloat * coord); /* 623 */
+   void (GLAPIENTRYP PixelTexGenSGIX)(GLenum mode); /* 624 */
+   void (GLAPIENTRYP BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); /* 625 */
+   void (GLAPIENTRYP FlushVertexArrayRangeNV)(void); /* 626 */
+   void (GLAPIENTRYP VertexArrayRangeNV)(GLsizei length, const GLvoid * pointer); /* 627 */
+   void (GLAPIENTRYP CombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 628 */
+   void (GLAPIENTRYP CombinerOutputNV)(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); /* 629 */
+   void (GLAPIENTRYP CombinerParameterfNV)(GLenum pname, GLfloat param); /* 630 */
+   void (GLAPIENTRYP CombinerParameterfvNV)(GLenum pname, const GLfloat * params); /* 631 */
+   void (GLAPIENTRYP CombinerParameteriNV)(GLenum pname, GLint param); /* 632 */
+   void (GLAPIENTRYP CombinerParameterivNV)(GLenum pname, const GLint * params); /* 633 */
+   void (GLAPIENTRYP FinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); /* 634 */
+   void (GLAPIENTRYP GetCombinerInputParameterfvNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params); /* 635 */
+   void (GLAPIENTRYP GetCombinerInputParameterivNV)(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params); /* 636 */
+   void (GLAPIENTRYP GetCombinerOutputParameterfvNV)(GLenum stage, GLenum portion, GLenum pname, GLfloat * params); /* 637 */
+   void (GLAPIENTRYP GetCombinerOutputParameterivNV)(GLenum stage, GLenum portion, GLenum pname, GLint * params); /* 638 */
+   void (GLAPIENTRYP GetFinalCombinerInputParameterfvNV)(GLenum variable, GLenum pname, GLfloat * params); /* 639 */
+   void (GLAPIENTRYP GetFinalCombinerInputParameterivNV)(GLenum variable, GLenum pname, GLint * params); /* 640 */
+   void (GLAPIENTRYP ResizeBuffersMESA)(void); /* 641 */
+   void (GLAPIENTRYP WindowPos2dMESA)(GLdouble x, GLdouble y); /* 642 */
+   void (GLAPIENTRYP WindowPos2dvMESA)(const GLdouble * v); /* 643 */
+   void (GLAPIENTRYP WindowPos2fMESA)(GLfloat x, GLfloat y); /* 644 */
+   void (GLAPIENTRYP WindowPos2fvMESA)(const GLfloat * v); /* 645 */
+   void (GLAPIENTRYP WindowPos2iMESA)(GLint x, GLint y); /* 646 */
+   void (GLAPIENTRYP WindowPos2ivMESA)(const GLint * v); /* 647 */
+   void (GLAPIENTRYP WindowPos2sMESA)(GLshort x, GLshort y); /* 648 */
+   void (GLAPIENTRYP WindowPos2svMESA)(const GLshort * v); /* 649 */
+   void (GLAPIENTRYP WindowPos3dMESA)(GLdouble x, GLdouble y, GLdouble z); /* 650 */
+   void (GLAPIENTRYP WindowPos3dvMESA)(const GLdouble * v); /* 651 */
+   void (GLAPIENTRYP WindowPos3fMESA)(GLfloat x, GLfloat y, GLfloat z); /* 652 */
+   void (GLAPIENTRYP WindowPos3fvMESA)(const GLfloat * v); /* 653 */
+   void (GLAPIENTRYP WindowPos3iMESA)(GLint x, GLint y, GLint z); /* 654 */
+   void (GLAPIENTRYP WindowPos3ivMESA)(const GLint * v); /* 655 */
+   void (GLAPIENTRYP WindowPos3sMESA)(GLshort x, GLshort y, GLshort z); /* 656 */
+   void (GLAPIENTRYP WindowPos3svMESA)(const GLshort * v); /* 657 */
+   void (GLAPIENTRYP WindowPos4dMESA)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 658 */
+   void (GLAPIENTRYP WindowPos4dvMESA)(const GLdouble * v); /* 659 */
+   void (GLAPIENTRYP WindowPos4fMESA)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 660 */
+   void (GLAPIENTRYP WindowPos4fvMESA)(const GLfloat * v); /* 661 */
+   void (GLAPIENTRYP WindowPos4iMESA)(GLint x, GLint y, GLint z, GLint w); /* 662 */
+   void (GLAPIENTRYP WindowPos4ivMESA)(const GLint * v); /* 663 */
+   void (GLAPIENTRYP WindowPos4sMESA)(GLshort x, GLshort y, GLshort z, GLshort w); /* 664 */
+   void (GLAPIENTRYP WindowPos4svMESA)(const GLshort * v); /* 665 */
+   void (GLAPIENTRYP MultiModeDrawArraysIBM)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride); /* 666 */
+   void (GLAPIENTRYP MultiModeDrawElementsIBM)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride); /* 667 */
+   void (GLAPIENTRYP DeleteFencesNV)(GLsizei n, const GLuint * fences); /* 668 */
+   void (GLAPIENTRYP FinishFenceNV)(GLuint fence); /* 669 */
+   void (GLAPIENTRYP GenFencesNV)(GLsizei n, GLuint * fences); /* 670 */
+   void (GLAPIENTRYP GetFenceivNV)(GLuint fence, GLenum pname, GLint * params); /* 671 */
+   GLboolean (GLAPIENTRYP IsFenceNV)(GLuint fence); /* 672 */
+   void (GLAPIENTRYP SetFenceNV)(GLuint fence, GLenum condition); /* 673 */
+   GLboolean (GLAPIENTRYP TestFenceNV)(GLuint fence); /* 674 */
+   GLboolean (GLAPIENTRYP AreProgramsResidentNV)(GLsizei n, const GLuint * ids, GLboolean * residences); /* 675 */
+   void (GLAPIENTRYP BindProgramNV)(GLenum target, GLuint program); /* 676 */
+   void (GLAPIENTRYP DeleteProgramsNV)(GLsizei n, const GLuint * programs); /* 677 */
+   void (GLAPIENTRYP ExecuteProgramNV)(GLenum target, GLuint id, const GLfloat * params); /* 678 */
+   void (GLAPIENTRYP GenProgramsNV)(GLsizei n, GLuint * programs); /* 679 */
+   void (GLAPIENTRYP GetProgramParameterdvNV)(GLenum target, GLuint index, GLenum pname, GLdouble * params); /* 680 */
+   void (GLAPIENTRYP GetProgramParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat * params); /* 681 */
+   void (GLAPIENTRYP GetProgramStringNV)(GLuint id, GLenum pname, GLubyte * program); /* 682 */
+   void (GLAPIENTRYP GetProgramivNV)(GLuint id, GLenum pname, GLint * params); /* 683 */
+   void (GLAPIENTRYP GetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint * params); /* 684 */
+   void (GLAPIENTRYP GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer); /* 685 */
+   void (GLAPIENTRYP GetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble * params); /* 686 */
+   void (GLAPIENTRYP GetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat * params); /* 687 */
+   void (GLAPIENTRYP GetVertexAttribivNV)(GLuint index, GLenum pname, GLint * params); /* 688 */
+   GLboolean (GLAPIENTRYP IsProgramNV)(GLuint program); /* 689 */
+   void (GLAPIENTRYP LoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte * program); /* 690 */
+   void (GLAPIENTRYP ProgramParameters4dvNV)(GLenum target, GLuint index, GLuint num, const GLdouble * params); /* 691 */
+   void (GLAPIENTRYP ProgramParameters4fvNV)(GLenum target, GLuint index, GLuint num, const GLfloat * params); /* 692 */
+   void (GLAPIENTRYP RequestResidentProgramsNV)(GLsizei n, const GLuint * ids); /* 693 */
+   void (GLAPIENTRYP TrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform); /* 694 */
+   void (GLAPIENTRYP VertexAttrib1dNV)(GLuint index, GLdouble x); /* 695 */
+   void (GLAPIENTRYP VertexAttrib1dvNV)(GLuint index, const GLdouble * v); /* 696 */
+   void (GLAPIENTRYP VertexAttrib1fNV)(GLuint index, GLfloat x); /* 697 */
+   void (GLAPIENTRYP VertexAttrib1fvNV)(GLuint index, const GLfloat * v); /* 698 */
+   void (GLAPIENTRYP VertexAttrib1sNV)(GLuint index, GLshort x); /* 699 */
+   void (GLAPIENTRYP VertexAttrib1svNV)(GLuint index, const GLshort * v); /* 700 */
+   void (GLAPIENTRYP VertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y); /* 701 */
+   void (GLAPIENTRYP VertexAttrib2dvNV)(GLuint index, const GLdouble * v); /* 702 */
+   void (GLAPIENTRYP VertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y); /* 703 */
+   void (GLAPIENTRYP VertexAttrib2fvNV)(GLuint index, const GLfloat * v); /* 704 */
+   void (GLAPIENTRYP VertexAttrib2sNV)(GLuint index, GLshort x, GLshort y); /* 705 */
+   void (GLAPIENTRYP VertexAttrib2svNV)(GLuint index, const GLshort * v); /* 706 */
+   void (GLAPIENTRYP VertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z); /* 707 */
+   void (GLAPIENTRYP VertexAttrib3dvNV)(GLuint index, const GLdouble * v); /* 708 */
+   void (GLAPIENTRYP VertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z); /* 709 */
+   void (GLAPIENTRYP VertexAttrib3fvNV)(GLuint index, const GLfloat * v); /* 710 */
+   void (GLAPIENTRYP VertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z); /* 711 */
+   void (GLAPIENTRYP VertexAttrib3svNV)(GLuint index, const GLshort * v); /* 712 */
+   void (GLAPIENTRYP VertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 713 */
+   void (GLAPIENTRYP VertexAttrib4dvNV)(GLuint index, const GLdouble * v); /* 714 */
+   void (GLAPIENTRYP VertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 715 */
+   void (GLAPIENTRYP VertexAttrib4fvNV)(GLuint index, const GLfloat * v); /* 716 */
+   void (GLAPIENTRYP VertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); /* 717 */
+   void (GLAPIENTRYP VertexAttrib4svNV)(GLuint index, const GLshort * v); /* 718 */
+   void (GLAPIENTRYP VertexAttrib4ubNV)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); /* 719 */
+   void (GLAPIENTRYP VertexAttrib4ubvNV)(GLuint index, const GLubyte * v); /* 720 */
+   void (GLAPIENTRYP VertexAttribPointerNV)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer); /* 721 */
+   void (GLAPIENTRYP VertexAttribs1dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 722 */
+   void (GLAPIENTRYP VertexAttribs1fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 723 */
+   void (GLAPIENTRYP VertexAttribs1svNV)(GLuint index, GLsizei n, const GLshort * v); /* 724 */
+   void (GLAPIENTRYP VertexAttribs2dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 725 */
+   void (GLAPIENTRYP VertexAttribs2fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 726 */
+   void (GLAPIENTRYP VertexAttribs2svNV)(GLuint index, GLsizei n, const GLshort * v); /* 727 */
+   void (GLAPIENTRYP VertexAttribs3dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 728 */
+   void (GLAPIENTRYP VertexAttribs3fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 729 */
+   void (GLAPIENTRYP VertexAttribs3svNV)(GLuint index, GLsizei n, const GLshort * v); /* 730 */
+   void (GLAPIENTRYP VertexAttribs4dvNV)(GLuint index, GLsizei n, const GLdouble * v); /* 731 */
+   void (GLAPIENTRYP VertexAttribs4fvNV)(GLuint index, GLsizei n, const GLfloat * v); /* 732 */
+   void (GLAPIENTRYP VertexAttribs4svNV)(GLuint index, GLsizei n, const GLshort * v); /* 733 */
+   void (GLAPIENTRYP VertexAttribs4ubvNV)(GLuint index, GLsizei n, const GLubyte * v); /* 734 */
+   void (GLAPIENTRYP GetTexBumpParameterfvATI)(GLenum pname, GLfloat * param); /* 735 */
+   void (GLAPIENTRYP GetTexBumpParameterivATI)(GLenum pname, GLint * param); /* 736 */
+   void (GLAPIENTRYP TexBumpParameterfvATI)(GLenum pname, const GLfloat * param); /* 737 */
+   void (GLAPIENTRYP TexBumpParameterivATI)(GLenum pname, const GLint * param); /* 738 */
+   void (GLAPIENTRYP AlphaFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 739 */
+   void (GLAPIENTRYP AlphaFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 740 */
+   void (GLAPIENTRYP AlphaFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 741 */
+   void (GLAPIENTRYP BeginFragmentShaderATI)(void); /* 742 */
+   void (GLAPIENTRYP BindFragmentShaderATI)(GLuint id); /* 743 */
+   void (GLAPIENTRYP ColorFragmentOp1ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); /* 744 */
+   void (GLAPIENTRYP ColorFragmentOp2ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); /* 745 */
+   void (GLAPIENTRYP ColorFragmentOp3ATI)(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); /* 746 */
+   void (GLAPIENTRYP DeleteFragmentShaderATI)(GLuint id); /* 747 */
+   void (GLAPIENTRYP EndFragmentShaderATI)(void); /* 748 */
+   GLuint (GLAPIENTRYP GenFragmentShadersATI)(GLuint range); /* 749 */
+   void (GLAPIENTRYP PassTexCoordATI)(GLuint dst, GLuint coord, GLenum swizzle); /* 750 */
+   void (GLAPIENTRYP SampleMapATI)(GLuint dst, GLuint interp, GLenum swizzle); /* 751 */
+   void (GLAPIENTRYP SetFragmentShaderConstantATI)(GLuint dst, const GLfloat * value); /* 752 */
+   void (GLAPIENTRYP PointParameteriNV)(GLenum pname, GLint param); /* 753 */
+   void (GLAPIENTRYP PointParameterivNV)(GLenum pname, const GLint * params); /* 754 */
+   void (GLAPIENTRYP ActiveStencilFaceEXT)(GLenum face); /* 755 */
+   void (GLAPIENTRYP BindVertexArrayAPPLE)(GLuint array); /* 756 */
+   void (GLAPIENTRYP DeleteVertexArraysAPPLE)(GLsizei n, const GLuint * arrays); /* 757 */
+   void (GLAPIENTRYP GenVertexArraysAPPLE)(GLsizei n, GLuint * arrays); /* 758 */
+   GLboolean (GLAPIENTRYP IsVertexArrayAPPLE)(GLuint array); /* 759 */
+   void (GLAPIENTRYP GetProgramNamedParameterdvNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params); /* 760 */
+   void (GLAPIENTRYP GetProgramNamedParameterfvNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params); /* 761 */
+   void (GLAPIENTRYP ProgramNamedParameter4dNV)(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); /* 762 */
+   void (GLAPIENTRYP ProgramNamedParameter4dvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v); /* 763 */
+   void (GLAPIENTRYP ProgramNamedParameter4fNV)(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); /* 764 */
+   void (GLAPIENTRYP ProgramNamedParameter4fvNV)(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v); /* 765 */
+   void (GLAPIENTRYP DepthBoundsEXT)(GLclampd zmin, GLclampd zmax); /* 766 */
+   void (GLAPIENTRYP BlendEquationSeparateEXT)(GLenum modeRGB, GLenum modeA); /* 767 */
+   void (GLAPIENTRYP BindFramebufferEXT)(GLenum target, GLuint framebuffer); /* 768 */
+   void (GLAPIENTRYP BindRenderbufferEXT)(GLenum target, GLuint renderbuffer); /* 769 */
+   GLenum (GLAPIENTRYP CheckFramebufferStatusEXT)(GLenum target); /* 770 */
+   void (GLAPIENTRYP DeleteFramebuffersEXT)(GLsizei n, const GLuint * framebuffers); /* 771 */
+   void (GLAPIENTRYP DeleteRenderbuffersEXT)(GLsizei n, const GLuint * renderbuffers); /* 772 */
+   void (GLAPIENTRYP FramebufferRenderbufferEXT)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); /* 773 */
+   void (GLAPIENTRYP FramebufferTexture1DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 774 */
+   void (GLAPIENTRYP FramebufferTexture2DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); /* 775 */
+   void (GLAPIENTRYP FramebufferTexture3DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); /* 776 */
+   void (GLAPIENTRYP GenFramebuffersEXT)(GLsizei n, GLuint * framebuffers); /* 777 */
+   void (GLAPIENTRYP GenRenderbuffersEXT)(GLsizei n, GLuint * renderbuffers); /* 778 */
+   void (GLAPIENTRYP GenerateMipmapEXT)(GLenum target); /* 779 */
+   void (GLAPIENTRYP GetFramebufferAttachmentParameterivEXT)(GLenum target, GLenum attachment, GLenum pname, GLint * params); /* 780 */
+   void (GLAPIENTRYP GetRenderbufferParameterivEXT)(GLenum target, GLenum pname, GLint * params); /* 781 */
+   GLboolean (GLAPIENTRYP IsFramebufferEXT)(GLuint framebuffer); /* 782 */
+   GLboolean (GLAPIENTRYP IsRenderbufferEXT)(GLuint renderbuffer); /* 783 */
+   void (GLAPIENTRYP RenderbufferStorageEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); /* 784 */
+   void (GLAPIENTRYP BlitFramebufferEXT)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); /* 785 */
+   void (GLAPIENTRYP BufferParameteriAPPLE)(GLenum target, GLenum pname, GLint param); /* 786 */
+   void (GLAPIENTRYP FlushMappedBufferRangeAPPLE)(GLenum target, GLintptr offset, GLsizeiptr size); /* 787 */
+   void (GLAPIENTRYP FramebufferTextureLayerEXT)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); /* 788 */
+   void (GLAPIENTRYP ColorMaskIndexedEXT)(GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a); /* 789 */
+   void (GLAPIENTRYP DisableIndexedEXT)(GLenum target, GLuint index); /* 790 */
+   void (GLAPIENTRYP EnableIndexedEXT)(GLenum target, GLuint index); /* 791 */
+   void (GLAPIENTRYP GetBooleanIndexedvEXT)(GLenum value, GLuint index, GLboolean * data); /* 792 */
+   void (GLAPIENTRYP GetIntegerIndexedvEXT)(GLenum value, GLuint index, GLint * data); /* 793 */
+   GLboolean (GLAPIENTRYP IsEnabledIndexedEXT)(GLenum target, GLuint index); /* 794 */
+   void (GLAPIENTRYP BeginConditionalRenderNV)(GLuint query, GLenum mode); /* 795 */
+   void (GLAPIENTRYP EndConditionalRenderNV)(void); /* 796 */
+   void (GLAPIENTRYP BeginTransformFeedbackEXT)(GLenum mode); /* 797 */
+   void (GLAPIENTRYP BindBufferBaseEXT)(GLenum target, GLuint index, GLuint buffer); /* 798 */
+   void (GLAPIENTRYP BindBufferOffsetEXT)(GLenum target, GLuint index, GLuint buffer, GLintptr offset); /* 799 */
+   void (GLAPIENTRYP BindBufferRangeEXT)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); /* 800 */
+   void (GLAPIENTRYP EndTransformFeedbackEXT)(void); /* 801 */
+   void (GLAPIENTRYP GetTransformFeedbackVaryingEXT)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name); /* 802 */
+   void (GLAPIENTRYP TransformFeedbackVaryingsEXT)(GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode); /* 803 */
+   void (GLAPIENTRYP ProvokingVertexEXT)(GLenum mode); /* 804 */
+   void (GLAPIENTRYP GetTexParameterPointervAPPLE)(GLenum target, GLenum pname, GLvoid ** params); /* 805 */
+   void (GLAPIENTRYP TextureRangeAPPLE)(GLenum target, GLsizei length, GLvoid * pointer); /* 806 */
+   void (GLAPIENTRYP GetObjectParameterivAPPLE)(GLenum objectType, GLuint name, GLenum pname, GLint * value); /* 807 */
+   GLenum (GLAPIENTRYP ObjectPurgeableAPPLE)(GLenum objectType, GLuint name, GLenum option); /* 808 */
+   GLenum (GLAPIENTRYP ObjectUnpurgeableAPPLE)(GLenum objectType, GLuint name, GLenum option); /* 809 */
+   void (GLAPIENTRYP StencilFuncSeparateATI)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); /* 810 */
+   void (GLAPIENTRYP ProgramEnvParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 811 */
+   void (GLAPIENTRYP ProgramLocalParameters4fvEXT)(GLenum target, GLuint index, GLsizei count, const GLfloat * params); /* 812 */
+   void (GLAPIENTRYP GetQueryObjecti64vEXT)(GLuint id, GLenum pname, GLint64EXT * params); /* 813 */
+   void (GLAPIENTRYP GetQueryObjectui64vEXT)(GLuint id, GLenum pname, GLuint64EXT * params); /* 814 */
+   void (GLAPIENTRYP EGLImageTargetRenderbufferStorageOES)(GLenum target, GLvoid * writeOffset); /* 815 */
+   void (GLAPIENTRYP EGLImageTargetTexture2DOES)(GLenum target, GLvoid * writeOffset); /* 816 */
 };
 
 #endif /* !defined( _GLAPI_TABLE_H_ ) */
diff --git a/src/mesa/glapi/glapitemp.h b/src/mesa/glapi/glapitemp.h
index ea6b61159d2..3ed337f8254 100644
--- a/src/mesa/glapi/glapitemp.h
+++ b/src/mesa/glapi/glapitemp.h
@@ -2632,6 +2632,36 @@ KEYWORD1 void KEYWORD2 NAME(UniformMatrix4x3fv)(GLint location, GLsizei count, G
    DISPATCH(UniformMatrix4x3fv, (location, count, transpose, value), (F, "glUniformMatrix4x3fv(%d, %d, %d, %p);\n", location, count, transpose, (const void *) value));
 }
 
+KEYWORD1 void KEYWORD2 NAME(DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
+{
+   DISPATCH(DrawArraysInstanced, (mode, first, count, primcount), (F, "glDrawArraysInstanced(0x%x, %d, %d, %d);\n", mode, first, count, primcount));
+}
+
+KEYWORD1 void KEYWORD2 NAME(DrawArraysInstancedARB)(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
+{
+   DISPATCH(DrawArraysInstanced, (mode, first, count, primcount), (F, "glDrawArraysInstancedARB(0x%x, %d, %d, %d);\n", mode, first, count, primcount));
+}
+
+KEYWORD1 void KEYWORD2 NAME(DrawArraysInstancedEXT)(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
+{
+   DISPATCH(DrawArraysInstanced, (mode, first, count, primcount), (F, "glDrawArraysInstancedEXT(0x%x, %d, %d, %d);\n", mode, first, count, primcount));
+}
+
+KEYWORD1 void KEYWORD2 NAME(DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount)
+{
+   DISPATCH(DrawElementsInstanced, (mode, count, type, indices, primcount), (F, "glDrawElementsInstanced(0x%x, %d, 0x%x, %p, %d);\n", mode, count, type, (const void *) indices, primcount));
+}
+
+KEYWORD1 void KEYWORD2 NAME(DrawElementsInstancedARB)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount)
+{
+   DISPATCH(DrawElementsInstanced, (mode, count, type, indices, primcount), (F, "glDrawElementsInstancedARB(0x%x, %d, 0x%x, %p, %d);\n", mode, count, type, (const void *) indices, primcount));
+}
+
+KEYWORD1 void KEYWORD2 NAME(DrawElementsInstancedEXT)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount)
+{
+   DISPATCH(DrawElementsInstanced, (mode, count, type, indices, primcount), (F, "glDrawElementsInstancedEXT(0x%x, %d, 0x%x, %p, %d);\n", mode, count, type, (const void *) indices, primcount));
+}
+
 KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixd)(const GLdouble * m)
 {
    DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixd(%p);\n", (const void *) m));
@@ -3932,58 +3962,58 @@ KEYWORD1 void KEYWORD2 NAME(PolygonOffsetEXT)(GLfloat factor, GLfloat bias)
    DISPATCH(PolygonOffsetEXT, (factor, bias), (F, "glPolygonOffsetEXT(%f, %f);\n", factor, bias));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_578)(GLenum pname, GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, GLfloat * params)
 {
    DISPATCH(GetPixelTexGenParameterfvSGIS, (pname, params), (F, "glGetPixelTexGenParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLenum pname, GLint * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_579)(GLenum pname, GLint * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLenum pname, GLint * params)
 {
    DISPATCH(GetPixelTexGenParameterivSGIS, (pname, params), (F, "glGetPixelTexGenParameterivSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, GLfloat param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pname, GLfloat param);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_580)(GLenum pname, GLfloat param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pname, GLfloat param)
 {
    DISPATCH(PixelTexGenParameterfSGIS, (pname, param), (F, "glPixelTexGenParameterfSGIS(0x%x, %f);\n", pname, param));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLenum pname, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_583)(GLenum pname, const GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_581)(GLenum pname, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_583)(GLenum pname, const GLfloat * params)
 {
    DISPATCH(PixelTexGenParameterfvSGIS, (pname, params), (F, "glPixelTexGenParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pname, GLint param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_584)(GLenum pname, GLint param);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_582)(GLenum pname, GLint param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_584)(GLenum pname, GLint param)
 {
    DISPATCH(PixelTexGenParameteriSGIS, (pname, param), (F, "glPixelTexGenParameteriSGIS(0x%x, %d);\n", pname, param));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_583)(GLenum pname, const GLint * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_585)(GLenum pname, const GLint * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_583)(GLenum pname, const GLint * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_585)(GLenum pname, const GLint * params)
 {
    DISPATCH(PixelTexGenParameterivSGIS, (pname, params), (F, "glPixelTexGenParameterivSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_584)(GLclampf value, GLboolean invert);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_586)(GLclampf value, GLboolean invert);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_584)(GLclampf value, GLboolean invert)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_586)(GLclampf value, GLboolean invert)
 {
    DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskSGIS(%f, %d);\n", value, invert));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_585)(GLenum pattern);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_587)(GLenum pattern);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_585)(GLenum pattern)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_587)(GLenum pattern)
 {
    DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternSGIS(0x%x);\n", pattern));
 }
@@ -4033,9 +4063,9 @@ KEYWORD1 void KEYWORD2 NAME(PointParameterfEXT)(GLenum pname, GLfloat param)
    DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfEXT(0x%x, %f);\n", pname, param));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_592)(GLenum pname, GLfloat param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_594)(GLenum pname, GLfloat param);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_592)(GLenum pname, GLfloat param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_594)(GLenum pname, GLfloat param)
 {
    DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfSGIS(0x%x, %f);\n", pname, param));
 }
@@ -4055,9 +4085,9 @@ KEYWORD1 void KEYWORD2 NAME(PointParameterfvEXT)(GLenum pname, const GLfloat * p
    DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvEXT(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_595)(GLenum pname, const GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_593)(GLenum pname, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_595)(GLenum pname, const GLfloat * params)
 {
    DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
 }
@@ -4072,16 +4102,16 @@ KEYWORD1 void KEYWORD2 NAME(UnlockArraysEXT)(void)
    DISPATCH(UnlockArraysEXT, (), (F, "glUnlockArraysEXT();\n"));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_596)(GLenum pname, GLdouble * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_598)(GLenum pname, GLdouble * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_596)(GLenum pname, GLdouble * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_598)(GLenum pname, GLdouble * params)
 {
    DISPATCH(CullParameterdvEXT, (pname, params), (F, "glCullParameterdvEXT(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_597)(GLenum pname, GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_599)(GLenum pname, GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_597)(GLenum pname, GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_599)(GLenum pname, GLfloat * params)
 {
    DISPATCH(CullParameterfvEXT, (pname, params), (F, "glCullParameterfvEXT(0x%x, %p);\n", pname, (const void *) params));
 }
@@ -4326,9 +4356,9 @@ KEYWORD1 void KEYWORD2 NAME(FogCoordfvEXT)(const GLfloat * coord)
    DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfvEXT(%p);\n", (const void *) coord));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_622)(GLenum mode);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_624)(GLenum mode);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_622)(GLenum mode)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_624)(GLenum mode)
 {
    DISPATCH(PixelTexGenSGIX, (mode), (F, "glPixelTexGenSGIX(0x%x);\n", mode));
 }
@@ -4343,9 +4373,9 @@ KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfac
    DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateEXT(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_623)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_625)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_623)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_625)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
    DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateINGR(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
 }
@@ -4710,65 +4740,65 @@ KEYWORD1 void KEYWORD2 NAME(WindowPos4svMESA)(const GLshort * v)
    DISPATCH(WindowPos4svMESA, (v), (F, "glWindowPos4svMESA(%p);\n", (const void *) v));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_664)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)
 {
    DISPATCH(MultiModeDrawArraysIBM, (mode, first, count, primcount, modestride), (F, "glMultiModeDrawArraysIBM(%p, %p, %p, %d, %d);\n", (const void *) mode, (const void *) first, (const void *) count, primcount, modestride));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_667)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_665)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_667)(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride)
 {
    DISPATCH(MultiModeDrawElementsIBM, (mode, count, type, indices, primcount, modestride), (F, "glMultiModeDrawElementsIBM(%p, %p, 0x%x, %p, %d, %d);\n", (const void *) mode, (const void *) count, type, (const void *) indices, primcount, modestride));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLsizei n, const GLuint * fences);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLsizei n, const GLuint * fences);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_666)(GLsizei n, const GLuint * fences)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLsizei n, const GLuint * fences)
 {
    DISPATCH(DeleteFencesNV, (n, fences), (F, "glDeleteFencesNV(%d, %p);\n", n, (const void *) fences));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_667)(GLuint fence)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence)
 {
    DISPATCH(FinishFenceNV, (fence), (F, "glFinishFenceNV(%d);\n", fence));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLsizei n, GLuint * fences);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_670)(GLsizei n, GLuint * fences);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_668)(GLsizei n, GLuint * fences)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_670)(GLsizei n, GLuint * fences)
 {
    DISPATCH(GenFencesNV, (n, fences), (F, "glGenFencesNV(%d, %p);\n", n, (const void *) fences));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence, GLenum pname, GLint * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_671)(GLuint fence, GLenum pname, GLint * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_669)(GLuint fence, GLenum pname, GLint * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_671)(GLuint fence, GLenum pname, GLint * params)
 {
    DISPATCH(GetFenceivNV, (fence, pname, params), (F, "glGetFenceivNV(%d, 0x%x, %p);\n", fence, pname, (const void *) params));
 }
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_670)(GLuint fence);
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_672)(GLuint fence);
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_670)(GLuint fence)
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_672)(GLuint fence)
 {
    RETURN_DISPATCH(IsFenceNV, (fence), (F, "glIsFenceNV(%d);\n", fence));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_671)(GLuint fence, GLenum condition);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_673)(GLuint fence, GLenum condition);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_671)(GLuint fence, GLenum condition)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_673)(GLuint fence, GLenum condition)
 {
    DISPATCH(SetFenceNV, (fence, condition), (F, "glSetFenceNV(%d, 0x%x);\n", fence, condition));
 }
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_672)(GLuint fence);
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_674)(GLuint fence);
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_672)(GLuint fence)
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_674)(GLuint fence)
 {
    RETURN_DISPATCH(TestFenceNV, (fence), (F, "glTestFenceNV(%d);\n", fence));
 }
@@ -5213,16 +5243,16 @@ KEYWORD1 void KEYWORD2 NAME(PointParameterivNV)(GLenum pname, const GLint * para
    DISPATCH(PointParameterivNV, (pname, params), (F, "glPointParameterivNV(0x%x, %p);\n", pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLenum face);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_755)(GLenum face);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_753)(GLenum face)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_755)(GLenum face)
 {
    DISPATCH(ActiveStencilFaceEXT, (face), (F, "glActiveStencilFaceEXT(0x%x);\n", face));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_754)(GLuint array);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_756)(GLuint array);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_754)(GLuint array)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_756)(GLuint array)
 {
    DISPATCH(BindVertexArrayAPPLE, (array), (F, "glBindVertexArrayAPPLE(%d);\n", array));
 }
@@ -5232,16 +5262,16 @@ KEYWORD1 void KEYWORD2 NAME(DeleteVertexArrays)(GLsizei n, const GLuint * arrays
    DISPATCH(DeleteVertexArraysAPPLE, (n, arrays), (F, "glDeleteVertexArrays(%d, %p);\n", n, (const void *) arrays));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_755)(GLsizei n, const GLuint * arrays);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_757)(GLsizei n, const GLuint * arrays);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_755)(GLsizei n, const GLuint * arrays)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_757)(GLsizei n, const GLuint * arrays)
 {
    DISPATCH(DeleteVertexArraysAPPLE, (n, arrays), (F, "glDeleteVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_756)(GLsizei n, GLuint * arrays);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_758)(GLsizei n, GLuint * arrays);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_756)(GLsizei n, GLuint * arrays)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_758)(GLsizei n, GLuint * arrays)
 {
    DISPATCH(GenVertexArraysAPPLE, (n, arrays), (F, "glGenVertexArraysAPPLE(%d, %p);\n", n, (const void *) arrays));
 }
@@ -5251,9 +5281,9 @@ KEYWORD1 GLboolean KEYWORD2 NAME(IsVertexArray)(GLuint array)
    RETURN_DISPATCH(IsVertexArrayAPPLE, (array), (F, "glIsVertexArray(%d);\n", array));
 }
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_757)(GLuint array);
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_759)(GLuint array);
 
-KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_757)(GLuint array)
+KEYWORD1_ALT GLboolean KEYWORD2 NAME(_dispatch_stub_759)(GLuint array)
 {
    RETURN_DISPATCH(IsVertexArrayAPPLE, (array), (F, "glIsVertexArrayAPPLE(%d);\n", array));
 }
@@ -5288,9 +5318,9 @@ KEYWORD1 void KEYWORD2 NAME(ProgramNamedParameter4fvNV)(GLuint id, GLsizei len,
    DISPATCH(ProgramNamedParameter4fvNV, (id, len, name, v), (F, "glProgramNamedParameter4fvNV(%d, %d, %p, %p);\n", id, len, (const void *) name, (const void *) v));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_764)(GLclampd zmin, GLclampd zmax);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_766)(GLclampd zmin, GLclampd zmax);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_764)(GLclampd zmin, GLclampd zmax)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_766)(GLclampd zmin, GLclampd zmax)
 {
    DISPATCH(DepthBoundsEXT, (zmin, zmax), (F, "glDepthBoundsEXT(%f, %f);\n", zmin, zmax));
 }
@@ -5300,9 +5330,9 @@ KEYWORD1 void KEYWORD2 NAME(BlendEquationSeparate)(GLenum modeRGB, GLenum modeA)
    DISPATCH(BlendEquationSeparateEXT, (modeRGB, modeA), (F, "glBlendEquationSeparate(0x%x, 0x%x);\n", modeRGB, modeA));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_765)(GLenum modeRGB, GLenum modeA);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_767)(GLenum modeRGB, GLenum modeA);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_765)(GLenum modeRGB, GLenum modeA)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_767)(GLenum modeRGB, GLenum modeA)
 {
    DISPATCH(BlendEquationSeparateEXT, (modeRGB, modeA), (F, "glBlendEquationSeparateEXT(0x%x, 0x%x);\n", modeRGB, modeA));
 }
@@ -5482,23 +5512,23 @@ KEYWORD1 void KEYWORD2 NAME(BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint src
    DISPATCH(BlitFramebufferEXT, (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter), (F, "glBlitFramebuffer(%d, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x);\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_783)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_783)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
    DISPATCH(BlitFramebufferEXT, (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter), (F, "glBlitFramebufferEXT(%d, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x);\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_784)(GLenum target, GLenum pname, GLint param);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_786)(GLenum target, GLenum pname, GLint param);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_784)(GLenum target, GLenum pname, GLint param)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_786)(GLenum target, GLenum pname, GLint param)
 {
    DISPATCH(BufferParameteriAPPLE, (target, pname, param), (F, "glBufferParameteriAPPLE(0x%x, 0x%x, %d);\n", target, pname, param));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLintptr offset, GLsizeiptr size);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_787)(GLenum target, GLintptr offset, GLsizeiptr size);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_785)(GLenum target, GLintptr offset, GLsizeiptr size)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_787)(GLenum target, GLintptr offset, GLsizeiptr size)
 {
    DISPATCH(FlushMappedBufferRangeAPPLE, (target, offset, size), (F, "glFlushMappedBufferRangeAPPLE(0x%x, %d, %d);\n", target, offset, size));
 }
@@ -5553,6 +5583,71 @@ KEYWORD1 void KEYWORD2 NAME(EndConditionalRenderNV)(void)
    DISPATCH(EndConditionalRenderNV, (), (F, "glEndConditionalRenderNV();\n"));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BeginTransformFeedbackEXT)(GLenum mode)
+{
+   DISPATCH(BeginTransformFeedbackEXT, (mode), (F, "glBeginTransformFeedbackEXT(0x%x);\n", mode));
+}
+
+KEYWORD1 void KEYWORD2 NAME(BeginTransformFeedback)(GLenum mode)
+{
+   DISPATCH(BeginTransformFeedbackEXT, (mode), (F, "glBeginTransformFeedback(0x%x);\n", mode));
+}
+
+KEYWORD1 void KEYWORD2 NAME(BindBufferBaseEXT)(GLenum target, GLuint index, GLuint buffer)
+{
+   DISPATCH(BindBufferBaseEXT, (target, index, buffer), (F, "glBindBufferBaseEXT(0x%x, %d, %d);\n", target, index, buffer));
+}
+
+KEYWORD1 void KEYWORD2 NAME(BindBufferBase)(GLenum target, GLuint index, GLuint buffer)
+{
+   DISPATCH(BindBufferBaseEXT, (target, index, buffer), (F, "glBindBufferBase(0x%x, %d, %d);\n", target, index, buffer));
+}
+
+KEYWORD1 void KEYWORD2 NAME(BindBufferOffsetEXT)(GLenum target, GLuint index, GLuint buffer, GLintptr offset)
+{
+   DISPATCH(BindBufferOffsetEXT, (target, index, buffer, offset), (F, "glBindBufferOffsetEXT(0x%x, %d, %d, %d);\n", target, index, buffer, offset));
+}
+
+KEYWORD1 void KEYWORD2 NAME(BindBufferRangeEXT)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+   DISPATCH(BindBufferRangeEXT, (target, index, buffer, offset, size), (F, "glBindBufferRangeEXT(0x%x, %d, %d, %d, %d);\n", target, index, buffer, offset, size));
+}
+
+KEYWORD1 void KEYWORD2 NAME(BindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+   DISPATCH(BindBufferRangeEXT, (target, index, buffer, offset, size), (F, "glBindBufferRange(0x%x, %d, %d, %d, %d);\n", target, index, buffer, offset, size));
+}
+
+KEYWORD1 void KEYWORD2 NAME(EndTransformFeedbackEXT)(void)
+{
+   DISPATCH(EndTransformFeedbackEXT, (), (F, "glEndTransformFeedbackEXT();\n"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(EndTransformFeedback)(void)
+{
+   DISPATCH(EndTransformFeedbackEXT, (), (F, "glEndTransformFeedback();\n"));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetTransformFeedbackVaryingEXT)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name)
+{
+   DISPATCH(GetTransformFeedbackVaryingEXT, (program, index, bufSize, length, size, type, name), (F, "glGetTransformFeedbackVaryingEXT(%d, %d, %d, %p, %p, %p, %p);\n", program, index, bufSize, (const void *) length, (const void *) size, (const void *) type, (const void *) name));
+}
+
+KEYWORD1 void KEYWORD2 NAME(GetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name)
+{
+   DISPATCH(GetTransformFeedbackVaryingEXT, (program, index, bufSize, length, size, type, name), (F, "glGetTransformFeedbackVarying(%d, %d, %d, %p, %p, %p, %p);\n", program, index, bufSize, (const void *) length, (const void *) size, (const void *) type, (const void *) name));
+}
+
+KEYWORD1 void KEYWORD2 NAME(TransformFeedbackVaryingsEXT)(GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode)
+{
+   DISPATCH(TransformFeedbackVaryingsEXT, (program, count, varyings, bufferMode), (F, "glTransformFeedbackVaryingsEXT(%d, %d, %p, 0x%x);\n", program, count, (const void *) varyings, bufferMode));
+}
+
+KEYWORD1 void KEYWORD2 NAME(TransformFeedbackVaryings)(GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode)
+{
+   DISPATCH(TransformFeedbackVaryingsEXT, (program, count, varyings, bufferMode), (F, "glTransformFeedbackVaryings(%d, %d, %p, 0x%x);\n", program, count, (const void *) varyings, bufferMode));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ProvokingVertexEXT)(GLenum mode)
 {
    DISPATCH(ProvokingVertexEXT, (mode), (F, "glProvokingVertexEXT(0x%x);\n", mode));
@@ -5563,16 +5658,16 @@ KEYWORD1 void KEYWORD2 NAME(ProvokingVertex)(GLenum mode)
    DISPATCH(ProvokingVertexEXT, (mode), (F, "glProvokingVertex(0x%x);\n", mode));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_796)(GLenum target, GLenum pname, GLvoid ** params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_805)(GLenum target, GLenum pname, GLvoid ** params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_796)(GLenum target, GLenum pname, GLvoid ** params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_805)(GLenum target, GLenum pname, GLvoid ** params)
 {
    DISPATCH(GetTexParameterPointervAPPLE, (target, pname, params), (F, "glGetTexParameterPointervAPPLE(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_797)(GLenum target, GLsizei length, GLvoid * pointer);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_806)(GLenum target, GLsizei length, GLvoid * pointer);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_797)(GLenum target, GLsizei length, GLvoid * pointer)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_806)(GLenum target, GLsizei length, GLvoid * pointer)
 {
    DISPATCH(TextureRangeAPPLE, (target, length, pointer), (F, "glTextureRangeAPPLE(0x%x, %d, %p);\n", target, length, (const void *) pointer));
 }
@@ -5592,37 +5687,37 @@ KEYWORD1 GLenum KEYWORD2 NAME(ObjectUnpurgeableAPPLE)(GLenum objectType, GLuint
    RETURN_DISPATCH(ObjectUnpurgeableAPPLE, (objectType, name, option), (F, "glObjectUnpurgeableAPPLE(0x%x, %d, 0x%x);\n", objectType, name, option));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_801)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_810)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_801)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_810)(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
 {
    DISPATCH(StencilFuncSeparateATI, (frontfunc, backfunc, ref, mask), (F, "glStencilFuncSeparateATI(0x%x, 0x%x, %d, %d);\n", frontfunc, backfunc, ref, mask));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_802)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_811)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_802)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_811)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
 {
    DISPATCH(ProgramEnvParameters4fvEXT, (target, index, count, params), (F, "glProgramEnvParameters4fvEXT(0x%x, %d, %d, %p);\n", target, index, count, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_803)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_812)(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_803)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_812)(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
 {
    DISPATCH(ProgramLocalParameters4fvEXT, (target, index, count, params), (F, "glProgramLocalParameters4fvEXT(0x%x, %d, %d, %p);\n", target, index, count, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_804)(GLuint id, GLenum pname, GLint64EXT * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_813)(GLuint id, GLenum pname, GLint64EXT * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_804)(GLuint id, GLenum pname, GLint64EXT * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_813)(GLuint id, GLenum pname, GLint64EXT * params)
 {
    DISPATCH(GetQueryObjecti64vEXT, (id, pname, params), (F, "glGetQueryObjecti64vEXT(%d, 0x%x, %p);\n", id, pname, (const void *) params));
 }
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_805)(GLuint id, GLenum pname, GLuint64EXT * params);
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_814)(GLuint id, GLenum pname, GLuint64EXT * params);
 
-KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_805)(GLuint id, GLenum pname, GLuint64EXT * params)
+KEYWORD1_ALT void KEYWORD2 NAME(_dispatch_stub_814)(GLuint id, GLenum pname, GLuint64EXT * params)
 {
    DISPATCH(GetQueryObjectui64vEXT, (id, pname, params), (F, "glGetQueryObjectui64vEXT(%d, 0x%x, %p);\n", id, pname, (const void *) params));
 }
@@ -6220,6 +6315,8 @@ _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(UniformMatrix3x4fv),
    TABLE_ENTRY(UniformMatrix4x2fv),
    TABLE_ENTRY(UniformMatrix4x3fv),
+   TABLE_ENTRY(DrawArraysInstanced),
+   TABLE_ENTRY(DrawElementsInstanced),
    TABLE_ENTRY(LoadTransposeMatrixdARB),
    TABLE_ENTRY(LoadTransposeMatrixfARB),
    TABLE_ENTRY(MultTransposeMatrixdARB),
@@ -6368,14 +6465,14 @@ _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(DrawRangeElementsBaseVertex),
    TABLE_ENTRY(MultiDrawElementsBaseVertex),
    TABLE_ENTRY(PolygonOffsetEXT),
-   TABLE_ENTRY(_dispatch_stub_578),
-   TABLE_ENTRY(_dispatch_stub_579),
    TABLE_ENTRY(_dispatch_stub_580),
    TABLE_ENTRY(_dispatch_stub_581),
    TABLE_ENTRY(_dispatch_stub_582),
    TABLE_ENTRY(_dispatch_stub_583),
    TABLE_ENTRY(_dispatch_stub_584),
    TABLE_ENTRY(_dispatch_stub_585),
+   TABLE_ENTRY(_dispatch_stub_586),
+   TABLE_ENTRY(_dispatch_stub_587),
    TABLE_ENTRY(ColorPointerEXT),
    TABLE_ENTRY(EdgeFlagPointerEXT),
    TABLE_ENTRY(IndexPointerEXT),
@@ -6386,8 +6483,8 @@ _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(PointParameterfvEXT),
    TABLE_ENTRY(LockArraysEXT),
    TABLE_ENTRY(UnlockArraysEXT),
-   TABLE_ENTRY(_dispatch_stub_596),
-   TABLE_ENTRY(_dispatch_stub_597),
+   TABLE_ENTRY(_dispatch_stub_598),
+   TABLE_ENTRY(_dispatch_stub_599),
    TABLE_ENTRY(SecondaryColor3bEXT),
    TABLE_ENTRY(SecondaryColor3bvEXT),
    TABLE_ENTRY(SecondaryColor3dEXT),
@@ -6412,7 +6509,7 @@ _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(FogCoorddvEXT),
    TABLE_ENTRY(FogCoordfEXT),
    TABLE_ENTRY(FogCoordfvEXT),
-   TABLE_ENTRY(_dispatch_stub_622),
+   TABLE_ENTRY(_dispatch_stub_624),
    TABLE_ENTRY(BlendFuncSeparateEXT),
    TABLE_ENTRY(FlushVertexArrayRangeNV),
    TABLE_ENTRY(VertexArrayRangeNV),
@@ -6454,8 +6551,6 @@ _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(WindowPos4ivMESA),
    TABLE_ENTRY(WindowPos4sMESA),
    TABLE_ENTRY(WindowPos4svMESA),
-   TABLE_ENTRY(_dispatch_stub_664),
-   TABLE_ENTRY(_dispatch_stub_665),
    TABLE_ENTRY(_dispatch_stub_666),
    TABLE_ENTRY(_dispatch_stub_667),
    TABLE_ENTRY(_dispatch_stub_668),
@@ -6463,6 +6558,8 @@ _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(_dispatch_stub_670),
    TABLE_ENTRY(_dispatch_stub_671),
    TABLE_ENTRY(_dispatch_stub_672),
+   TABLE_ENTRY(_dispatch_stub_673),
+   TABLE_ENTRY(_dispatch_stub_674),
    TABLE_ENTRY(AreProgramsResidentNV),
    TABLE_ENTRY(BindProgramNV),
    TABLE_ENTRY(DeleteProgramsNV),
@@ -6543,19 +6640,19 @@ _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(SetFragmentShaderConstantATI),
    TABLE_ENTRY(PointParameteriNV),
    TABLE_ENTRY(PointParameterivNV),
-   TABLE_ENTRY(_dispatch_stub_753),
-   TABLE_ENTRY(_dispatch_stub_754),
    TABLE_ENTRY(_dispatch_stub_755),
    TABLE_ENTRY(_dispatch_stub_756),
    TABLE_ENTRY(_dispatch_stub_757),
+   TABLE_ENTRY(_dispatch_stub_758),
+   TABLE_ENTRY(_dispatch_stub_759),
    TABLE_ENTRY(GetProgramNamedParameterdvNV),
    TABLE_ENTRY(GetProgramNamedParameterfvNV),
    TABLE_ENTRY(ProgramNamedParameter4dNV),
    TABLE_ENTRY(ProgramNamedParameter4dvNV),
    TABLE_ENTRY(ProgramNamedParameter4fNV),
    TABLE_ENTRY(ProgramNamedParameter4fvNV),
-   TABLE_ENTRY(_dispatch_stub_764),
-   TABLE_ENTRY(_dispatch_stub_765),
+   TABLE_ENTRY(_dispatch_stub_766),
+   TABLE_ENTRY(_dispatch_stub_767),
    TABLE_ENTRY(BindFramebufferEXT),
    TABLE_ENTRY(BindRenderbufferEXT),
    TABLE_ENTRY(CheckFramebufferStatusEXT),
@@ -6573,9 +6670,9 @@ _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(IsFramebufferEXT),
    TABLE_ENTRY(IsRenderbufferEXT),
    TABLE_ENTRY(RenderbufferStorageEXT),
-   TABLE_ENTRY(_dispatch_stub_783),
-   TABLE_ENTRY(_dispatch_stub_784),
    TABLE_ENTRY(_dispatch_stub_785),
+   TABLE_ENTRY(_dispatch_stub_786),
+   TABLE_ENTRY(_dispatch_stub_787),
    TABLE_ENTRY(FramebufferTextureLayerEXT),
    TABLE_ENTRY(ColorMaskIndexedEXT),
    TABLE_ENTRY(DisableIndexedEXT),
@@ -6585,17 +6682,24 @@ _glapi_proc DISPATCH_TABLE_NAME[] = {
    TABLE_ENTRY(IsEnabledIndexedEXT),
    TABLE_ENTRY(BeginConditionalRenderNV),
    TABLE_ENTRY(EndConditionalRenderNV),
+   TABLE_ENTRY(BeginTransformFeedbackEXT),
+   TABLE_ENTRY(BindBufferBaseEXT),
+   TABLE_ENTRY(BindBufferOffsetEXT),
+   TABLE_ENTRY(BindBufferRangeEXT),
+   TABLE_ENTRY(EndTransformFeedbackEXT),
+   TABLE_ENTRY(GetTransformFeedbackVaryingEXT),
+   TABLE_ENTRY(TransformFeedbackVaryingsEXT),
    TABLE_ENTRY(ProvokingVertexEXT),
-   TABLE_ENTRY(_dispatch_stub_796),
-   TABLE_ENTRY(_dispatch_stub_797),
+   TABLE_ENTRY(_dispatch_stub_805),
+   TABLE_ENTRY(_dispatch_stub_806),
    TABLE_ENTRY(GetObjectParameterivAPPLE),
    TABLE_ENTRY(ObjectPurgeableAPPLE),
    TABLE_ENTRY(ObjectUnpurgeableAPPLE),
-   TABLE_ENTRY(_dispatch_stub_801),
-   TABLE_ENTRY(_dispatch_stub_802),
-   TABLE_ENTRY(_dispatch_stub_803),
-   TABLE_ENTRY(_dispatch_stub_804),
-   TABLE_ENTRY(_dispatch_stub_805),
+   TABLE_ENTRY(_dispatch_stub_810),
+   TABLE_ENTRY(_dispatch_stub_811),
+   TABLE_ENTRY(_dispatch_stub_812),
+   TABLE_ENTRY(_dispatch_stub_813),
+   TABLE_ENTRY(_dispatch_stub_814),
    TABLE_ENTRY(EGLImageTargetRenderbufferStorageOES),
    TABLE_ENTRY(EGLImageTargetTexture2DOES),
    /* A whole bunch of no-op functions.  These might be called
@@ -6784,6 +6888,10 @@ _glapi_proc UNUSED_TABLE_NAME[] = {
    TABLE_ENTRY(MultiTexCoord4s),
    TABLE_ENTRY(MultiTexCoord4sv),
    TABLE_ENTRY(_dispatch_stub_423),
+   TABLE_ENTRY(DrawArraysInstancedARB),
+   TABLE_ENTRY(DrawArraysInstancedEXT),
+   TABLE_ENTRY(DrawElementsInstancedARB),
+   TABLE_ENTRY(DrawElementsInstancedEXT),
    TABLE_ENTRY(LoadTransposeMatrixd),
    TABLE_ENTRY(LoadTransposeMatrixf),
    TABLE_ENTRY(MultTransposeMatrixd),
@@ -6898,10 +7006,10 @@ _glapi_proc UNUSED_TABLE_NAME[] = {
    TABLE_ENTRY(RenderbufferStorageMultisampleEXT),
    TABLE_ENTRY(PointParameterf),
    TABLE_ENTRY(PointParameterfARB),
-   TABLE_ENTRY(_dispatch_stub_592),
+   TABLE_ENTRY(_dispatch_stub_594),
    TABLE_ENTRY(PointParameterfv),
    TABLE_ENTRY(PointParameterfvARB),
-   TABLE_ENTRY(_dispatch_stub_593),
+   TABLE_ENTRY(_dispatch_stub_595),
    TABLE_ENTRY(SecondaryColor3b),
    TABLE_ENTRY(SecondaryColor3bv),
    TABLE_ENTRY(SecondaryColor3d),
@@ -6927,7 +7035,7 @@ _glapi_proc UNUSED_TABLE_NAME[] = {
    TABLE_ENTRY(FogCoordf),
    TABLE_ENTRY(FogCoordfv),
    TABLE_ENTRY(BlendFuncSeparate),
-   TABLE_ENTRY(_dispatch_stub_623),
+   TABLE_ENTRY(_dispatch_stub_625),
    TABLE_ENTRY(WindowPos2d),
    TABLE_ENTRY(WindowPos2dARB),
    TABLE_ENTRY(WindowPos2dv),
@@ -6990,6 +7098,12 @@ _glapi_proc UNUSED_TABLE_NAME[] = {
    TABLE_ENTRY(RenderbufferStorage),
    TABLE_ENTRY(BlitFramebuffer),
    TABLE_ENTRY(FramebufferTextureLayer),
+   TABLE_ENTRY(BeginTransformFeedback),
+   TABLE_ENTRY(BindBufferBase),
+   TABLE_ENTRY(BindBufferRange),
+   TABLE_ENTRY(EndTransformFeedback),
+   TABLE_ENTRY(GetTransformFeedbackVarying),
+   TABLE_ENTRY(TransformFeedbackVaryings),
    TABLE_ENTRY(ProvokingVertex),
 #endif /* _GLAPI_SKIP_NORMAL_ENTRY_POINTS */
 #ifndef _GLAPI_SKIP_PROTO_ENTRY_POINTS
diff --git a/src/mesa/glapi/glprocs.h b/src/mesa/glapi/glprocs.h
index 44861863e63..8eb04ee6781 100644
--- a/src/mesa/glapi/glprocs.h
+++ b/src/mesa/glapi/glprocs.h
@@ -482,6 +482,8 @@ static const char gl_string_table[] =
     "glUniformMatrix3x4fv\0"
     "glUniformMatrix4x2fv\0"
     "glUniformMatrix4x3fv\0"
+    "glDrawArraysInstanced\0"
+    "glDrawElementsInstanced\0"
     "glLoadTransposeMatrixdARB\0"
     "glLoadTransposeMatrixfARB\0"
     "glMultTransposeMatrixdARB\0"
@@ -847,6 +849,13 @@ static const char gl_string_table[] =
     "glIsEnabledIndexedEXT\0"
     "glBeginConditionalRenderNV\0"
     "glEndConditionalRenderNV\0"
+    "glBeginTransformFeedbackEXT\0"
+    "glBindBufferBaseEXT\0"
+    "glBindBufferOffsetEXT\0"
+    "glBindBufferRangeEXT\0"
+    "glEndTransformFeedbackEXT\0"
+    "glGetTransformFeedbackVaryingEXT\0"
+    "glTransformFeedbackVaryingsEXT\0"
     "glProvokingVertexEXT\0"
     "glGetTexParameterPointervAPPLE\0"
     "glTextureRangeAPPLE\0"
@@ -952,6 +961,10 @@ static const char gl_string_table[] =
     "glMultiTexCoord4s\0"
     "glMultiTexCoord4sv\0"
     "glStencilOpSeparateATI\0"
+    "glDrawArraysInstancedARB\0"
+    "glDrawArraysInstancedEXT\0"
+    "glDrawElementsInstancedARB\0"
+    "glDrawElementsInstancedEXT\0"
     "glLoadTransposeMatrixd\0"
     "glLoadTransposeMatrixf\0"
     "glMultTransposeMatrixd\0"
@@ -1161,6 +1174,12 @@ static const char gl_string_table[] =
     "glRenderbufferStorage\0"
     "glBlitFramebuffer\0"
     "glFramebufferTextureLayer\0"
+    "glBeginTransformFeedback\0"
+    "glBindBufferBase\0"
+    "glBindBufferRange\0"
+    "glEndTransformFeedback\0"
+    "glGetTransformFeedbackVarying\0"
+    "glTransformFeedbackVaryings\0"
     "glProvokingVertex\0"
     ;
 
@@ -1179,19 +1198,17 @@ static const char gl_string_table[] =
 #define gl_dispatch_stub_364 mgl_dispatch_stub_364
 #define gl_dispatch_stub_365 mgl_dispatch_stub_365
 #define gl_dispatch_stub_366 mgl_dispatch_stub_366
-#define gl_dispatch_stub_578 mgl_dispatch_stub_578
-#define gl_dispatch_stub_579 mgl_dispatch_stub_579
 #define gl_dispatch_stub_580 mgl_dispatch_stub_580
 #define gl_dispatch_stub_581 mgl_dispatch_stub_581
 #define gl_dispatch_stub_582 mgl_dispatch_stub_582
 #define gl_dispatch_stub_583 mgl_dispatch_stub_583
 #define gl_dispatch_stub_584 mgl_dispatch_stub_584
 #define gl_dispatch_stub_585 mgl_dispatch_stub_585
-#define gl_dispatch_stub_596 mgl_dispatch_stub_596
-#define gl_dispatch_stub_597 mgl_dispatch_stub_597
-#define gl_dispatch_stub_622 mgl_dispatch_stub_622
-#define gl_dispatch_stub_664 mgl_dispatch_stub_664
-#define gl_dispatch_stub_665 mgl_dispatch_stub_665
+#define gl_dispatch_stub_586 mgl_dispatch_stub_586
+#define gl_dispatch_stub_587 mgl_dispatch_stub_587
+#define gl_dispatch_stub_598 mgl_dispatch_stub_598
+#define gl_dispatch_stub_599 mgl_dispatch_stub_599
+#define gl_dispatch_stub_624 mgl_dispatch_stub_624
 #define gl_dispatch_stub_666 mgl_dispatch_stub_666
 #define gl_dispatch_stub_667 mgl_dispatch_stub_667
 #define gl_dispatch_stub_668 mgl_dispatch_stub_668
@@ -1199,23 +1216,25 @@ static const char gl_string_table[] =
 #define gl_dispatch_stub_670 mgl_dispatch_stub_670
 #define gl_dispatch_stub_671 mgl_dispatch_stub_671
 #define gl_dispatch_stub_672 mgl_dispatch_stub_672
-#define gl_dispatch_stub_753 mgl_dispatch_stub_753
-#define gl_dispatch_stub_754 mgl_dispatch_stub_754
+#define gl_dispatch_stub_673 mgl_dispatch_stub_673
+#define gl_dispatch_stub_674 mgl_dispatch_stub_674
 #define gl_dispatch_stub_755 mgl_dispatch_stub_755
 #define gl_dispatch_stub_756 mgl_dispatch_stub_756
 #define gl_dispatch_stub_757 mgl_dispatch_stub_757
-#define gl_dispatch_stub_764 mgl_dispatch_stub_764
-#define gl_dispatch_stub_765 mgl_dispatch_stub_765
-#define gl_dispatch_stub_783 mgl_dispatch_stub_783
-#define gl_dispatch_stub_784 mgl_dispatch_stub_784
+#define gl_dispatch_stub_758 mgl_dispatch_stub_758
+#define gl_dispatch_stub_759 mgl_dispatch_stub_759
+#define gl_dispatch_stub_766 mgl_dispatch_stub_766
+#define gl_dispatch_stub_767 mgl_dispatch_stub_767
 #define gl_dispatch_stub_785 mgl_dispatch_stub_785
-#define gl_dispatch_stub_796 mgl_dispatch_stub_796
-#define gl_dispatch_stub_797 mgl_dispatch_stub_797
-#define gl_dispatch_stub_801 mgl_dispatch_stub_801
-#define gl_dispatch_stub_802 mgl_dispatch_stub_802
-#define gl_dispatch_stub_803 mgl_dispatch_stub_803
-#define gl_dispatch_stub_804 mgl_dispatch_stub_804
+#define gl_dispatch_stub_786 mgl_dispatch_stub_786
+#define gl_dispatch_stub_787 mgl_dispatch_stub_787
 #define gl_dispatch_stub_805 mgl_dispatch_stub_805
+#define gl_dispatch_stub_806 mgl_dispatch_stub_806
+#define gl_dispatch_stub_810 mgl_dispatch_stub_810
+#define gl_dispatch_stub_811 mgl_dispatch_stub_811
+#define gl_dispatch_stub_812 mgl_dispatch_stub_812
+#define gl_dispatch_stub_813 mgl_dispatch_stub_813
+#define gl_dispatch_stub_814 mgl_dispatch_stub_814
 #endif /* USE_MGL_NAMESPACE */
 
 
@@ -1233,43 +1252,43 @@ void GLAPIENTRY gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params
 void GLAPIENTRY gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values);
 void GLAPIENTRY gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params);
 void GLAPIENTRY gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params);
-void GLAPIENTRY gl_dispatch_stub_578(GLenum pname, GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_579(GLenum pname, GLint * params);
-void GLAPIENTRY gl_dispatch_stub_580(GLenum pname, GLfloat param);
-void GLAPIENTRY gl_dispatch_stub_581(GLenum pname, const GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_582(GLenum pname, GLint param);
-void GLAPIENTRY gl_dispatch_stub_583(GLenum pname, const GLint * params);
-void GLAPIENTRY gl_dispatch_stub_584(GLclampf value, GLboolean invert);
-void GLAPIENTRY gl_dispatch_stub_585(GLenum pattern);
-void GLAPIENTRY gl_dispatch_stub_596(GLenum pname, GLdouble * params);
-void GLAPIENTRY gl_dispatch_stub_597(GLenum pname, GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_622(GLenum mode);
-void GLAPIENTRY gl_dispatch_stub_664(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
-void GLAPIENTRY gl_dispatch_stub_665(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
-void GLAPIENTRY gl_dispatch_stub_666(GLsizei n, const GLuint * fences);
-void GLAPIENTRY gl_dispatch_stub_667(GLuint fence);
-void GLAPIENTRY gl_dispatch_stub_668(GLsizei n, GLuint * fences);
-void GLAPIENTRY gl_dispatch_stub_669(GLuint fence, GLenum pname, GLint * params);
-GLboolean GLAPIENTRY gl_dispatch_stub_670(GLuint fence);
-void GLAPIENTRY gl_dispatch_stub_671(GLuint fence, GLenum condition);
+void GLAPIENTRY gl_dispatch_stub_580(GLenum pname, GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_581(GLenum pname, GLint * params);
+void GLAPIENTRY gl_dispatch_stub_582(GLenum pname, GLfloat param);
+void GLAPIENTRY gl_dispatch_stub_583(GLenum pname, const GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_584(GLenum pname, GLint param);
+void GLAPIENTRY gl_dispatch_stub_585(GLenum pname, const GLint * params);
+void GLAPIENTRY gl_dispatch_stub_586(GLclampf value, GLboolean invert);
+void GLAPIENTRY gl_dispatch_stub_587(GLenum pattern);
+void GLAPIENTRY gl_dispatch_stub_598(GLenum pname, GLdouble * params);
+void GLAPIENTRY gl_dispatch_stub_599(GLenum pname, GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_624(GLenum mode);
+void GLAPIENTRY gl_dispatch_stub_666(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride);
+void GLAPIENTRY gl_dispatch_stub_667(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride);
+void GLAPIENTRY gl_dispatch_stub_668(GLsizei n, const GLuint * fences);
+void GLAPIENTRY gl_dispatch_stub_669(GLuint fence);
+void GLAPIENTRY gl_dispatch_stub_670(GLsizei n, GLuint * fences);
+void GLAPIENTRY gl_dispatch_stub_671(GLuint fence, GLenum pname, GLint * params);
 GLboolean GLAPIENTRY gl_dispatch_stub_672(GLuint fence);
-void GLAPIENTRY gl_dispatch_stub_753(GLenum face);
-void GLAPIENTRY gl_dispatch_stub_754(GLuint array);
-void GLAPIENTRY gl_dispatch_stub_755(GLsizei n, const GLuint * arrays);
-void GLAPIENTRY gl_dispatch_stub_756(GLsizei n, GLuint * arrays);
-GLboolean GLAPIENTRY gl_dispatch_stub_757(GLuint array);
-void GLAPIENTRY gl_dispatch_stub_764(GLclampd zmin, GLclampd zmax);
-void GLAPIENTRY gl_dispatch_stub_765(GLenum modeRGB, GLenum modeA);
-void GLAPIENTRY gl_dispatch_stub_783(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-void GLAPIENTRY gl_dispatch_stub_784(GLenum target, GLenum pname, GLint param);
-void GLAPIENTRY gl_dispatch_stub_785(GLenum target, GLintptr offset, GLsizeiptr size);
-void GLAPIENTRY gl_dispatch_stub_796(GLenum target, GLenum pname, GLvoid ** params);
-void GLAPIENTRY gl_dispatch_stub_797(GLenum target, GLsizei length, GLvoid * pointer);
-void GLAPIENTRY gl_dispatch_stub_801(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
-void GLAPIENTRY gl_dispatch_stub_802(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_803(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
-void GLAPIENTRY gl_dispatch_stub_804(GLuint id, GLenum pname, GLint64EXT * params);
-void GLAPIENTRY gl_dispatch_stub_805(GLuint id, GLenum pname, GLuint64EXT * params);
+void GLAPIENTRY gl_dispatch_stub_673(GLuint fence, GLenum condition);
+GLboolean GLAPIENTRY gl_dispatch_stub_674(GLuint fence);
+void GLAPIENTRY gl_dispatch_stub_755(GLenum face);
+void GLAPIENTRY gl_dispatch_stub_756(GLuint array);
+void GLAPIENTRY gl_dispatch_stub_757(GLsizei n, const GLuint * arrays);
+void GLAPIENTRY gl_dispatch_stub_758(GLsizei n, GLuint * arrays);
+GLboolean GLAPIENTRY gl_dispatch_stub_759(GLuint array);
+void GLAPIENTRY gl_dispatch_stub_766(GLclampd zmin, GLclampd zmax);
+void GLAPIENTRY gl_dispatch_stub_767(GLenum modeRGB, GLenum modeA);
+void GLAPIENTRY gl_dispatch_stub_785(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+void GLAPIENTRY gl_dispatch_stub_786(GLenum target, GLenum pname, GLint param);
+void GLAPIENTRY gl_dispatch_stub_787(GLenum target, GLintptr offset, GLsizeiptr size);
+void GLAPIENTRY gl_dispatch_stub_805(GLenum target, GLenum pname, GLvoid ** params);
+void GLAPIENTRY gl_dispatch_stub_806(GLenum target, GLsizei length, GLvoid * pointer);
+void GLAPIENTRY gl_dispatch_stub_810(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+void GLAPIENTRY gl_dispatch_stub_811(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_812(GLenum target, GLuint index, GLsizei count, const GLfloat * params);
+void GLAPIENTRY gl_dispatch_stub_813(GLuint id, GLenum pname, GLint64EXT * params);
+void GLAPIENTRY gl_dispatch_stub_814(GLuint id, GLenum pname, GLuint64EXT * params);
 #endif /* defined(NEED_FUNCTION_POINTER) || defined(GLX_INDIRECT_RENDERING) */
 
 static const glprocs_table_t static_functions[] = {
@@ -1703,686 +1722,705 @@ static const glprocs_table_t static_functions[] = {
     NAME_FUNC_OFFSET( 6100, glUniformMatrix3x4fv, glUniformMatrix3x4fv, NULL, _gloffset_UniformMatrix3x4fv),
     NAME_FUNC_OFFSET( 6121, glUniformMatrix4x2fv, glUniformMatrix4x2fv, NULL, _gloffset_UniformMatrix4x2fv),
     NAME_FUNC_OFFSET( 6142, glUniformMatrix4x3fv, glUniformMatrix4x3fv, NULL, _gloffset_UniformMatrix4x3fv),
-    NAME_FUNC_OFFSET( 6163, glLoadTransposeMatrixdARB, glLoadTransposeMatrixdARB, NULL, _gloffset_LoadTransposeMatrixdARB),
-    NAME_FUNC_OFFSET( 6189, glLoadTransposeMatrixfARB, glLoadTransposeMatrixfARB, NULL, _gloffset_LoadTransposeMatrixfARB),
-    NAME_FUNC_OFFSET( 6215, glMultTransposeMatrixdARB, glMultTransposeMatrixdARB, NULL, _gloffset_MultTransposeMatrixdARB),
-    NAME_FUNC_OFFSET( 6241, glMultTransposeMatrixfARB, glMultTransposeMatrixfARB, NULL, _gloffset_MultTransposeMatrixfARB),
-    NAME_FUNC_OFFSET( 6267, glSampleCoverageARB, glSampleCoverageARB, NULL, _gloffset_SampleCoverageARB),
-    NAME_FUNC_OFFSET( 6287, glCompressedTexImage1DARB, glCompressedTexImage1DARB, NULL, _gloffset_CompressedTexImage1DARB),
-    NAME_FUNC_OFFSET( 6313, glCompressedTexImage2DARB, glCompressedTexImage2DARB, NULL, _gloffset_CompressedTexImage2DARB),
-    NAME_FUNC_OFFSET( 6339, glCompressedTexImage3DARB, glCompressedTexImage3DARB, NULL, _gloffset_CompressedTexImage3DARB),
-    NAME_FUNC_OFFSET( 6365, glCompressedTexSubImage1DARB, glCompressedTexSubImage1DARB, NULL, _gloffset_CompressedTexSubImage1DARB),
-    NAME_FUNC_OFFSET( 6394, glCompressedTexSubImage2DARB, glCompressedTexSubImage2DARB, NULL, _gloffset_CompressedTexSubImage2DARB),
-    NAME_FUNC_OFFSET( 6423, glCompressedTexSubImage3DARB, glCompressedTexSubImage3DARB, NULL, _gloffset_CompressedTexSubImage3DARB),
-    NAME_FUNC_OFFSET( 6452, glGetCompressedTexImageARB, glGetCompressedTexImageARB, NULL, _gloffset_GetCompressedTexImageARB),
-    NAME_FUNC_OFFSET( 6479, glDisableVertexAttribArrayARB, glDisableVertexAttribArrayARB, NULL, _gloffset_DisableVertexAttribArrayARB),
-    NAME_FUNC_OFFSET( 6509, glEnableVertexAttribArrayARB, glEnableVertexAttribArrayARB, NULL, _gloffset_EnableVertexAttribArrayARB),
-    NAME_FUNC_OFFSET( 6538, glGetProgramEnvParameterdvARB, glGetProgramEnvParameterdvARB, NULL, _gloffset_GetProgramEnvParameterdvARB),
-    NAME_FUNC_OFFSET( 6568, glGetProgramEnvParameterfvARB, glGetProgramEnvParameterfvARB, NULL, _gloffset_GetProgramEnvParameterfvARB),
-    NAME_FUNC_OFFSET( 6598, glGetProgramLocalParameterdvARB, glGetProgramLocalParameterdvARB, NULL, _gloffset_GetProgramLocalParameterdvARB),
-    NAME_FUNC_OFFSET( 6630, glGetProgramLocalParameterfvARB, glGetProgramLocalParameterfvARB, NULL, _gloffset_GetProgramLocalParameterfvARB),
-    NAME_FUNC_OFFSET( 6662, glGetProgramStringARB, glGetProgramStringARB, NULL, _gloffset_GetProgramStringARB),
-    NAME_FUNC_OFFSET( 6684, glGetProgramivARB, glGetProgramivARB, NULL, _gloffset_GetProgramivARB),
-    NAME_FUNC_OFFSET( 6702, glGetVertexAttribdvARB, glGetVertexAttribdvARB, NULL, _gloffset_GetVertexAttribdvARB),
-    NAME_FUNC_OFFSET( 6725, glGetVertexAttribfvARB, glGetVertexAttribfvARB, NULL, _gloffset_GetVertexAttribfvARB),
-    NAME_FUNC_OFFSET( 6748, glGetVertexAttribivARB, glGetVertexAttribivARB, NULL, _gloffset_GetVertexAttribivARB),
-    NAME_FUNC_OFFSET( 6771, glProgramEnvParameter4dARB, glProgramEnvParameter4dARB, NULL, _gloffset_ProgramEnvParameter4dARB),
-    NAME_FUNC_OFFSET( 6798, glProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB, NULL, _gloffset_ProgramEnvParameter4dvARB),
-    NAME_FUNC_OFFSET( 6826, glProgramEnvParameter4fARB, glProgramEnvParameter4fARB, NULL, _gloffset_ProgramEnvParameter4fARB),
-    NAME_FUNC_OFFSET( 6853, glProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB, NULL, _gloffset_ProgramEnvParameter4fvARB),
-    NAME_FUNC_OFFSET( 6881, glProgramLocalParameter4dARB, glProgramLocalParameter4dARB, NULL, _gloffset_ProgramLocalParameter4dARB),
-    NAME_FUNC_OFFSET( 6910, glProgramLocalParameter4dvARB, glProgramLocalParameter4dvARB, NULL, _gloffset_ProgramLocalParameter4dvARB),
-    NAME_FUNC_OFFSET( 6940, glProgramLocalParameter4fARB, glProgramLocalParameter4fARB, NULL, _gloffset_ProgramLocalParameter4fARB),
-    NAME_FUNC_OFFSET( 6969, glProgramLocalParameter4fvARB, glProgramLocalParameter4fvARB, NULL, _gloffset_ProgramLocalParameter4fvARB),
-    NAME_FUNC_OFFSET( 6999, glProgramStringARB, glProgramStringARB, NULL, _gloffset_ProgramStringARB),
-    NAME_FUNC_OFFSET( 7018, glVertexAttrib1dARB, glVertexAttrib1dARB, NULL, _gloffset_VertexAttrib1dARB),
-    NAME_FUNC_OFFSET( 7038, glVertexAttrib1dvARB, glVertexAttrib1dvARB, NULL, _gloffset_VertexAttrib1dvARB),
-    NAME_FUNC_OFFSET( 7059, glVertexAttrib1fARB, glVertexAttrib1fARB, NULL, _gloffset_VertexAttrib1fARB),
-    NAME_FUNC_OFFSET( 7079, glVertexAttrib1fvARB, glVertexAttrib1fvARB, NULL, _gloffset_VertexAttrib1fvARB),
-    NAME_FUNC_OFFSET( 7100, glVertexAttrib1sARB, glVertexAttrib1sARB, NULL, _gloffset_VertexAttrib1sARB),
-    NAME_FUNC_OFFSET( 7120, glVertexAttrib1svARB, glVertexAttrib1svARB, NULL, _gloffset_VertexAttrib1svARB),
-    NAME_FUNC_OFFSET( 7141, glVertexAttrib2dARB, glVertexAttrib2dARB, NULL, _gloffset_VertexAttrib2dARB),
-    NAME_FUNC_OFFSET( 7161, glVertexAttrib2dvARB, glVertexAttrib2dvARB, NULL, _gloffset_VertexAttrib2dvARB),
-    NAME_FUNC_OFFSET( 7182, glVertexAttrib2fARB, glVertexAttrib2fARB, NULL, _gloffset_VertexAttrib2fARB),
-    NAME_FUNC_OFFSET( 7202, glVertexAttrib2fvARB, glVertexAttrib2fvARB, NULL, _gloffset_VertexAttrib2fvARB),
-    NAME_FUNC_OFFSET( 7223, glVertexAttrib2sARB, glVertexAttrib2sARB, NULL, _gloffset_VertexAttrib2sARB),
-    NAME_FUNC_OFFSET( 7243, glVertexAttrib2svARB, glVertexAttrib2svARB, NULL, _gloffset_VertexAttrib2svARB),
-    NAME_FUNC_OFFSET( 7264, glVertexAttrib3dARB, glVertexAttrib3dARB, NULL, _gloffset_VertexAttrib3dARB),
-    NAME_FUNC_OFFSET( 7284, glVertexAttrib3dvARB, glVertexAttrib3dvARB, NULL, _gloffset_VertexAttrib3dvARB),
-    NAME_FUNC_OFFSET( 7305, glVertexAttrib3fARB, glVertexAttrib3fARB, NULL, _gloffset_VertexAttrib3fARB),
-    NAME_FUNC_OFFSET( 7325, glVertexAttrib3fvARB, glVertexAttrib3fvARB, NULL, _gloffset_VertexAttrib3fvARB),
-    NAME_FUNC_OFFSET( 7346, glVertexAttrib3sARB, glVertexAttrib3sARB, NULL, _gloffset_VertexAttrib3sARB),
-    NAME_FUNC_OFFSET( 7366, glVertexAttrib3svARB, glVertexAttrib3svARB, NULL, _gloffset_VertexAttrib3svARB),
-    NAME_FUNC_OFFSET( 7387, glVertexAttrib4NbvARB, glVertexAttrib4NbvARB, NULL, _gloffset_VertexAttrib4NbvARB),
-    NAME_FUNC_OFFSET( 7409, glVertexAttrib4NivARB, glVertexAttrib4NivARB, NULL, _gloffset_VertexAttrib4NivARB),
-    NAME_FUNC_OFFSET( 7431, glVertexAttrib4NsvARB, glVertexAttrib4NsvARB, NULL, _gloffset_VertexAttrib4NsvARB),
-    NAME_FUNC_OFFSET( 7453, glVertexAttrib4NubARB, glVertexAttrib4NubARB, NULL, _gloffset_VertexAttrib4NubARB),
-    NAME_FUNC_OFFSET( 7475, glVertexAttrib4NubvARB, glVertexAttrib4NubvARB, NULL, _gloffset_VertexAttrib4NubvARB),
-    NAME_FUNC_OFFSET( 7498, glVertexAttrib4NuivARB, glVertexAttrib4NuivARB, NULL, _gloffset_VertexAttrib4NuivARB),
-    NAME_FUNC_OFFSET( 7521, glVertexAttrib4NusvARB, glVertexAttrib4NusvARB, NULL, _gloffset_VertexAttrib4NusvARB),
-    NAME_FUNC_OFFSET( 7544, glVertexAttrib4bvARB, glVertexAttrib4bvARB, NULL, _gloffset_VertexAttrib4bvARB),
-    NAME_FUNC_OFFSET( 7565, glVertexAttrib4dARB, glVertexAttrib4dARB, NULL, _gloffset_VertexAttrib4dARB),
-    NAME_FUNC_OFFSET( 7585, glVertexAttrib4dvARB, glVertexAttrib4dvARB, NULL, _gloffset_VertexAttrib4dvARB),
-    NAME_FUNC_OFFSET( 7606, glVertexAttrib4fARB, glVertexAttrib4fARB, NULL, _gloffset_VertexAttrib4fARB),
-    NAME_FUNC_OFFSET( 7626, glVertexAttrib4fvARB, glVertexAttrib4fvARB, NULL, _gloffset_VertexAttrib4fvARB),
-    NAME_FUNC_OFFSET( 7647, glVertexAttrib4ivARB, glVertexAttrib4ivARB, NULL, _gloffset_VertexAttrib4ivARB),
-    NAME_FUNC_OFFSET( 7668, glVertexAttrib4sARB, glVertexAttrib4sARB, NULL, _gloffset_VertexAttrib4sARB),
-    NAME_FUNC_OFFSET( 7688, glVertexAttrib4svARB, glVertexAttrib4svARB, NULL, _gloffset_VertexAttrib4svARB),
-    NAME_FUNC_OFFSET( 7709, glVertexAttrib4ubvARB, glVertexAttrib4ubvARB, NULL, _gloffset_VertexAttrib4ubvARB),
-    NAME_FUNC_OFFSET( 7731, glVertexAttrib4uivARB, glVertexAttrib4uivARB, NULL, _gloffset_VertexAttrib4uivARB),
-    NAME_FUNC_OFFSET( 7753, glVertexAttrib4usvARB, glVertexAttrib4usvARB, NULL, _gloffset_VertexAttrib4usvARB),
-    NAME_FUNC_OFFSET( 7775, glVertexAttribPointerARB, glVertexAttribPointerARB, NULL, _gloffset_VertexAttribPointerARB),
-    NAME_FUNC_OFFSET( 7800, glBindBufferARB, glBindBufferARB, NULL, _gloffset_BindBufferARB),
-    NAME_FUNC_OFFSET( 7816, glBufferDataARB, glBufferDataARB, NULL, _gloffset_BufferDataARB),
-    NAME_FUNC_OFFSET( 7832, glBufferSubDataARB, glBufferSubDataARB, NULL, _gloffset_BufferSubDataARB),
-    NAME_FUNC_OFFSET( 7851, glDeleteBuffersARB, glDeleteBuffersARB, NULL, _gloffset_DeleteBuffersARB),
-    NAME_FUNC_OFFSET( 7870, glGenBuffersARB, glGenBuffersARB, NULL, _gloffset_GenBuffersARB),
-    NAME_FUNC_OFFSET( 7886, glGetBufferParameterivARB, glGetBufferParameterivARB, NULL, _gloffset_GetBufferParameterivARB),
-    NAME_FUNC_OFFSET( 7912, glGetBufferPointervARB, glGetBufferPointervARB, NULL, _gloffset_GetBufferPointervARB),
-    NAME_FUNC_OFFSET( 7935, glGetBufferSubDataARB, glGetBufferSubDataARB, NULL, _gloffset_GetBufferSubDataARB),
-    NAME_FUNC_OFFSET( 7957, glIsBufferARB, glIsBufferARB, NULL, _gloffset_IsBufferARB),
-    NAME_FUNC_OFFSET( 7971, glMapBufferARB, glMapBufferARB, NULL, _gloffset_MapBufferARB),
-    NAME_FUNC_OFFSET( 7986, glUnmapBufferARB, glUnmapBufferARB, NULL, _gloffset_UnmapBufferARB),
-    NAME_FUNC_OFFSET( 8003, glBeginQueryARB, glBeginQueryARB, NULL, _gloffset_BeginQueryARB),
-    NAME_FUNC_OFFSET( 8019, glDeleteQueriesARB, glDeleteQueriesARB, NULL, _gloffset_DeleteQueriesARB),
-    NAME_FUNC_OFFSET( 8038, glEndQueryARB, glEndQueryARB, NULL, _gloffset_EndQueryARB),
-    NAME_FUNC_OFFSET( 8052, glGenQueriesARB, glGenQueriesARB, NULL, _gloffset_GenQueriesARB),
-    NAME_FUNC_OFFSET( 8068, glGetQueryObjectivARB, glGetQueryObjectivARB, NULL, _gloffset_GetQueryObjectivARB),
-    NAME_FUNC_OFFSET( 8090, glGetQueryObjectuivARB, glGetQueryObjectuivARB, NULL, _gloffset_GetQueryObjectuivARB),
-    NAME_FUNC_OFFSET( 8113, glGetQueryivARB, glGetQueryivARB, NULL, _gloffset_GetQueryivARB),
-    NAME_FUNC_OFFSET( 8129, glIsQueryARB, glIsQueryARB, NULL, _gloffset_IsQueryARB),
-    NAME_FUNC_OFFSET( 8142, glAttachObjectARB, glAttachObjectARB, NULL, _gloffset_AttachObjectARB),
-    NAME_FUNC_OFFSET( 8160, glCompileShaderARB, glCompileShaderARB, NULL, _gloffset_CompileShaderARB),
-    NAME_FUNC_OFFSET( 8179, glCreateProgramObjectARB, glCreateProgramObjectARB, NULL, _gloffset_CreateProgramObjectARB),
-    NAME_FUNC_OFFSET( 8204, glCreateShaderObjectARB, glCreateShaderObjectARB, NULL, _gloffset_CreateShaderObjectARB),
-    NAME_FUNC_OFFSET( 8228, glDeleteObjectARB, glDeleteObjectARB, NULL, _gloffset_DeleteObjectARB),
-    NAME_FUNC_OFFSET( 8246, glDetachObjectARB, glDetachObjectARB, NULL, _gloffset_DetachObjectARB),
-    NAME_FUNC_OFFSET( 8264, glGetActiveUniformARB, glGetActiveUniformARB, NULL, _gloffset_GetActiveUniformARB),
-    NAME_FUNC_OFFSET( 8286, glGetAttachedObjectsARB, glGetAttachedObjectsARB, NULL, _gloffset_GetAttachedObjectsARB),
-    NAME_FUNC_OFFSET( 8310, glGetHandleARB, glGetHandleARB, NULL, _gloffset_GetHandleARB),
-    NAME_FUNC_OFFSET( 8325, glGetInfoLogARB, glGetInfoLogARB, NULL, _gloffset_GetInfoLogARB),
-    NAME_FUNC_OFFSET( 8341, glGetObjectParameterfvARB, glGetObjectParameterfvARB, NULL, _gloffset_GetObjectParameterfvARB),
-    NAME_FUNC_OFFSET( 8367, glGetObjectParameterivARB, glGetObjectParameterivARB, NULL, _gloffset_GetObjectParameterivARB),
-    NAME_FUNC_OFFSET( 8393, glGetShaderSourceARB, glGetShaderSourceARB, NULL, _gloffset_GetShaderSourceARB),
-    NAME_FUNC_OFFSET( 8414, glGetUniformLocationARB, glGetUniformLocationARB, NULL, _gloffset_GetUniformLocationARB),
-    NAME_FUNC_OFFSET( 8438, glGetUniformfvARB, glGetUniformfvARB, NULL, _gloffset_GetUniformfvARB),
-    NAME_FUNC_OFFSET( 8456, glGetUniformivARB, glGetUniformivARB, NULL, _gloffset_GetUniformivARB),
-    NAME_FUNC_OFFSET( 8474, glLinkProgramARB, glLinkProgramARB, NULL, _gloffset_LinkProgramARB),
-    NAME_FUNC_OFFSET( 8491, glShaderSourceARB, glShaderSourceARB, NULL, _gloffset_ShaderSourceARB),
-    NAME_FUNC_OFFSET( 8509, glUniform1fARB, glUniform1fARB, NULL, _gloffset_Uniform1fARB),
-    NAME_FUNC_OFFSET( 8524, glUniform1fvARB, glUniform1fvARB, NULL, _gloffset_Uniform1fvARB),
-    NAME_FUNC_OFFSET( 8540, glUniform1iARB, glUniform1iARB, NULL, _gloffset_Uniform1iARB),
-    NAME_FUNC_OFFSET( 8555, glUniform1ivARB, glUniform1ivARB, NULL, _gloffset_Uniform1ivARB),
-    NAME_FUNC_OFFSET( 8571, glUniform2fARB, glUniform2fARB, NULL, _gloffset_Uniform2fARB),
-    NAME_FUNC_OFFSET( 8586, glUniform2fvARB, glUniform2fvARB, NULL, _gloffset_Uniform2fvARB),
-    NAME_FUNC_OFFSET( 8602, glUniform2iARB, glUniform2iARB, NULL, _gloffset_Uniform2iARB),
-    NAME_FUNC_OFFSET( 8617, glUniform2ivARB, glUniform2ivARB, NULL, _gloffset_Uniform2ivARB),
-    NAME_FUNC_OFFSET( 8633, glUniform3fARB, glUniform3fARB, NULL, _gloffset_Uniform3fARB),
-    NAME_FUNC_OFFSET( 8648, glUniform3fvARB, glUniform3fvARB, NULL, _gloffset_Uniform3fvARB),
-    NAME_FUNC_OFFSET( 8664, glUniform3iARB, glUniform3iARB, NULL, _gloffset_Uniform3iARB),
-    NAME_FUNC_OFFSET( 8679, glUniform3ivARB, glUniform3ivARB, NULL, _gloffset_Uniform3ivARB),
-    NAME_FUNC_OFFSET( 8695, glUniform4fARB, glUniform4fARB, NULL, _gloffset_Uniform4fARB),
-    NAME_FUNC_OFFSET( 8710, glUniform4fvARB, glUniform4fvARB, NULL, _gloffset_Uniform4fvARB),
-    NAME_FUNC_OFFSET( 8726, glUniform4iARB, glUniform4iARB, NULL, _gloffset_Uniform4iARB),
-    NAME_FUNC_OFFSET( 8741, glUniform4ivARB, glUniform4ivARB, NULL, _gloffset_Uniform4ivARB),
-    NAME_FUNC_OFFSET( 8757, glUniformMatrix2fvARB, glUniformMatrix2fvARB, NULL, _gloffset_UniformMatrix2fvARB),
-    NAME_FUNC_OFFSET( 8779, glUniformMatrix3fvARB, glUniformMatrix3fvARB, NULL, _gloffset_UniformMatrix3fvARB),
-    NAME_FUNC_OFFSET( 8801, glUniformMatrix4fvARB, glUniformMatrix4fvARB, NULL, _gloffset_UniformMatrix4fvARB),
-    NAME_FUNC_OFFSET( 8823, glUseProgramObjectARB, glUseProgramObjectARB, NULL, _gloffset_UseProgramObjectARB),
-    NAME_FUNC_OFFSET( 8845, glValidateProgramARB, glValidateProgramARB, NULL, _gloffset_ValidateProgramARB),
-    NAME_FUNC_OFFSET( 8866, glBindAttribLocationARB, glBindAttribLocationARB, NULL, _gloffset_BindAttribLocationARB),
-    NAME_FUNC_OFFSET( 8890, glGetActiveAttribARB, glGetActiveAttribARB, NULL, _gloffset_GetActiveAttribARB),
-    NAME_FUNC_OFFSET( 8911, glGetAttribLocationARB, glGetAttribLocationARB, NULL, _gloffset_GetAttribLocationARB),
-    NAME_FUNC_OFFSET( 8934, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
-    NAME_FUNC_OFFSET( 8951, glRenderbufferStorageMultisample, glRenderbufferStorageMultisample, NULL, _gloffset_RenderbufferStorageMultisample),
-    NAME_FUNC_OFFSET( 8984, glFlushMappedBufferRange, glFlushMappedBufferRange, NULL, _gloffset_FlushMappedBufferRange),
-    NAME_FUNC_OFFSET( 9009, glMapBufferRange, glMapBufferRange, NULL, _gloffset_MapBufferRange),
-    NAME_FUNC_OFFSET( 9026, glBindVertexArray, glBindVertexArray, NULL, _gloffset_BindVertexArray),
-    NAME_FUNC_OFFSET( 9044, glGenVertexArrays, glGenVertexArrays, NULL, _gloffset_GenVertexArrays),
-    NAME_FUNC_OFFSET( 9062, glCopyBufferSubData, glCopyBufferSubData, NULL, _gloffset_CopyBufferSubData),
-    NAME_FUNC_OFFSET( 9082, glClientWaitSync, glClientWaitSync, NULL, _gloffset_ClientWaitSync),
-    NAME_FUNC_OFFSET( 9099, glDeleteSync, glDeleteSync, NULL, _gloffset_DeleteSync),
-    NAME_FUNC_OFFSET( 9112, glFenceSync, glFenceSync, NULL, _gloffset_FenceSync),
-    NAME_FUNC_OFFSET( 9124, glGetInteger64v, glGetInteger64v, NULL, _gloffset_GetInteger64v),
-    NAME_FUNC_OFFSET( 9140, glGetSynciv, glGetSynciv, NULL, _gloffset_GetSynciv),
-    NAME_FUNC_OFFSET( 9152, glIsSync, glIsSync, NULL, _gloffset_IsSync),
-    NAME_FUNC_OFFSET( 9161, glWaitSync, glWaitSync, NULL, _gloffset_WaitSync),
-    NAME_FUNC_OFFSET( 9172, glDrawElementsBaseVertex, glDrawElementsBaseVertex, NULL, _gloffset_DrawElementsBaseVertex),
-    NAME_FUNC_OFFSET( 9197, glDrawRangeElementsBaseVertex, glDrawRangeElementsBaseVertex, NULL, _gloffset_DrawRangeElementsBaseVertex),
-    NAME_FUNC_OFFSET( 9227, glMultiDrawElementsBaseVertex, glMultiDrawElementsBaseVertex, NULL, _gloffset_MultiDrawElementsBaseVertex),
-    NAME_FUNC_OFFSET( 9257, glPolygonOffsetEXT, glPolygonOffsetEXT, NULL, _gloffset_PolygonOffsetEXT),
-    NAME_FUNC_OFFSET( 9276, gl_dispatch_stub_578, gl_dispatch_stub_578, NULL, _gloffset_GetPixelTexGenParameterfvSGIS),
-    NAME_FUNC_OFFSET( 9308, gl_dispatch_stub_579, gl_dispatch_stub_579, NULL, _gloffset_GetPixelTexGenParameterivSGIS),
-    NAME_FUNC_OFFSET( 9340, gl_dispatch_stub_580, gl_dispatch_stub_580, NULL, _gloffset_PixelTexGenParameterfSGIS),
-    NAME_FUNC_OFFSET( 9368, gl_dispatch_stub_581, gl_dispatch_stub_581, NULL, _gloffset_PixelTexGenParameterfvSGIS),
-    NAME_FUNC_OFFSET( 9397, gl_dispatch_stub_582, gl_dispatch_stub_582, NULL, _gloffset_PixelTexGenParameteriSGIS),
-    NAME_FUNC_OFFSET( 9425, gl_dispatch_stub_583, gl_dispatch_stub_583, NULL, _gloffset_PixelTexGenParameterivSGIS),
-    NAME_FUNC_OFFSET( 9454, gl_dispatch_stub_584, gl_dispatch_stub_584, NULL, _gloffset_SampleMaskSGIS),
-    NAME_FUNC_OFFSET( 9471, gl_dispatch_stub_585, gl_dispatch_stub_585, NULL, _gloffset_SamplePatternSGIS),
-    NAME_FUNC_OFFSET( 9491, glColorPointerEXT, glColorPointerEXT, NULL, _gloffset_ColorPointerEXT),
-    NAME_FUNC_OFFSET( 9509, glEdgeFlagPointerEXT, glEdgeFlagPointerEXT, NULL, _gloffset_EdgeFlagPointerEXT),
-    NAME_FUNC_OFFSET( 9530, glIndexPointerEXT, glIndexPointerEXT, NULL, _gloffset_IndexPointerEXT),
-    NAME_FUNC_OFFSET( 9548, glNormalPointerEXT, glNormalPointerEXT, NULL, _gloffset_NormalPointerEXT),
-    NAME_FUNC_OFFSET( 9567, glTexCoordPointerEXT, glTexCoordPointerEXT, NULL, _gloffset_TexCoordPointerEXT),
-    NAME_FUNC_OFFSET( 9588, glVertexPointerEXT, glVertexPointerEXT, NULL, _gloffset_VertexPointerEXT),
-    NAME_FUNC_OFFSET( 9607, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
-    NAME_FUNC_OFFSET( 9628, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
-    NAME_FUNC_OFFSET( 9650, glLockArraysEXT, glLockArraysEXT, NULL, _gloffset_LockArraysEXT),
-    NAME_FUNC_OFFSET( 9666, glUnlockArraysEXT, glUnlockArraysEXT, NULL, _gloffset_UnlockArraysEXT),
-    NAME_FUNC_OFFSET( 9684, gl_dispatch_stub_596, gl_dispatch_stub_596, NULL, _gloffset_CullParameterdvEXT),
-    NAME_FUNC_OFFSET( 9705, gl_dispatch_stub_597, gl_dispatch_stub_597, NULL, _gloffset_CullParameterfvEXT),
-    NAME_FUNC_OFFSET( 9726, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
-    NAME_FUNC_OFFSET( 9748, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
-    NAME_FUNC_OFFSET( 9771, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
-    NAME_FUNC_OFFSET( 9793, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
-    NAME_FUNC_OFFSET( 9816, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
-    NAME_FUNC_OFFSET( 9838, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
-    NAME_FUNC_OFFSET( 9861, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
-    NAME_FUNC_OFFSET( 9883, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
-    NAME_FUNC_OFFSET( 9906, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
-    NAME_FUNC_OFFSET( 9928, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
-    NAME_FUNC_OFFSET( 9951, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
-    NAME_FUNC_OFFSET( 9974, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
-    NAME_FUNC_OFFSET( 9998, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
-    NAME_FUNC_OFFSET(10021, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
-    NAME_FUNC_OFFSET(10045, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
-    NAME_FUNC_OFFSET(10068, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
-    NAME_FUNC_OFFSET(10092, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
-    NAME_FUNC_OFFSET(10119, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
-    NAME_FUNC_OFFSET(10140, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
-    NAME_FUNC_OFFSET(10163, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
-    NAME_FUNC_OFFSET(10184, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
-    NAME_FUNC_OFFSET(10199, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
-    NAME_FUNC_OFFSET(10215, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
-    NAME_FUNC_OFFSET(10230, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
-    NAME_FUNC_OFFSET(10246, gl_dispatch_stub_622, gl_dispatch_stub_622, NULL, _gloffset_PixelTexGenSGIX),
-    NAME_FUNC_OFFSET(10264, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
-    NAME_FUNC_OFFSET(10287, glFlushVertexArrayRangeNV, glFlushVertexArrayRangeNV, NULL, _gloffset_FlushVertexArrayRangeNV),
-    NAME_FUNC_OFFSET(10313, glVertexArrayRangeNV, glVertexArrayRangeNV, NULL, _gloffset_VertexArrayRangeNV),
-    NAME_FUNC_OFFSET(10334, glCombinerInputNV, glCombinerInputNV, NULL, _gloffset_CombinerInputNV),
-    NAME_FUNC_OFFSET(10352, glCombinerOutputNV, glCombinerOutputNV, NULL, _gloffset_CombinerOutputNV),
-    NAME_FUNC_OFFSET(10371, glCombinerParameterfNV, glCombinerParameterfNV, NULL, _gloffset_CombinerParameterfNV),
-    NAME_FUNC_OFFSET(10394, glCombinerParameterfvNV, glCombinerParameterfvNV, NULL, _gloffset_CombinerParameterfvNV),
-    NAME_FUNC_OFFSET(10418, glCombinerParameteriNV, glCombinerParameteriNV, NULL, _gloffset_CombinerParameteriNV),
-    NAME_FUNC_OFFSET(10441, glCombinerParameterivNV, glCombinerParameterivNV, NULL, _gloffset_CombinerParameterivNV),
-    NAME_FUNC_OFFSET(10465, glFinalCombinerInputNV, glFinalCombinerInputNV, NULL, _gloffset_FinalCombinerInputNV),
-    NAME_FUNC_OFFSET(10488, glGetCombinerInputParameterfvNV, glGetCombinerInputParameterfvNV, NULL, _gloffset_GetCombinerInputParameterfvNV),
-    NAME_FUNC_OFFSET(10520, glGetCombinerInputParameterivNV, glGetCombinerInputParameterivNV, NULL, _gloffset_GetCombinerInputParameterivNV),
-    NAME_FUNC_OFFSET(10552, glGetCombinerOutputParameterfvNV, glGetCombinerOutputParameterfvNV, NULL, _gloffset_GetCombinerOutputParameterfvNV),
-    NAME_FUNC_OFFSET(10585, glGetCombinerOutputParameterivNV, glGetCombinerOutputParameterivNV, NULL, _gloffset_GetCombinerOutputParameterivNV),
-    NAME_FUNC_OFFSET(10618, glGetFinalCombinerInputParameterfvNV, glGetFinalCombinerInputParameterfvNV, NULL, _gloffset_GetFinalCombinerInputParameterfvNV),
-    NAME_FUNC_OFFSET(10655, glGetFinalCombinerInputParameterivNV, glGetFinalCombinerInputParameterivNV, NULL, _gloffset_GetFinalCombinerInputParameterivNV),
-    NAME_FUNC_OFFSET(10692, glResizeBuffersMESA, glResizeBuffersMESA, NULL, _gloffset_ResizeBuffersMESA),
-    NAME_FUNC_OFFSET(10712, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
-    NAME_FUNC_OFFSET(10730, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
-    NAME_FUNC_OFFSET(10749, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
-    NAME_FUNC_OFFSET(10767, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
-    NAME_FUNC_OFFSET(10786, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
-    NAME_FUNC_OFFSET(10804, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
-    NAME_FUNC_OFFSET(10823, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
-    NAME_FUNC_OFFSET(10841, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
-    NAME_FUNC_OFFSET(10860, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
-    NAME_FUNC_OFFSET(10878, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
-    NAME_FUNC_OFFSET(10897, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
-    NAME_FUNC_OFFSET(10915, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
-    NAME_FUNC_OFFSET(10934, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
-    NAME_FUNC_OFFSET(10952, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
-    NAME_FUNC_OFFSET(10971, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
-    NAME_FUNC_OFFSET(10989, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
-    NAME_FUNC_OFFSET(11008, glWindowPos4dMESA, glWindowPos4dMESA, NULL, _gloffset_WindowPos4dMESA),
-    NAME_FUNC_OFFSET(11026, glWindowPos4dvMESA, glWindowPos4dvMESA, NULL, _gloffset_WindowPos4dvMESA),
-    NAME_FUNC_OFFSET(11045, glWindowPos4fMESA, glWindowPos4fMESA, NULL, _gloffset_WindowPos4fMESA),
-    NAME_FUNC_OFFSET(11063, glWindowPos4fvMESA, glWindowPos4fvMESA, NULL, _gloffset_WindowPos4fvMESA),
-    NAME_FUNC_OFFSET(11082, glWindowPos4iMESA, glWindowPos4iMESA, NULL, _gloffset_WindowPos4iMESA),
-    NAME_FUNC_OFFSET(11100, glWindowPos4ivMESA, glWindowPos4ivMESA, NULL, _gloffset_WindowPos4ivMESA),
-    NAME_FUNC_OFFSET(11119, glWindowPos4sMESA, glWindowPos4sMESA, NULL, _gloffset_WindowPos4sMESA),
-    NAME_FUNC_OFFSET(11137, glWindowPos4svMESA, glWindowPos4svMESA, NULL, _gloffset_WindowPos4svMESA),
-    NAME_FUNC_OFFSET(11156, gl_dispatch_stub_664, gl_dispatch_stub_664, NULL, _gloffset_MultiModeDrawArraysIBM),
-    NAME_FUNC_OFFSET(11181, gl_dispatch_stub_665, gl_dispatch_stub_665, NULL, _gloffset_MultiModeDrawElementsIBM),
-    NAME_FUNC_OFFSET(11208, gl_dispatch_stub_666, gl_dispatch_stub_666, NULL, _gloffset_DeleteFencesNV),
-    NAME_FUNC_OFFSET(11225, gl_dispatch_stub_667, gl_dispatch_stub_667, NULL, _gloffset_FinishFenceNV),
-    NAME_FUNC_OFFSET(11241, gl_dispatch_stub_668, gl_dispatch_stub_668, NULL, _gloffset_GenFencesNV),
-    NAME_FUNC_OFFSET(11255, gl_dispatch_stub_669, gl_dispatch_stub_669, NULL, _gloffset_GetFenceivNV),
-    NAME_FUNC_OFFSET(11270, gl_dispatch_stub_670, gl_dispatch_stub_670, NULL, _gloffset_IsFenceNV),
-    NAME_FUNC_OFFSET(11282, gl_dispatch_stub_671, gl_dispatch_stub_671, NULL, _gloffset_SetFenceNV),
-    NAME_FUNC_OFFSET(11295, gl_dispatch_stub_672, gl_dispatch_stub_672, NULL, _gloffset_TestFenceNV),
-    NAME_FUNC_OFFSET(11309, glAreProgramsResidentNV, glAreProgramsResidentNV, NULL, _gloffset_AreProgramsResidentNV),
-    NAME_FUNC_OFFSET(11333, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
-    NAME_FUNC_OFFSET(11349, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
-    NAME_FUNC_OFFSET(11368, glExecuteProgramNV, glExecuteProgramNV, NULL, _gloffset_ExecuteProgramNV),
-    NAME_FUNC_OFFSET(11387, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
-    NAME_FUNC_OFFSET(11403, glGetProgramParameterdvNV, glGetProgramParameterdvNV, NULL, _gloffset_GetProgramParameterdvNV),
-    NAME_FUNC_OFFSET(11429, glGetProgramParameterfvNV, glGetProgramParameterfvNV, NULL, _gloffset_GetProgramParameterfvNV),
-    NAME_FUNC_OFFSET(11455, glGetProgramStringNV, glGetProgramStringNV, NULL, _gloffset_GetProgramStringNV),
-    NAME_FUNC_OFFSET(11476, glGetProgramivNV, glGetProgramivNV, NULL, _gloffset_GetProgramivNV),
-    NAME_FUNC_OFFSET(11493, glGetTrackMatrixivNV, glGetTrackMatrixivNV, NULL, _gloffset_GetTrackMatrixivNV),
-    NAME_FUNC_OFFSET(11514, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
-    NAME_FUNC_OFFSET(11542, glGetVertexAttribdvNV, glGetVertexAttribdvNV, NULL, _gloffset_GetVertexAttribdvNV),
-    NAME_FUNC_OFFSET(11564, glGetVertexAttribfvNV, glGetVertexAttribfvNV, NULL, _gloffset_GetVertexAttribfvNV),
-    NAME_FUNC_OFFSET(11586, glGetVertexAttribivNV, glGetVertexAttribivNV, NULL, _gloffset_GetVertexAttribivNV),
-    NAME_FUNC_OFFSET(11608, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
-    NAME_FUNC_OFFSET(11622, glLoadProgramNV, glLoadProgramNV, NULL, _gloffset_LoadProgramNV),
-    NAME_FUNC_OFFSET(11638, glProgramParameters4dvNV, glProgramParameters4dvNV, NULL, _gloffset_ProgramParameters4dvNV),
-    NAME_FUNC_OFFSET(11663, glProgramParameters4fvNV, glProgramParameters4fvNV, NULL, _gloffset_ProgramParameters4fvNV),
-    NAME_FUNC_OFFSET(11688, glRequestResidentProgramsNV, glRequestResidentProgramsNV, NULL, _gloffset_RequestResidentProgramsNV),
-    NAME_FUNC_OFFSET(11716, glTrackMatrixNV, glTrackMatrixNV, NULL, _gloffset_TrackMatrixNV),
-    NAME_FUNC_OFFSET(11732, glVertexAttrib1dNV, glVertexAttrib1dNV, NULL, _gloffset_VertexAttrib1dNV),
-    NAME_FUNC_OFFSET(11751, glVertexAttrib1dvNV, glVertexAttrib1dvNV, NULL, _gloffset_VertexAttrib1dvNV),
-    NAME_FUNC_OFFSET(11771, glVertexAttrib1fNV, glVertexAttrib1fNV, NULL, _gloffset_VertexAttrib1fNV),
-    NAME_FUNC_OFFSET(11790, glVertexAttrib1fvNV, glVertexAttrib1fvNV, NULL, _gloffset_VertexAttrib1fvNV),
-    NAME_FUNC_OFFSET(11810, glVertexAttrib1sNV, glVertexAttrib1sNV, NULL, _gloffset_VertexAttrib1sNV),
-    NAME_FUNC_OFFSET(11829, glVertexAttrib1svNV, glVertexAttrib1svNV, NULL, _gloffset_VertexAttrib1svNV),
-    NAME_FUNC_OFFSET(11849, glVertexAttrib2dNV, glVertexAttrib2dNV, NULL, _gloffset_VertexAttrib2dNV),
-    NAME_FUNC_OFFSET(11868, glVertexAttrib2dvNV, glVertexAttrib2dvNV, NULL, _gloffset_VertexAttrib2dvNV),
-    NAME_FUNC_OFFSET(11888, glVertexAttrib2fNV, glVertexAttrib2fNV, NULL, _gloffset_VertexAttrib2fNV),
-    NAME_FUNC_OFFSET(11907, glVertexAttrib2fvNV, glVertexAttrib2fvNV, NULL, _gloffset_VertexAttrib2fvNV),
-    NAME_FUNC_OFFSET(11927, glVertexAttrib2sNV, glVertexAttrib2sNV, NULL, _gloffset_VertexAttrib2sNV),
-    NAME_FUNC_OFFSET(11946, glVertexAttrib2svNV, glVertexAttrib2svNV, NULL, _gloffset_VertexAttrib2svNV),
-    NAME_FUNC_OFFSET(11966, glVertexAttrib3dNV, glVertexAttrib3dNV, NULL, _gloffset_VertexAttrib3dNV),
-    NAME_FUNC_OFFSET(11985, glVertexAttrib3dvNV, glVertexAttrib3dvNV, NULL, _gloffset_VertexAttrib3dvNV),
-    NAME_FUNC_OFFSET(12005, glVertexAttrib3fNV, glVertexAttrib3fNV, NULL, _gloffset_VertexAttrib3fNV),
-    NAME_FUNC_OFFSET(12024, glVertexAttrib3fvNV, glVertexAttrib3fvNV, NULL, _gloffset_VertexAttrib3fvNV),
-    NAME_FUNC_OFFSET(12044, glVertexAttrib3sNV, glVertexAttrib3sNV, NULL, _gloffset_VertexAttrib3sNV),
-    NAME_FUNC_OFFSET(12063, glVertexAttrib3svNV, glVertexAttrib3svNV, NULL, _gloffset_VertexAttrib3svNV),
-    NAME_FUNC_OFFSET(12083, glVertexAttrib4dNV, glVertexAttrib4dNV, NULL, _gloffset_VertexAttrib4dNV),
-    NAME_FUNC_OFFSET(12102, glVertexAttrib4dvNV, glVertexAttrib4dvNV, NULL, _gloffset_VertexAttrib4dvNV),
-    NAME_FUNC_OFFSET(12122, glVertexAttrib4fNV, glVertexAttrib4fNV, NULL, _gloffset_VertexAttrib4fNV),
-    NAME_FUNC_OFFSET(12141, glVertexAttrib4fvNV, glVertexAttrib4fvNV, NULL, _gloffset_VertexAttrib4fvNV),
-    NAME_FUNC_OFFSET(12161, glVertexAttrib4sNV, glVertexAttrib4sNV, NULL, _gloffset_VertexAttrib4sNV),
-    NAME_FUNC_OFFSET(12180, glVertexAttrib4svNV, glVertexAttrib4svNV, NULL, _gloffset_VertexAttrib4svNV),
-    NAME_FUNC_OFFSET(12200, glVertexAttrib4ubNV, glVertexAttrib4ubNV, NULL, _gloffset_VertexAttrib4ubNV),
-    NAME_FUNC_OFFSET(12220, glVertexAttrib4ubvNV, glVertexAttrib4ubvNV, NULL, _gloffset_VertexAttrib4ubvNV),
-    NAME_FUNC_OFFSET(12241, glVertexAttribPointerNV, glVertexAttribPointerNV, NULL, _gloffset_VertexAttribPointerNV),
-    NAME_FUNC_OFFSET(12265, glVertexAttribs1dvNV, glVertexAttribs1dvNV, NULL, _gloffset_VertexAttribs1dvNV),
-    NAME_FUNC_OFFSET(12286, glVertexAttribs1fvNV, glVertexAttribs1fvNV, NULL, _gloffset_VertexAttribs1fvNV),
-    NAME_FUNC_OFFSET(12307, glVertexAttribs1svNV, glVertexAttribs1svNV, NULL, _gloffset_VertexAttribs1svNV),
-    NAME_FUNC_OFFSET(12328, glVertexAttribs2dvNV, glVertexAttribs2dvNV, NULL, _gloffset_VertexAttribs2dvNV),
-    NAME_FUNC_OFFSET(12349, glVertexAttribs2fvNV, glVertexAttribs2fvNV, NULL, _gloffset_VertexAttribs2fvNV),
-    NAME_FUNC_OFFSET(12370, glVertexAttribs2svNV, glVertexAttribs2svNV, NULL, _gloffset_VertexAttribs2svNV),
-    NAME_FUNC_OFFSET(12391, glVertexAttribs3dvNV, glVertexAttribs3dvNV, NULL, _gloffset_VertexAttribs3dvNV),
-    NAME_FUNC_OFFSET(12412, glVertexAttribs3fvNV, glVertexAttribs3fvNV, NULL, _gloffset_VertexAttribs3fvNV),
-    NAME_FUNC_OFFSET(12433, glVertexAttribs3svNV, glVertexAttribs3svNV, NULL, _gloffset_VertexAttribs3svNV),
-    NAME_FUNC_OFFSET(12454, glVertexAttribs4dvNV, glVertexAttribs4dvNV, NULL, _gloffset_VertexAttribs4dvNV),
-    NAME_FUNC_OFFSET(12475, glVertexAttribs4fvNV, glVertexAttribs4fvNV, NULL, _gloffset_VertexAttribs4fvNV),
-    NAME_FUNC_OFFSET(12496, glVertexAttribs4svNV, glVertexAttribs4svNV, NULL, _gloffset_VertexAttribs4svNV),
-    NAME_FUNC_OFFSET(12517, glVertexAttribs4ubvNV, glVertexAttribs4ubvNV, NULL, _gloffset_VertexAttribs4ubvNV),
-    NAME_FUNC_OFFSET(12539, glGetTexBumpParameterfvATI, glGetTexBumpParameterfvATI, NULL, _gloffset_GetTexBumpParameterfvATI),
-    NAME_FUNC_OFFSET(12566, glGetTexBumpParameterivATI, glGetTexBumpParameterivATI, NULL, _gloffset_GetTexBumpParameterivATI),
-    NAME_FUNC_OFFSET(12593, glTexBumpParameterfvATI, glTexBumpParameterfvATI, NULL, _gloffset_TexBumpParameterfvATI),
-    NAME_FUNC_OFFSET(12617, glTexBumpParameterivATI, glTexBumpParameterivATI, NULL, _gloffset_TexBumpParameterivATI),
-    NAME_FUNC_OFFSET(12641, glAlphaFragmentOp1ATI, glAlphaFragmentOp1ATI, NULL, _gloffset_AlphaFragmentOp1ATI),
-    NAME_FUNC_OFFSET(12663, glAlphaFragmentOp2ATI, glAlphaFragmentOp2ATI, NULL, _gloffset_AlphaFragmentOp2ATI),
-    NAME_FUNC_OFFSET(12685, glAlphaFragmentOp3ATI, glAlphaFragmentOp3ATI, NULL, _gloffset_AlphaFragmentOp3ATI),
-    NAME_FUNC_OFFSET(12707, glBeginFragmentShaderATI, glBeginFragmentShaderATI, NULL, _gloffset_BeginFragmentShaderATI),
-    NAME_FUNC_OFFSET(12732, glBindFragmentShaderATI, glBindFragmentShaderATI, NULL, _gloffset_BindFragmentShaderATI),
-    NAME_FUNC_OFFSET(12756, glColorFragmentOp1ATI, glColorFragmentOp1ATI, NULL, _gloffset_ColorFragmentOp1ATI),
-    NAME_FUNC_OFFSET(12778, glColorFragmentOp2ATI, glColorFragmentOp2ATI, NULL, _gloffset_ColorFragmentOp2ATI),
-    NAME_FUNC_OFFSET(12800, glColorFragmentOp3ATI, glColorFragmentOp3ATI, NULL, _gloffset_ColorFragmentOp3ATI),
-    NAME_FUNC_OFFSET(12822, glDeleteFragmentShaderATI, glDeleteFragmentShaderATI, NULL, _gloffset_DeleteFragmentShaderATI),
-    NAME_FUNC_OFFSET(12848, glEndFragmentShaderATI, glEndFragmentShaderATI, NULL, _gloffset_EndFragmentShaderATI),
-    NAME_FUNC_OFFSET(12871, glGenFragmentShadersATI, glGenFragmentShadersATI, NULL, _gloffset_GenFragmentShadersATI),
-    NAME_FUNC_OFFSET(12895, glPassTexCoordATI, glPassTexCoordATI, NULL, _gloffset_PassTexCoordATI),
-    NAME_FUNC_OFFSET(12913, glSampleMapATI, glSampleMapATI, NULL, _gloffset_SampleMapATI),
-    NAME_FUNC_OFFSET(12928, glSetFragmentShaderConstantATI, glSetFragmentShaderConstantATI, NULL, _gloffset_SetFragmentShaderConstantATI),
-    NAME_FUNC_OFFSET(12959, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
-    NAME_FUNC_OFFSET(12979, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
-    NAME_FUNC_OFFSET(13000, gl_dispatch_stub_753, gl_dispatch_stub_753, NULL, _gloffset_ActiveStencilFaceEXT),
-    NAME_FUNC_OFFSET(13023, gl_dispatch_stub_754, gl_dispatch_stub_754, NULL, _gloffset_BindVertexArrayAPPLE),
-    NAME_FUNC_OFFSET(13046, gl_dispatch_stub_755, gl_dispatch_stub_755, NULL, _gloffset_DeleteVertexArraysAPPLE),
-    NAME_FUNC_OFFSET(13072, gl_dispatch_stub_756, gl_dispatch_stub_756, NULL, _gloffset_GenVertexArraysAPPLE),
-    NAME_FUNC_OFFSET(13095, gl_dispatch_stub_757, gl_dispatch_stub_757, NULL, _gloffset_IsVertexArrayAPPLE),
-    NAME_FUNC_OFFSET(13116, glGetProgramNamedParameterdvNV, glGetProgramNamedParameterdvNV, NULL, _gloffset_GetProgramNamedParameterdvNV),
-    NAME_FUNC_OFFSET(13147, glGetProgramNamedParameterfvNV, glGetProgramNamedParameterfvNV, NULL, _gloffset_GetProgramNamedParameterfvNV),
-    NAME_FUNC_OFFSET(13178, glProgramNamedParameter4dNV, glProgramNamedParameter4dNV, NULL, _gloffset_ProgramNamedParameter4dNV),
-    NAME_FUNC_OFFSET(13206, glProgramNamedParameter4dvNV, glProgramNamedParameter4dvNV, NULL, _gloffset_ProgramNamedParameter4dvNV),
-    NAME_FUNC_OFFSET(13235, glProgramNamedParameter4fNV, glProgramNamedParameter4fNV, NULL, _gloffset_ProgramNamedParameter4fNV),
-    NAME_FUNC_OFFSET(13263, glProgramNamedParameter4fvNV, glProgramNamedParameter4fvNV, NULL, _gloffset_ProgramNamedParameter4fvNV),
-    NAME_FUNC_OFFSET(13292, gl_dispatch_stub_764, gl_dispatch_stub_764, NULL, _gloffset_DepthBoundsEXT),
-    NAME_FUNC_OFFSET(13309, gl_dispatch_stub_765, gl_dispatch_stub_765, NULL, _gloffset_BlendEquationSeparateEXT),
-    NAME_FUNC_OFFSET(13336, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
-    NAME_FUNC_OFFSET(13357, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
-    NAME_FUNC_OFFSET(13379, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
-    NAME_FUNC_OFFSET(13407, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
-    NAME_FUNC_OFFSET(13431, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
-    NAME_FUNC_OFFSET(13456, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
-    NAME_FUNC_OFFSET(13485, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
-    NAME_FUNC_OFFSET(13511, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
-    NAME_FUNC_OFFSET(13537, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
-    NAME_FUNC_OFFSET(13563, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
-    NAME_FUNC_OFFSET(13584, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
-    NAME_FUNC_OFFSET(13606, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
-    NAME_FUNC_OFFSET(13626, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
-    NAME_FUNC_OFFSET(13667, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
-    NAME_FUNC_OFFSET(13699, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
-    NAME_FUNC_OFFSET(13718, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
-    NAME_FUNC_OFFSET(13738, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
-    NAME_FUNC_OFFSET(13763, gl_dispatch_stub_783, gl_dispatch_stub_783, NULL, _gloffset_BlitFramebufferEXT),
-    NAME_FUNC_OFFSET(13784, gl_dispatch_stub_784, gl_dispatch_stub_784, NULL, _gloffset_BufferParameteriAPPLE),
-    NAME_FUNC_OFFSET(13808, gl_dispatch_stub_785, gl_dispatch_stub_785, NULL, _gloffset_FlushMappedBufferRangeAPPLE),
-    NAME_FUNC_OFFSET(13838, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
-    NAME_FUNC_OFFSET(13867, glColorMaskIndexedEXT, glColorMaskIndexedEXT, NULL, _gloffset_ColorMaskIndexedEXT),
-    NAME_FUNC_OFFSET(13889, glDisableIndexedEXT, glDisableIndexedEXT, NULL, _gloffset_DisableIndexedEXT),
-    NAME_FUNC_OFFSET(13909, glEnableIndexedEXT, glEnableIndexedEXT, NULL, _gloffset_EnableIndexedEXT),
-    NAME_FUNC_OFFSET(13928, glGetBooleanIndexedvEXT, glGetBooleanIndexedvEXT, NULL, _gloffset_GetBooleanIndexedvEXT),
-    NAME_FUNC_OFFSET(13952, glGetIntegerIndexedvEXT, glGetIntegerIndexedvEXT, NULL, _gloffset_GetIntegerIndexedvEXT),
-    NAME_FUNC_OFFSET(13976, glIsEnabledIndexedEXT, glIsEnabledIndexedEXT, NULL, _gloffset_IsEnabledIndexedEXT),
-    NAME_FUNC_OFFSET(13998, glBeginConditionalRenderNV, glBeginConditionalRenderNV, NULL, _gloffset_BeginConditionalRenderNV),
-    NAME_FUNC_OFFSET(14025, glEndConditionalRenderNV, glEndConditionalRenderNV, NULL, _gloffset_EndConditionalRenderNV),
-    NAME_FUNC_OFFSET(14050, glProvokingVertexEXT, glProvokingVertexEXT, NULL, _gloffset_ProvokingVertexEXT),
-    NAME_FUNC_OFFSET(14071, gl_dispatch_stub_796, gl_dispatch_stub_796, NULL, _gloffset_GetTexParameterPointervAPPLE),
-    NAME_FUNC_OFFSET(14102, gl_dispatch_stub_797, gl_dispatch_stub_797, NULL, _gloffset_TextureRangeAPPLE),
-    NAME_FUNC_OFFSET(14122, glGetObjectParameterivAPPLE, glGetObjectParameterivAPPLE, NULL, _gloffset_GetObjectParameterivAPPLE),
-    NAME_FUNC_OFFSET(14150, glObjectPurgeableAPPLE, glObjectPurgeableAPPLE, NULL, _gloffset_ObjectPurgeableAPPLE),
-    NAME_FUNC_OFFSET(14173, glObjectUnpurgeableAPPLE, glObjectUnpurgeableAPPLE, NULL, _gloffset_ObjectUnpurgeableAPPLE),
-    NAME_FUNC_OFFSET(14198, gl_dispatch_stub_801, gl_dispatch_stub_801, NULL, _gloffset_StencilFuncSeparateATI),
-    NAME_FUNC_OFFSET(14223, gl_dispatch_stub_802, gl_dispatch_stub_802, NULL, _gloffset_ProgramEnvParameters4fvEXT),
-    NAME_FUNC_OFFSET(14252, gl_dispatch_stub_803, gl_dispatch_stub_803, NULL, _gloffset_ProgramLocalParameters4fvEXT),
-    NAME_FUNC_OFFSET(14283, gl_dispatch_stub_804, gl_dispatch_stub_804, NULL, _gloffset_GetQueryObjecti64vEXT),
-    NAME_FUNC_OFFSET(14307, gl_dispatch_stub_805, gl_dispatch_stub_805, NULL, _gloffset_GetQueryObjectui64vEXT),
-    NAME_FUNC_OFFSET(14332, glEGLImageTargetRenderbufferStorageOES, glEGLImageTargetRenderbufferStorageOES, NULL, _gloffset_EGLImageTargetRenderbufferStorageOES),
-    NAME_FUNC_OFFSET(14371, glEGLImageTargetTexture2DOES, glEGLImageTargetTexture2DOES, NULL, _gloffset_EGLImageTargetTexture2DOES),
-    NAME_FUNC_OFFSET(14400, glArrayElement, glArrayElement, NULL, _gloffset_ArrayElement),
-    NAME_FUNC_OFFSET(14418, glBindTexture, glBindTexture, NULL, _gloffset_BindTexture),
-    NAME_FUNC_OFFSET(14435, glDrawArrays, glDrawArrays, NULL, _gloffset_DrawArrays),
-    NAME_FUNC_OFFSET(14451, glAreTexturesResident, glAreTexturesResidentEXT, glAreTexturesResidentEXT, _gloffset_AreTexturesResident),
-    NAME_FUNC_OFFSET(14476, glCopyTexImage1D, glCopyTexImage1D, NULL, _gloffset_CopyTexImage1D),
-    NAME_FUNC_OFFSET(14496, glCopyTexImage2D, glCopyTexImage2D, NULL, _gloffset_CopyTexImage2D),
-    NAME_FUNC_OFFSET(14516, glCopyTexSubImage1D, glCopyTexSubImage1D, NULL, _gloffset_CopyTexSubImage1D),
-    NAME_FUNC_OFFSET(14539, glCopyTexSubImage2D, glCopyTexSubImage2D, NULL, _gloffset_CopyTexSubImage2D),
-    NAME_FUNC_OFFSET(14562, glDeleteTextures, glDeleteTexturesEXT, glDeleteTexturesEXT, _gloffset_DeleteTextures),
-    NAME_FUNC_OFFSET(14582, glGenTextures, glGenTexturesEXT, glGenTexturesEXT, _gloffset_GenTextures),
-    NAME_FUNC_OFFSET(14599, glGetPointerv, glGetPointerv, NULL, _gloffset_GetPointerv),
-    NAME_FUNC_OFFSET(14616, glIsTexture, glIsTextureEXT, glIsTextureEXT, _gloffset_IsTexture),
-    NAME_FUNC_OFFSET(14631, glPrioritizeTextures, glPrioritizeTextures, NULL, _gloffset_PrioritizeTextures),
-    NAME_FUNC_OFFSET(14655, glTexSubImage1D, glTexSubImage1D, NULL, _gloffset_TexSubImage1D),
-    NAME_FUNC_OFFSET(14674, glTexSubImage2D, glTexSubImage2D, NULL, _gloffset_TexSubImage2D),
-    NAME_FUNC_OFFSET(14693, glBlendColor, glBlendColor, NULL, _gloffset_BlendColor),
-    NAME_FUNC_OFFSET(14709, glBlendEquation, glBlendEquation, NULL, _gloffset_BlendEquation),
-    NAME_FUNC_OFFSET(14728, glDrawRangeElements, glDrawRangeElements, NULL, _gloffset_DrawRangeElements),
-    NAME_FUNC_OFFSET(14751, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
-    NAME_FUNC_OFFSET(14767, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
-    NAME_FUNC_OFFSET(14783, glColorTableParameterfv, glColorTableParameterfv, NULL, _gloffset_ColorTableParameterfv),
-    NAME_FUNC_OFFSET(14810, glColorTableParameteriv, glColorTableParameteriv, NULL, _gloffset_ColorTableParameteriv),
-    NAME_FUNC_OFFSET(14837, glCopyColorTable, glCopyColorTable, NULL, _gloffset_CopyColorTable),
-    NAME_FUNC_OFFSET(14857, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
-    NAME_FUNC_OFFSET(14876, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
-    NAME_FUNC_OFFSET(14895, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
-    NAME_FUNC_OFFSET(14925, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
-    NAME_FUNC_OFFSET(14955, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
-    NAME_FUNC_OFFSET(14985, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
-    NAME_FUNC_OFFSET(15015, glColorSubTable, glColorSubTable, NULL, _gloffset_ColorSubTable),
-    NAME_FUNC_OFFSET(15034, glCopyColorSubTable, glCopyColorSubTable, NULL, _gloffset_CopyColorSubTable),
-    NAME_FUNC_OFFSET(15057, glConvolutionFilter1D, glConvolutionFilter1D, NULL, _gloffset_ConvolutionFilter1D),
-    NAME_FUNC_OFFSET(15082, glConvolutionFilter2D, glConvolutionFilter2D, NULL, _gloffset_ConvolutionFilter2D),
-    NAME_FUNC_OFFSET(15107, glConvolutionParameterf, glConvolutionParameterf, NULL, _gloffset_ConvolutionParameterf),
-    NAME_FUNC_OFFSET(15134, glConvolutionParameterfv, glConvolutionParameterfv, NULL, _gloffset_ConvolutionParameterfv),
-    NAME_FUNC_OFFSET(15162, glConvolutionParameteri, glConvolutionParameteri, NULL, _gloffset_ConvolutionParameteri),
-    NAME_FUNC_OFFSET(15189, glConvolutionParameteriv, glConvolutionParameteriv, NULL, _gloffset_ConvolutionParameteriv),
-    NAME_FUNC_OFFSET(15217, glCopyConvolutionFilter1D, glCopyConvolutionFilter1D, NULL, _gloffset_CopyConvolutionFilter1D),
-    NAME_FUNC_OFFSET(15246, glCopyConvolutionFilter2D, glCopyConvolutionFilter2D, NULL, _gloffset_CopyConvolutionFilter2D),
-    NAME_FUNC_OFFSET(15275, glGetConvolutionFilter, gl_dispatch_stub_356, gl_dispatch_stub_356, _gloffset_GetConvolutionFilter),
-    NAME_FUNC_OFFSET(15301, glGetConvolutionParameterfv, gl_dispatch_stub_357, gl_dispatch_stub_357, _gloffset_GetConvolutionParameterfv),
-    NAME_FUNC_OFFSET(15332, glGetConvolutionParameteriv, gl_dispatch_stub_358, gl_dispatch_stub_358, _gloffset_GetConvolutionParameteriv),
-    NAME_FUNC_OFFSET(15363, glGetSeparableFilter, gl_dispatch_stub_359, gl_dispatch_stub_359, _gloffset_GetSeparableFilter),
-    NAME_FUNC_OFFSET(15387, glSeparableFilter2D, glSeparableFilter2D, NULL, _gloffset_SeparableFilter2D),
-    NAME_FUNC_OFFSET(15410, glGetHistogram, gl_dispatch_stub_361, gl_dispatch_stub_361, _gloffset_GetHistogram),
-    NAME_FUNC_OFFSET(15428, glGetHistogramParameterfv, gl_dispatch_stub_362, gl_dispatch_stub_362, _gloffset_GetHistogramParameterfv),
-    NAME_FUNC_OFFSET(15457, glGetHistogramParameteriv, gl_dispatch_stub_363, gl_dispatch_stub_363, _gloffset_GetHistogramParameteriv),
-    NAME_FUNC_OFFSET(15486, glGetMinmax, gl_dispatch_stub_364, gl_dispatch_stub_364, _gloffset_GetMinmax),
-    NAME_FUNC_OFFSET(15501, glGetMinmaxParameterfv, gl_dispatch_stub_365, gl_dispatch_stub_365, _gloffset_GetMinmaxParameterfv),
-    NAME_FUNC_OFFSET(15527, glGetMinmaxParameteriv, gl_dispatch_stub_366, gl_dispatch_stub_366, _gloffset_GetMinmaxParameteriv),
-    NAME_FUNC_OFFSET(15553, glHistogram, glHistogram, NULL, _gloffset_Histogram),
-    NAME_FUNC_OFFSET(15568, glMinmax, glMinmax, NULL, _gloffset_Minmax),
-    NAME_FUNC_OFFSET(15580, glResetHistogram, glResetHistogram, NULL, _gloffset_ResetHistogram),
-    NAME_FUNC_OFFSET(15600, glResetMinmax, glResetMinmax, NULL, _gloffset_ResetMinmax),
-    NAME_FUNC_OFFSET(15617, glTexImage3D, glTexImage3D, NULL, _gloffset_TexImage3D),
-    NAME_FUNC_OFFSET(15633, glTexSubImage3D, glTexSubImage3D, NULL, _gloffset_TexSubImage3D),
-    NAME_FUNC_OFFSET(15652, glCopyTexSubImage3D, glCopyTexSubImage3D, NULL, _gloffset_CopyTexSubImage3D),
-    NAME_FUNC_OFFSET(15675, glActiveTextureARB, glActiveTextureARB, NULL, _gloffset_ActiveTextureARB),
-    NAME_FUNC_OFFSET(15691, glClientActiveTextureARB, glClientActiveTextureARB, NULL, _gloffset_ClientActiveTextureARB),
-    NAME_FUNC_OFFSET(15713, glMultiTexCoord1dARB, glMultiTexCoord1dARB, NULL, _gloffset_MultiTexCoord1dARB),
-    NAME_FUNC_OFFSET(15731, glMultiTexCoord1dvARB, glMultiTexCoord1dvARB, NULL, _gloffset_MultiTexCoord1dvARB),
-    NAME_FUNC_OFFSET(15750, glMultiTexCoord1fARB, glMultiTexCoord1fARB, NULL, _gloffset_MultiTexCoord1fARB),
-    NAME_FUNC_OFFSET(15768, glMultiTexCoord1fvARB, glMultiTexCoord1fvARB, NULL, _gloffset_MultiTexCoord1fvARB),
-    NAME_FUNC_OFFSET(15787, glMultiTexCoord1iARB, glMultiTexCoord1iARB, NULL, _gloffset_MultiTexCoord1iARB),
-    NAME_FUNC_OFFSET(15805, glMultiTexCoord1ivARB, glMultiTexCoord1ivARB, NULL, _gloffset_MultiTexCoord1ivARB),
-    NAME_FUNC_OFFSET(15824, glMultiTexCoord1sARB, glMultiTexCoord1sARB, NULL, _gloffset_MultiTexCoord1sARB),
-    NAME_FUNC_OFFSET(15842, glMultiTexCoord1svARB, glMultiTexCoord1svARB, NULL, _gloffset_MultiTexCoord1svARB),
-    NAME_FUNC_OFFSET(15861, glMultiTexCoord2dARB, glMultiTexCoord2dARB, NULL, _gloffset_MultiTexCoord2dARB),
-    NAME_FUNC_OFFSET(15879, glMultiTexCoord2dvARB, glMultiTexCoord2dvARB, NULL, _gloffset_MultiTexCoord2dvARB),
-    NAME_FUNC_OFFSET(15898, glMultiTexCoord2fARB, glMultiTexCoord2fARB, NULL, _gloffset_MultiTexCoord2fARB),
-    NAME_FUNC_OFFSET(15916, glMultiTexCoord2fvARB, glMultiTexCoord2fvARB, NULL, _gloffset_MultiTexCoord2fvARB),
-    NAME_FUNC_OFFSET(15935, glMultiTexCoord2iARB, glMultiTexCoord2iARB, NULL, _gloffset_MultiTexCoord2iARB),
-    NAME_FUNC_OFFSET(15953, glMultiTexCoord2ivARB, glMultiTexCoord2ivARB, NULL, _gloffset_MultiTexCoord2ivARB),
-    NAME_FUNC_OFFSET(15972, glMultiTexCoord2sARB, glMultiTexCoord2sARB, NULL, _gloffset_MultiTexCoord2sARB),
-    NAME_FUNC_OFFSET(15990, glMultiTexCoord2svARB, glMultiTexCoord2svARB, NULL, _gloffset_MultiTexCoord2svARB),
-    NAME_FUNC_OFFSET(16009, glMultiTexCoord3dARB, glMultiTexCoord3dARB, NULL, _gloffset_MultiTexCoord3dARB),
-    NAME_FUNC_OFFSET(16027, glMultiTexCoord3dvARB, glMultiTexCoord3dvARB, NULL, _gloffset_MultiTexCoord3dvARB),
-    NAME_FUNC_OFFSET(16046, glMultiTexCoord3fARB, glMultiTexCoord3fARB, NULL, _gloffset_MultiTexCoord3fARB),
-    NAME_FUNC_OFFSET(16064, glMultiTexCoord3fvARB, glMultiTexCoord3fvARB, NULL, _gloffset_MultiTexCoord3fvARB),
-    NAME_FUNC_OFFSET(16083, glMultiTexCoord3iARB, glMultiTexCoord3iARB, NULL, _gloffset_MultiTexCoord3iARB),
-    NAME_FUNC_OFFSET(16101, glMultiTexCoord3ivARB, glMultiTexCoord3ivARB, NULL, _gloffset_MultiTexCoord3ivARB),
-    NAME_FUNC_OFFSET(16120, glMultiTexCoord3sARB, glMultiTexCoord3sARB, NULL, _gloffset_MultiTexCoord3sARB),
-    NAME_FUNC_OFFSET(16138, glMultiTexCoord3svARB, glMultiTexCoord3svARB, NULL, _gloffset_MultiTexCoord3svARB),
-    NAME_FUNC_OFFSET(16157, glMultiTexCoord4dARB, glMultiTexCoord4dARB, NULL, _gloffset_MultiTexCoord4dARB),
-    NAME_FUNC_OFFSET(16175, glMultiTexCoord4dvARB, glMultiTexCoord4dvARB, NULL, _gloffset_MultiTexCoord4dvARB),
-    NAME_FUNC_OFFSET(16194, glMultiTexCoord4fARB, glMultiTexCoord4fARB, NULL, _gloffset_MultiTexCoord4fARB),
-    NAME_FUNC_OFFSET(16212, glMultiTexCoord4fvARB, glMultiTexCoord4fvARB, NULL, _gloffset_MultiTexCoord4fvARB),
-    NAME_FUNC_OFFSET(16231, glMultiTexCoord4iARB, glMultiTexCoord4iARB, NULL, _gloffset_MultiTexCoord4iARB),
-    NAME_FUNC_OFFSET(16249, glMultiTexCoord4ivARB, glMultiTexCoord4ivARB, NULL, _gloffset_MultiTexCoord4ivARB),
-    NAME_FUNC_OFFSET(16268, glMultiTexCoord4sARB, glMultiTexCoord4sARB, NULL, _gloffset_MultiTexCoord4sARB),
-    NAME_FUNC_OFFSET(16286, glMultiTexCoord4svARB, glMultiTexCoord4svARB, NULL, _gloffset_MultiTexCoord4svARB),
-    NAME_FUNC_OFFSET(16305, glStencilOpSeparate, glStencilOpSeparate, NULL, _gloffset_StencilOpSeparate),
-    NAME_FUNC_OFFSET(16328, glLoadTransposeMatrixdARB, glLoadTransposeMatrixdARB, NULL, _gloffset_LoadTransposeMatrixdARB),
-    NAME_FUNC_OFFSET(16351, glLoadTransposeMatrixfARB, glLoadTransposeMatrixfARB, NULL, _gloffset_LoadTransposeMatrixfARB),
-    NAME_FUNC_OFFSET(16374, glMultTransposeMatrixdARB, glMultTransposeMatrixdARB, NULL, _gloffset_MultTransposeMatrixdARB),
-    NAME_FUNC_OFFSET(16397, glMultTransposeMatrixfARB, glMultTransposeMatrixfARB, NULL, _gloffset_MultTransposeMatrixfARB),
-    NAME_FUNC_OFFSET(16420, glSampleCoverageARB, glSampleCoverageARB, NULL, _gloffset_SampleCoverageARB),
-    NAME_FUNC_OFFSET(16437, glCompressedTexImage1DARB, glCompressedTexImage1DARB, NULL, _gloffset_CompressedTexImage1DARB),
-    NAME_FUNC_OFFSET(16460, glCompressedTexImage2DARB, glCompressedTexImage2DARB, NULL, _gloffset_CompressedTexImage2DARB),
-    NAME_FUNC_OFFSET(16483, glCompressedTexImage3DARB, glCompressedTexImage3DARB, NULL, _gloffset_CompressedTexImage3DARB),
-    NAME_FUNC_OFFSET(16506, glCompressedTexSubImage1DARB, glCompressedTexSubImage1DARB, NULL, _gloffset_CompressedTexSubImage1DARB),
-    NAME_FUNC_OFFSET(16532, glCompressedTexSubImage2DARB, glCompressedTexSubImage2DARB, NULL, _gloffset_CompressedTexSubImage2DARB),
-    NAME_FUNC_OFFSET(16558, glCompressedTexSubImage3DARB, glCompressedTexSubImage3DARB, NULL, _gloffset_CompressedTexSubImage3DARB),
-    NAME_FUNC_OFFSET(16584, glGetCompressedTexImageARB, glGetCompressedTexImageARB, NULL, _gloffset_GetCompressedTexImageARB),
-    NAME_FUNC_OFFSET(16608, glDisableVertexAttribArrayARB, glDisableVertexAttribArrayARB, NULL, _gloffset_DisableVertexAttribArrayARB),
-    NAME_FUNC_OFFSET(16635, glEnableVertexAttribArrayARB, glEnableVertexAttribArrayARB, NULL, _gloffset_EnableVertexAttribArrayARB),
-    NAME_FUNC_OFFSET(16661, glGetVertexAttribdvARB, glGetVertexAttribdvARB, NULL, _gloffset_GetVertexAttribdvARB),
-    NAME_FUNC_OFFSET(16681, glGetVertexAttribfvARB, glGetVertexAttribfvARB, NULL, _gloffset_GetVertexAttribfvARB),
-    NAME_FUNC_OFFSET(16701, glGetVertexAttribivARB, glGetVertexAttribivARB, NULL, _gloffset_GetVertexAttribivARB),
-    NAME_FUNC_OFFSET(16721, glProgramEnvParameter4dARB, glProgramEnvParameter4dARB, NULL, _gloffset_ProgramEnvParameter4dARB),
-    NAME_FUNC_OFFSET(16744, glProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB, NULL, _gloffset_ProgramEnvParameter4dvARB),
-    NAME_FUNC_OFFSET(16768, glProgramEnvParameter4fARB, glProgramEnvParameter4fARB, NULL, _gloffset_ProgramEnvParameter4fARB),
-    NAME_FUNC_OFFSET(16791, glProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB, NULL, _gloffset_ProgramEnvParameter4fvARB),
-    NAME_FUNC_OFFSET(16815, glVertexAttrib1dARB, glVertexAttrib1dARB, NULL, _gloffset_VertexAttrib1dARB),
-    NAME_FUNC_OFFSET(16832, glVertexAttrib1dvARB, glVertexAttrib1dvARB, NULL, _gloffset_VertexAttrib1dvARB),
-    NAME_FUNC_OFFSET(16850, glVertexAttrib1fARB, glVertexAttrib1fARB, NULL, _gloffset_VertexAttrib1fARB),
-    NAME_FUNC_OFFSET(16867, glVertexAttrib1fvARB, glVertexAttrib1fvARB, NULL, _gloffset_VertexAttrib1fvARB),
-    NAME_FUNC_OFFSET(16885, glVertexAttrib1sARB, glVertexAttrib1sARB, NULL, _gloffset_VertexAttrib1sARB),
-    NAME_FUNC_OFFSET(16902, glVertexAttrib1svARB, glVertexAttrib1svARB, NULL, _gloffset_VertexAttrib1svARB),
-    NAME_FUNC_OFFSET(16920, glVertexAttrib2dARB, glVertexAttrib2dARB, NULL, _gloffset_VertexAttrib2dARB),
-    NAME_FUNC_OFFSET(16937, glVertexAttrib2dvARB, glVertexAttrib2dvARB, NULL, _gloffset_VertexAttrib2dvARB),
-    NAME_FUNC_OFFSET(16955, glVertexAttrib2fARB, glVertexAttrib2fARB, NULL, _gloffset_VertexAttrib2fARB),
-    NAME_FUNC_OFFSET(16972, glVertexAttrib2fvARB, glVertexAttrib2fvARB, NULL, _gloffset_VertexAttrib2fvARB),
-    NAME_FUNC_OFFSET(16990, glVertexAttrib2sARB, glVertexAttrib2sARB, NULL, _gloffset_VertexAttrib2sARB),
-    NAME_FUNC_OFFSET(17007, glVertexAttrib2svARB, glVertexAttrib2svARB, NULL, _gloffset_VertexAttrib2svARB),
-    NAME_FUNC_OFFSET(17025, glVertexAttrib3dARB, glVertexAttrib3dARB, NULL, _gloffset_VertexAttrib3dARB),
-    NAME_FUNC_OFFSET(17042, glVertexAttrib3dvARB, glVertexAttrib3dvARB, NULL, _gloffset_VertexAttrib3dvARB),
-    NAME_FUNC_OFFSET(17060, glVertexAttrib3fARB, glVertexAttrib3fARB, NULL, _gloffset_VertexAttrib3fARB),
-    NAME_FUNC_OFFSET(17077, glVertexAttrib3fvARB, glVertexAttrib3fvARB, NULL, _gloffset_VertexAttrib3fvARB),
-    NAME_FUNC_OFFSET(17095, glVertexAttrib3sARB, glVertexAttrib3sARB, NULL, _gloffset_VertexAttrib3sARB),
-    NAME_FUNC_OFFSET(17112, glVertexAttrib3svARB, glVertexAttrib3svARB, NULL, _gloffset_VertexAttrib3svARB),
-    NAME_FUNC_OFFSET(17130, glVertexAttrib4NbvARB, glVertexAttrib4NbvARB, NULL, _gloffset_VertexAttrib4NbvARB),
-    NAME_FUNC_OFFSET(17149, glVertexAttrib4NivARB, glVertexAttrib4NivARB, NULL, _gloffset_VertexAttrib4NivARB),
-    NAME_FUNC_OFFSET(17168, glVertexAttrib4NsvARB, glVertexAttrib4NsvARB, NULL, _gloffset_VertexAttrib4NsvARB),
-    NAME_FUNC_OFFSET(17187, glVertexAttrib4NubARB, glVertexAttrib4NubARB, NULL, _gloffset_VertexAttrib4NubARB),
-    NAME_FUNC_OFFSET(17206, glVertexAttrib4NubvARB, glVertexAttrib4NubvARB, NULL, _gloffset_VertexAttrib4NubvARB),
-    NAME_FUNC_OFFSET(17226, glVertexAttrib4NuivARB, glVertexAttrib4NuivARB, NULL, _gloffset_VertexAttrib4NuivARB),
-    NAME_FUNC_OFFSET(17246, glVertexAttrib4NusvARB, glVertexAttrib4NusvARB, NULL, _gloffset_VertexAttrib4NusvARB),
-    NAME_FUNC_OFFSET(17266, glVertexAttrib4bvARB, glVertexAttrib4bvARB, NULL, _gloffset_VertexAttrib4bvARB),
-    NAME_FUNC_OFFSET(17284, glVertexAttrib4dARB, glVertexAttrib4dARB, NULL, _gloffset_VertexAttrib4dARB),
-    NAME_FUNC_OFFSET(17301, glVertexAttrib4dvARB, glVertexAttrib4dvARB, NULL, _gloffset_VertexAttrib4dvARB),
-    NAME_FUNC_OFFSET(17319, glVertexAttrib4fARB, glVertexAttrib4fARB, NULL, _gloffset_VertexAttrib4fARB),
-    NAME_FUNC_OFFSET(17336, glVertexAttrib4fvARB, glVertexAttrib4fvARB, NULL, _gloffset_VertexAttrib4fvARB),
-    NAME_FUNC_OFFSET(17354, glVertexAttrib4ivARB, glVertexAttrib4ivARB, NULL, _gloffset_VertexAttrib4ivARB),
-    NAME_FUNC_OFFSET(17372, glVertexAttrib4sARB, glVertexAttrib4sARB, NULL, _gloffset_VertexAttrib4sARB),
-    NAME_FUNC_OFFSET(17389, glVertexAttrib4svARB, glVertexAttrib4svARB, NULL, _gloffset_VertexAttrib4svARB),
-    NAME_FUNC_OFFSET(17407, glVertexAttrib4ubvARB, glVertexAttrib4ubvARB, NULL, _gloffset_VertexAttrib4ubvARB),
-    NAME_FUNC_OFFSET(17426, glVertexAttrib4uivARB, glVertexAttrib4uivARB, NULL, _gloffset_VertexAttrib4uivARB),
-    NAME_FUNC_OFFSET(17445, glVertexAttrib4usvARB, glVertexAttrib4usvARB, NULL, _gloffset_VertexAttrib4usvARB),
-    NAME_FUNC_OFFSET(17464, glVertexAttribPointerARB, glVertexAttribPointerARB, NULL, _gloffset_VertexAttribPointerARB),
-    NAME_FUNC_OFFSET(17486, glBindBufferARB, glBindBufferARB, NULL, _gloffset_BindBufferARB),
-    NAME_FUNC_OFFSET(17499, glBufferDataARB, glBufferDataARB, NULL, _gloffset_BufferDataARB),
-    NAME_FUNC_OFFSET(17512, glBufferSubDataARB, glBufferSubDataARB, NULL, _gloffset_BufferSubDataARB),
-    NAME_FUNC_OFFSET(17528, glDeleteBuffersARB, glDeleteBuffersARB, NULL, _gloffset_DeleteBuffersARB),
-    NAME_FUNC_OFFSET(17544, glGenBuffersARB, glGenBuffersARB, NULL, _gloffset_GenBuffersARB),
-    NAME_FUNC_OFFSET(17557, glGetBufferParameterivARB, glGetBufferParameterivARB, NULL, _gloffset_GetBufferParameterivARB),
-    NAME_FUNC_OFFSET(17580, glGetBufferPointervARB, glGetBufferPointervARB, NULL, _gloffset_GetBufferPointervARB),
-    NAME_FUNC_OFFSET(17600, glGetBufferSubDataARB, glGetBufferSubDataARB, NULL, _gloffset_GetBufferSubDataARB),
-    NAME_FUNC_OFFSET(17619, glIsBufferARB, glIsBufferARB, NULL, _gloffset_IsBufferARB),
-    NAME_FUNC_OFFSET(17630, glMapBufferARB, glMapBufferARB, NULL, _gloffset_MapBufferARB),
-    NAME_FUNC_OFFSET(17642, glUnmapBufferARB, glUnmapBufferARB, NULL, _gloffset_UnmapBufferARB),
-    NAME_FUNC_OFFSET(17656, glBeginQueryARB, glBeginQueryARB, NULL, _gloffset_BeginQueryARB),
-    NAME_FUNC_OFFSET(17669, glDeleteQueriesARB, glDeleteQueriesARB, NULL, _gloffset_DeleteQueriesARB),
-    NAME_FUNC_OFFSET(17685, glEndQueryARB, glEndQueryARB, NULL, _gloffset_EndQueryARB),
-    NAME_FUNC_OFFSET(17696, glGenQueriesARB, glGenQueriesARB, NULL, _gloffset_GenQueriesARB),
-    NAME_FUNC_OFFSET(17709, glGetQueryObjectivARB, glGetQueryObjectivARB, NULL, _gloffset_GetQueryObjectivARB),
-    NAME_FUNC_OFFSET(17728, glGetQueryObjectuivARB, glGetQueryObjectuivARB, NULL, _gloffset_GetQueryObjectuivARB),
-    NAME_FUNC_OFFSET(17748, glGetQueryivARB, glGetQueryivARB, NULL, _gloffset_GetQueryivARB),
-    NAME_FUNC_OFFSET(17761, glIsQueryARB, glIsQueryARB, NULL, _gloffset_IsQueryARB),
-    NAME_FUNC_OFFSET(17771, glCompileShaderARB, glCompileShaderARB, NULL, _gloffset_CompileShaderARB),
-    NAME_FUNC_OFFSET(17787, glGetActiveUniformARB, glGetActiveUniformARB, NULL, _gloffset_GetActiveUniformARB),
-    NAME_FUNC_OFFSET(17806, glGetShaderSourceARB, glGetShaderSourceARB, NULL, _gloffset_GetShaderSourceARB),
-    NAME_FUNC_OFFSET(17824, glGetUniformLocationARB, glGetUniformLocationARB, NULL, _gloffset_GetUniformLocationARB),
-    NAME_FUNC_OFFSET(17845, glGetUniformfvARB, glGetUniformfvARB, NULL, _gloffset_GetUniformfvARB),
-    NAME_FUNC_OFFSET(17860, glGetUniformivARB, glGetUniformivARB, NULL, _gloffset_GetUniformivARB),
-    NAME_FUNC_OFFSET(17875, glLinkProgramARB, glLinkProgramARB, NULL, _gloffset_LinkProgramARB),
-    NAME_FUNC_OFFSET(17889, glShaderSourceARB, glShaderSourceARB, NULL, _gloffset_ShaderSourceARB),
-    NAME_FUNC_OFFSET(17904, glUniform1fARB, glUniform1fARB, NULL, _gloffset_Uniform1fARB),
-    NAME_FUNC_OFFSET(17916, glUniform1fvARB, glUniform1fvARB, NULL, _gloffset_Uniform1fvARB),
-    NAME_FUNC_OFFSET(17929, glUniform1iARB, glUniform1iARB, NULL, _gloffset_Uniform1iARB),
-    NAME_FUNC_OFFSET(17941, glUniform1ivARB, glUniform1ivARB, NULL, _gloffset_Uniform1ivARB),
-    NAME_FUNC_OFFSET(17954, glUniform2fARB, glUniform2fARB, NULL, _gloffset_Uniform2fARB),
-    NAME_FUNC_OFFSET(17966, glUniform2fvARB, glUniform2fvARB, NULL, _gloffset_Uniform2fvARB),
-    NAME_FUNC_OFFSET(17979, glUniform2iARB, glUniform2iARB, NULL, _gloffset_Uniform2iARB),
-    NAME_FUNC_OFFSET(17991, glUniform2ivARB, glUniform2ivARB, NULL, _gloffset_Uniform2ivARB),
-    NAME_FUNC_OFFSET(18004, glUniform3fARB, glUniform3fARB, NULL, _gloffset_Uniform3fARB),
-    NAME_FUNC_OFFSET(18016, glUniform3fvARB, glUniform3fvARB, NULL, _gloffset_Uniform3fvARB),
-    NAME_FUNC_OFFSET(18029, glUniform3iARB, glUniform3iARB, NULL, _gloffset_Uniform3iARB),
-    NAME_FUNC_OFFSET(18041, glUniform3ivARB, glUniform3ivARB, NULL, _gloffset_Uniform3ivARB),
-    NAME_FUNC_OFFSET(18054, glUniform4fARB, glUniform4fARB, NULL, _gloffset_Uniform4fARB),
-    NAME_FUNC_OFFSET(18066, glUniform4fvARB, glUniform4fvARB, NULL, _gloffset_Uniform4fvARB),
-    NAME_FUNC_OFFSET(18079, glUniform4iARB, glUniform4iARB, NULL, _gloffset_Uniform4iARB),
-    NAME_FUNC_OFFSET(18091, glUniform4ivARB, glUniform4ivARB, NULL, _gloffset_Uniform4ivARB),
-    NAME_FUNC_OFFSET(18104, glUniformMatrix2fvARB, glUniformMatrix2fvARB, NULL, _gloffset_UniformMatrix2fvARB),
-    NAME_FUNC_OFFSET(18123, glUniformMatrix3fvARB, glUniformMatrix3fvARB, NULL, _gloffset_UniformMatrix3fvARB),
-    NAME_FUNC_OFFSET(18142, glUniformMatrix4fvARB, glUniformMatrix4fvARB, NULL, _gloffset_UniformMatrix4fvARB),
-    NAME_FUNC_OFFSET(18161, glUseProgramObjectARB, glUseProgramObjectARB, NULL, _gloffset_UseProgramObjectARB),
-    NAME_FUNC_OFFSET(18174, glValidateProgramARB, glValidateProgramARB, NULL, _gloffset_ValidateProgramARB),
-    NAME_FUNC_OFFSET(18192, glBindAttribLocationARB, glBindAttribLocationARB, NULL, _gloffset_BindAttribLocationARB),
-    NAME_FUNC_OFFSET(18213, glGetActiveAttribARB, glGetActiveAttribARB, NULL, _gloffset_GetActiveAttribARB),
-    NAME_FUNC_OFFSET(18231, glGetAttribLocationARB, glGetAttribLocationARB, NULL, _gloffset_GetAttribLocationARB),
-    NAME_FUNC_OFFSET(18251, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
-    NAME_FUNC_OFFSET(18265, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
-    NAME_FUNC_OFFSET(18282, glRenderbufferStorageMultisample, glRenderbufferStorageMultisample, NULL, _gloffset_RenderbufferStorageMultisample),
-    NAME_FUNC_OFFSET(18318, gl_dispatch_stub_584, gl_dispatch_stub_584, NULL, _gloffset_SampleMaskSGIS),
-    NAME_FUNC_OFFSET(18334, gl_dispatch_stub_585, gl_dispatch_stub_585, NULL, _gloffset_SamplePatternSGIS),
-    NAME_FUNC_OFFSET(18353, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
-    NAME_FUNC_OFFSET(18371, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
-    NAME_FUNC_OFFSET(18392, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
-    NAME_FUNC_OFFSET(18414, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
-    NAME_FUNC_OFFSET(18433, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
-    NAME_FUNC_OFFSET(18455, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
-    NAME_FUNC_OFFSET(18478, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
-    NAME_FUNC_OFFSET(18497, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
-    NAME_FUNC_OFFSET(18517, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
-    NAME_FUNC_OFFSET(18536, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
-    NAME_FUNC_OFFSET(18556, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
-    NAME_FUNC_OFFSET(18575, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
-    NAME_FUNC_OFFSET(18595, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
-    NAME_FUNC_OFFSET(18614, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
-    NAME_FUNC_OFFSET(18634, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
-    NAME_FUNC_OFFSET(18653, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
-    NAME_FUNC_OFFSET(18673, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
-    NAME_FUNC_OFFSET(18693, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
-    NAME_FUNC_OFFSET(18714, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
-    NAME_FUNC_OFFSET(18734, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
-    NAME_FUNC_OFFSET(18755, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
-    NAME_FUNC_OFFSET(18775, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
-    NAME_FUNC_OFFSET(18796, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
-    NAME_FUNC_OFFSET(18820, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
-    NAME_FUNC_OFFSET(18838, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
-    NAME_FUNC_OFFSET(18858, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
-    NAME_FUNC_OFFSET(18876, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
-    NAME_FUNC_OFFSET(18888, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
-    NAME_FUNC_OFFSET(18901, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
-    NAME_FUNC_OFFSET(18913, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
-    NAME_FUNC_OFFSET(18926, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
-    NAME_FUNC_OFFSET(18946, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
-    NAME_FUNC_OFFSET(18970, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
-    NAME_FUNC_OFFSET(18984, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
-    NAME_FUNC_OFFSET(19001, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
-    NAME_FUNC_OFFSET(19016, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
-    NAME_FUNC_OFFSET(19034, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
-    NAME_FUNC_OFFSET(19048, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
-    NAME_FUNC_OFFSET(19065, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
-    NAME_FUNC_OFFSET(19080, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
-    NAME_FUNC_OFFSET(19098, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
-    NAME_FUNC_OFFSET(19112, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
-    NAME_FUNC_OFFSET(19129, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
-    NAME_FUNC_OFFSET(19144, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
-    NAME_FUNC_OFFSET(19162, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
-    NAME_FUNC_OFFSET(19176, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
-    NAME_FUNC_OFFSET(19193, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
-    NAME_FUNC_OFFSET(19208, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
-    NAME_FUNC_OFFSET(19226, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
-    NAME_FUNC_OFFSET(19240, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
-    NAME_FUNC_OFFSET(19257, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
-    NAME_FUNC_OFFSET(19272, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
-    NAME_FUNC_OFFSET(19290, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
-    NAME_FUNC_OFFSET(19304, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
-    NAME_FUNC_OFFSET(19321, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
-    NAME_FUNC_OFFSET(19336, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
-    NAME_FUNC_OFFSET(19354, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
-    NAME_FUNC_OFFSET(19368, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
-    NAME_FUNC_OFFSET(19385, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
-    NAME_FUNC_OFFSET(19400, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
-    NAME_FUNC_OFFSET(19418, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
-    NAME_FUNC_OFFSET(19432, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
-    NAME_FUNC_OFFSET(19449, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
-    NAME_FUNC_OFFSET(19464, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
-    NAME_FUNC_OFFSET(19482, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
-    NAME_FUNC_OFFSET(19499, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
-    NAME_FUNC_OFFSET(19519, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
-    NAME_FUNC_OFFSET(19536, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
-    NAME_FUNC_OFFSET(19562, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
-    NAME_FUNC_OFFSET(19591, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
-    NAME_FUNC_OFFSET(19606, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
-    NAME_FUNC_OFFSET(19624, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
-    NAME_FUNC_OFFSET(19643, gl_dispatch_stub_755, gl_dispatch_stub_755, NULL, _gloffset_DeleteVertexArraysAPPLE),
-    NAME_FUNC_OFFSET(19664, gl_dispatch_stub_757, gl_dispatch_stub_757, NULL, _gloffset_IsVertexArrayAPPLE),
-    NAME_FUNC_OFFSET(19680, gl_dispatch_stub_765, gl_dispatch_stub_765, NULL, _gloffset_BlendEquationSeparateEXT),
-    NAME_FUNC_OFFSET(19704, gl_dispatch_stub_765, gl_dispatch_stub_765, NULL, _gloffset_BlendEquationSeparateEXT),
-    NAME_FUNC_OFFSET(19731, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
-    NAME_FUNC_OFFSET(19749, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
-    NAME_FUNC_OFFSET(19768, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
-    NAME_FUNC_OFFSET(19793, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
-    NAME_FUNC_OFFSET(19814, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
-    NAME_FUNC_OFFSET(19836, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
-    NAME_FUNC_OFFSET(19862, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
-    NAME_FUNC_OFFSET(19885, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
-    NAME_FUNC_OFFSET(19908, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
-    NAME_FUNC_OFFSET(19931, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
-    NAME_FUNC_OFFSET(19949, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
-    NAME_FUNC_OFFSET(19968, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
-    NAME_FUNC_OFFSET(19985, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
-    NAME_FUNC_OFFSET(20023, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
-    NAME_FUNC_OFFSET(20052, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
-    NAME_FUNC_OFFSET(20068, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
-    NAME_FUNC_OFFSET(20085, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
-    NAME_FUNC_OFFSET(20107, gl_dispatch_stub_783, gl_dispatch_stub_783, NULL, _gloffset_BlitFramebufferEXT),
-    NAME_FUNC_OFFSET(20125, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
-    NAME_FUNC_OFFSET(20151, glProvokingVertexEXT, glProvokingVertexEXT, NULL, _gloffset_ProvokingVertexEXT),
+    NAME_FUNC_OFFSET( 6163, glDrawArraysInstanced, glDrawArraysInstanced, NULL, _gloffset_DrawArraysInstanced),
+    NAME_FUNC_OFFSET( 6185, glDrawElementsInstanced, glDrawElementsInstanced, NULL, _gloffset_DrawElementsInstanced),
+    NAME_FUNC_OFFSET( 6209, glLoadTransposeMatrixdARB, glLoadTransposeMatrixdARB, NULL, _gloffset_LoadTransposeMatrixdARB),
+    NAME_FUNC_OFFSET( 6235, glLoadTransposeMatrixfARB, glLoadTransposeMatrixfARB, NULL, _gloffset_LoadTransposeMatrixfARB),
+    NAME_FUNC_OFFSET( 6261, glMultTransposeMatrixdARB, glMultTransposeMatrixdARB, NULL, _gloffset_MultTransposeMatrixdARB),
+    NAME_FUNC_OFFSET( 6287, glMultTransposeMatrixfARB, glMultTransposeMatrixfARB, NULL, _gloffset_MultTransposeMatrixfARB),
+    NAME_FUNC_OFFSET( 6313, glSampleCoverageARB, glSampleCoverageARB, NULL, _gloffset_SampleCoverageARB),
+    NAME_FUNC_OFFSET( 6333, glCompressedTexImage1DARB, glCompressedTexImage1DARB, NULL, _gloffset_CompressedTexImage1DARB),
+    NAME_FUNC_OFFSET( 6359, glCompressedTexImage2DARB, glCompressedTexImage2DARB, NULL, _gloffset_CompressedTexImage2DARB),
+    NAME_FUNC_OFFSET( 6385, glCompressedTexImage3DARB, glCompressedTexImage3DARB, NULL, _gloffset_CompressedTexImage3DARB),
+    NAME_FUNC_OFFSET( 6411, glCompressedTexSubImage1DARB, glCompressedTexSubImage1DARB, NULL, _gloffset_CompressedTexSubImage1DARB),
+    NAME_FUNC_OFFSET( 6440, glCompressedTexSubImage2DARB, glCompressedTexSubImage2DARB, NULL, _gloffset_CompressedTexSubImage2DARB),
+    NAME_FUNC_OFFSET( 6469, glCompressedTexSubImage3DARB, glCompressedTexSubImage3DARB, NULL, _gloffset_CompressedTexSubImage3DARB),
+    NAME_FUNC_OFFSET( 6498, glGetCompressedTexImageARB, glGetCompressedTexImageARB, NULL, _gloffset_GetCompressedTexImageARB),
+    NAME_FUNC_OFFSET( 6525, glDisableVertexAttribArrayARB, glDisableVertexAttribArrayARB, NULL, _gloffset_DisableVertexAttribArrayARB),
+    NAME_FUNC_OFFSET( 6555, glEnableVertexAttribArrayARB, glEnableVertexAttribArrayARB, NULL, _gloffset_EnableVertexAttribArrayARB),
+    NAME_FUNC_OFFSET( 6584, glGetProgramEnvParameterdvARB, glGetProgramEnvParameterdvARB, NULL, _gloffset_GetProgramEnvParameterdvARB),
+    NAME_FUNC_OFFSET( 6614, glGetProgramEnvParameterfvARB, glGetProgramEnvParameterfvARB, NULL, _gloffset_GetProgramEnvParameterfvARB),
+    NAME_FUNC_OFFSET( 6644, glGetProgramLocalParameterdvARB, glGetProgramLocalParameterdvARB, NULL, _gloffset_GetProgramLocalParameterdvARB),
+    NAME_FUNC_OFFSET( 6676, glGetProgramLocalParameterfvARB, glGetProgramLocalParameterfvARB, NULL, _gloffset_GetProgramLocalParameterfvARB),
+    NAME_FUNC_OFFSET( 6708, glGetProgramStringARB, glGetProgramStringARB, NULL, _gloffset_GetProgramStringARB),
+    NAME_FUNC_OFFSET( 6730, glGetProgramivARB, glGetProgramivARB, NULL, _gloffset_GetProgramivARB),
+    NAME_FUNC_OFFSET( 6748, glGetVertexAttribdvARB, glGetVertexAttribdvARB, NULL, _gloffset_GetVertexAttribdvARB),
+    NAME_FUNC_OFFSET( 6771, glGetVertexAttribfvARB, glGetVertexAttribfvARB, NULL, _gloffset_GetVertexAttribfvARB),
+    NAME_FUNC_OFFSET( 6794, glGetVertexAttribivARB, glGetVertexAttribivARB, NULL, _gloffset_GetVertexAttribivARB),
+    NAME_FUNC_OFFSET( 6817, glProgramEnvParameter4dARB, glProgramEnvParameter4dARB, NULL, _gloffset_ProgramEnvParameter4dARB),
+    NAME_FUNC_OFFSET( 6844, glProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB, NULL, _gloffset_ProgramEnvParameter4dvARB),
+    NAME_FUNC_OFFSET( 6872, glProgramEnvParameter4fARB, glProgramEnvParameter4fARB, NULL, _gloffset_ProgramEnvParameter4fARB),
+    NAME_FUNC_OFFSET( 6899, glProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB, NULL, _gloffset_ProgramEnvParameter4fvARB),
+    NAME_FUNC_OFFSET( 6927, glProgramLocalParameter4dARB, glProgramLocalParameter4dARB, NULL, _gloffset_ProgramLocalParameter4dARB),
+    NAME_FUNC_OFFSET( 6956, glProgramLocalParameter4dvARB, glProgramLocalParameter4dvARB, NULL, _gloffset_ProgramLocalParameter4dvARB),
+    NAME_FUNC_OFFSET( 6986, glProgramLocalParameter4fARB, glProgramLocalParameter4fARB, NULL, _gloffset_ProgramLocalParameter4fARB),
+    NAME_FUNC_OFFSET( 7015, glProgramLocalParameter4fvARB, glProgramLocalParameter4fvARB, NULL, _gloffset_ProgramLocalParameter4fvARB),
+    NAME_FUNC_OFFSET( 7045, glProgramStringARB, glProgramStringARB, NULL, _gloffset_ProgramStringARB),
+    NAME_FUNC_OFFSET( 7064, glVertexAttrib1dARB, glVertexAttrib1dARB, NULL, _gloffset_VertexAttrib1dARB),
+    NAME_FUNC_OFFSET( 7084, glVertexAttrib1dvARB, glVertexAttrib1dvARB, NULL, _gloffset_VertexAttrib1dvARB),
+    NAME_FUNC_OFFSET( 7105, glVertexAttrib1fARB, glVertexAttrib1fARB, NULL, _gloffset_VertexAttrib1fARB),
+    NAME_FUNC_OFFSET( 7125, glVertexAttrib1fvARB, glVertexAttrib1fvARB, NULL, _gloffset_VertexAttrib1fvARB),
+    NAME_FUNC_OFFSET( 7146, glVertexAttrib1sARB, glVertexAttrib1sARB, NULL, _gloffset_VertexAttrib1sARB),
+    NAME_FUNC_OFFSET( 7166, glVertexAttrib1svARB, glVertexAttrib1svARB, NULL, _gloffset_VertexAttrib1svARB),
+    NAME_FUNC_OFFSET( 7187, glVertexAttrib2dARB, glVertexAttrib2dARB, NULL, _gloffset_VertexAttrib2dARB),
+    NAME_FUNC_OFFSET( 7207, glVertexAttrib2dvARB, glVertexAttrib2dvARB, NULL, _gloffset_VertexAttrib2dvARB),
+    NAME_FUNC_OFFSET( 7228, glVertexAttrib2fARB, glVertexAttrib2fARB, NULL, _gloffset_VertexAttrib2fARB),
+    NAME_FUNC_OFFSET( 7248, glVertexAttrib2fvARB, glVertexAttrib2fvARB, NULL, _gloffset_VertexAttrib2fvARB),
+    NAME_FUNC_OFFSET( 7269, glVertexAttrib2sARB, glVertexAttrib2sARB, NULL, _gloffset_VertexAttrib2sARB),
+    NAME_FUNC_OFFSET( 7289, glVertexAttrib2svARB, glVertexAttrib2svARB, NULL, _gloffset_VertexAttrib2svARB),
+    NAME_FUNC_OFFSET( 7310, glVertexAttrib3dARB, glVertexAttrib3dARB, NULL, _gloffset_VertexAttrib3dARB),
+    NAME_FUNC_OFFSET( 7330, glVertexAttrib3dvARB, glVertexAttrib3dvARB, NULL, _gloffset_VertexAttrib3dvARB),
+    NAME_FUNC_OFFSET( 7351, glVertexAttrib3fARB, glVertexAttrib3fARB, NULL, _gloffset_VertexAttrib3fARB),
+    NAME_FUNC_OFFSET( 7371, glVertexAttrib3fvARB, glVertexAttrib3fvARB, NULL, _gloffset_VertexAttrib3fvARB),
+    NAME_FUNC_OFFSET( 7392, glVertexAttrib3sARB, glVertexAttrib3sARB, NULL, _gloffset_VertexAttrib3sARB),
+    NAME_FUNC_OFFSET( 7412, glVertexAttrib3svARB, glVertexAttrib3svARB, NULL, _gloffset_VertexAttrib3svARB),
+    NAME_FUNC_OFFSET( 7433, glVertexAttrib4NbvARB, glVertexAttrib4NbvARB, NULL, _gloffset_VertexAttrib4NbvARB),
+    NAME_FUNC_OFFSET( 7455, glVertexAttrib4NivARB, glVertexAttrib4NivARB, NULL, _gloffset_VertexAttrib4NivARB),
+    NAME_FUNC_OFFSET( 7477, glVertexAttrib4NsvARB, glVertexAttrib4NsvARB, NULL, _gloffset_VertexAttrib4NsvARB),
+    NAME_FUNC_OFFSET( 7499, glVertexAttrib4NubARB, glVertexAttrib4NubARB, NULL, _gloffset_VertexAttrib4NubARB),
+    NAME_FUNC_OFFSET( 7521, glVertexAttrib4NubvARB, glVertexAttrib4NubvARB, NULL, _gloffset_VertexAttrib4NubvARB),
+    NAME_FUNC_OFFSET( 7544, glVertexAttrib4NuivARB, glVertexAttrib4NuivARB, NULL, _gloffset_VertexAttrib4NuivARB),
+    NAME_FUNC_OFFSET( 7567, glVertexAttrib4NusvARB, glVertexAttrib4NusvARB, NULL, _gloffset_VertexAttrib4NusvARB),
+    NAME_FUNC_OFFSET( 7590, glVertexAttrib4bvARB, glVertexAttrib4bvARB, NULL, _gloffset_VertexAttrib4bvARB),
+    NAME_FUNC_OFFSET( 7611, glVertexAttrib4dARB, glVertexAttrib4dARB, NULL, _gloffset_VertexAttrib4dARB),
+    NAME_FUNC_OFFSET( 7631, glVertexAttrib4dvARB, glVertexAttrib4dvARB, NULL, _gloffset_VertexAttrib4dvARB),
+    NAME_FUNC_OFFSET( 7652, glVertexAttrib4fARB, glVertexAttrib4fARB, NULL, _gloffset_VertexAttrib4fARB),
+    NAME_FUNC_OFFSET( 7672, glVertexAttrib4fvARB, glVertexAttrib4fvARB, NULL, _gloffset_VertexAttrib4fvARB),
+    NAME_FUNC_OFFSET( 7693, glVertexAttrib4ivARB, glVertexAttrib4ivARB, NULL, _gloffset_VertexAttrib4ivARB),
+    NAME_FUNC_OFFSET( 7714, glVertexAttrib4sARB, glVertexAttrib4sARB, NULL, _gloffset_VertexAttrib4sARB),
+    NAME_FUNC_OFFSET( 7734, glVertexAttrib4svARB, glVertexAttrib4svARB, NULL, _gloffset_VertexAttrib4svARB),
+    NAME_FUNC_OFFSET( 7755, glVertexAttrib4ubvARB, glVertexAttrib4ubvARB, NULL, _gloffset_VertexAttrib4ubvARB),
+    NAME_FUNC_OFFSET( 7777, glVertexAttrib4uivARB, glVertexAttrib4uivARB, NULL, _gloffset_VertexAttrib4uivARB),
+    NAME_FUNC_OFFSET( 7799, glVertexAttrib4usvARB, glVertexAttrib4usvARB, NULL, _gloffset_VertexAttrib4usvARB),
+    NAME_FUNC_OFFSET( 7821, glVertexAttribPointerARB, glVertexAttribPointerARB, NULL, _gloffset_VertexAttribPointerARB),
+    NAME_FUNC_OFFSET( 7846, glBindBufferARB, glBindBufferARB, NULL, _gloffset_BindBufferARB),
+    NAME_FUNC_OFFSET( 7862, glBufferDataARB, glBufferDataARB, NULL, _gloffset_BufferDataARB),
+    NAME_FUNC_OFFSET( 7878, glBufferSubDataARB, glBufferSubDataARB, NULL, _gloffset_BufferSubDataARB),
+    NAME_FUNC_OFFSET( 7897, glDeleteBuffersARB, glDeleteBuffersARB, NULL, _gloffset_DeleteBuffersARB),
+    NAME_FUNC_OFFSET( 7916, glGenBuffersARB, glGenBuffersARB, NULL, _gloffset_GenBuffersARB),
+    NAME_FUNC_OFFSET( 7932, glGetBufferParameterivARB, glGetBufferParameterivARB, NULL, _gloffset_GetBufferParameterivARB),
+    NAME_FUNC_OFFSET( 7958, glGetBufferPointervARB, glGetBufferPointervARB, NULL, _gloffset_GetBufferPointervARB),
+    NAME_FUNC_OFFSET( 7981, glGetBufferSubDataARB, glGetBufferSubDataARB, NULL, _gloffset_GetBufferSubDataARB),
+    NAME_FUNC_OFFSET( 8003, glIsBufferARB, glIsBufferARB, NULL, _gloffset_IsBufferARB),
+    NAME_FUNC_OFFSET( 8017, glMapBufferARB, glMapBufferARB, NULL, _gloffset_MapBufferARB),
+    NAME_FUNC_OFFSET( 8032, glUnmapBufferARB, glUnmapBufferARB, NULL, _gloffset_UnmapBufferARB),
+    NAME_FUNC_OFFSET( 8049, glBeginQueryARB, glBeginQueryARB, NULL, _gloffset_BeginQueryARB),
+    NAME_FUNC_OFFSET( 8065, glDeleteQueriesARB, glDeleteQueriesARB, NULL, _gloffset_DeleteQueriesARB),
+    NAME_FUNC_OFFSET( 8084, glEndQueryARB, glEndQueryARB, NULL, _gloffset_EndQueryARB),
+    NAME_FUNC_OFFSET( 8098, glGenQueriesARB, glGenQueriesARB, NULL, _gloffset_GenQueriesARB),
+    NAME_FUNC_OFFSET( 8114, glGetQueryObjectivARB, glGetQueryObjectivARB, NULL, _gloffset_GetQueryObjectivARB),
+    NAME_FUNC_OFFSET( 8136, glGetQueryObjectuivARB, glGetQueryObjectuivARB, NULL, _gloffset_GetQueryObjectuivARB),
+    NAME_FUNC_OFFSET( 8159, glGetQueryivARB, glGetQueryivARB, NULL, _gloffset_GetQueryivARB),
+    NAME_FUNC_OFFSET( 8175, glIsQueryARB, glIsQueryARB, NULL, _gloffset_IsQueryARB),
+    NAME_FUNC_OFFSET( 8188, glAttachObjectARB, glAttachObjectARB, NULL, _gloffset_AttachObjectARB),
+    NAME_FUNC_OFFSET( 8206, glCompileShaderARB, glCompileShaderARB, NULL, _gloffset_CompileShaderARB),
+    NAME_FUNC_OFFSET( 8225, glCreateProgramObjectARB, glCreateProgramObjectARB, NULL, _gloffset_CreateProgramObjectARB),
+    NAME_FUNC_OFFSET( 8250, glCreateShaderObjectARB, glCreateShaderObjectARB, NULL, _gloffset_CreateShaderObjectARB),
+    NAME_FUNC_OFFSET( 8274, glDeleteObjectARB, glDeleteObjectARB, NULL, _gloffset_DeleteObjectARB),
+    NAME_FUNC_OFFSET( 8292, glDetachObjectARB, glDetachObjectARB, NULL, _gloffset_DetachObjectARB),
+    NAME_FUNC_OFFSET( 8310, glGetActiveUniformARB, glGetActiveUniformARB, NULL, _gloffset_GetActiveUniformARB),
+    NAME_FUNC_OFFSET( 8332, glGetAttachedObjectsARB, glGetAttachedObjectsARB, NULL, _gloffset_GetAttachedObjectsARB),
+    NAME_FUNC_OFFSET( 8356, glGetHandleARB, glGetHandleARB, NULL, _gloffset_GetHandleARB),
+    NAME_FUNC_OFFSET( 8371, glGetInfoLogARB, glGetInfoLogARB, NULL, _gloffset_GetInfoLogARB),
+    NAME_FUNC_OFFSET( 8387, glGetObjectParameterfvARB, glGetObjectParameterfvARB, NULL, _gloffset_GetObjectParameterfvARB),
+    NAME_FUNC_OFFSET( 8413, glGetObjectParameterivARB, glGetObjectParameterivARB, NULL, _gloffset_GetObjectParameterivARB),
+    NAME_FUNC_OFFSET( 8439, glGetShaderSourceARB, glGetShaderSourceARB, NULL, _gloffset_GetShaderSourceARB),
+    NAME_FUNC_OFFSET( 8460, glGetUniformLocationARB, glGetUniformLocationARB, NULL, _gloffset_GetUniformLocationARB),
+    NAME_FUNC_OFFSET( 8484, glGetUniformfvARB, glGetUniformfvARB, NULL, _gloffset_GetUniformfvARB),
+    NAME_FUNC_OFFSET( 8502, glGetUniformivARB, glGetUniformivARB, NULL, _gloffset_GetUniformivARB),
+    NAME_FUNC_OFFSET( 8520, glLinkProgramARB, glLinkProgramARB, NULL, _gloffset_LinkProgramARB),
+    NAME_FUNC_OFFSET( 8537, glShaderSourceARB, glShaderSourceARB, NULL, _gloffset_ShaderSourceARB),
+    NAME_FUNC_OFFSET( 8555, glUniform1fARB, glUniform1fARB, NULL, _gloffset_Uniform1fARB),
+    NAME_FUNC_OFFSET( 8570, glUniform1fvARB, glUniform1fvARB, NULL, _gloffset_Uniform1fvARB),
+    NAME_FUNC_OFFSET( 8586, glUniform1iARB, glUniform1iARB, NULL, _gloffset_Uniform1iARB),
+    NAME_FUNC_OFFSET( 8601, glUniform1ivARB, glUniform1ivARB, NULL, _gloffset_Uniform1ivARB),
+    NAME_FUNC_OFFSET( 8617, glUniform2fARB, glUniform2fARB, NULL, _gloffset_Uniform2fARB),
+    NAME_FUNC_OFFSET( 8632, glUniform2fvARB, glUniform2fvARB, NULL, _gloffset_Uniform2fvARB),
+    NAME_FUNC_OFFSET( 8648, glUniform2iARB, glUniform2iARB, NULL, _gloffset_Uniform2iARB),
+    NAME_FUNC_OFFSET( 8663, glUniform2ivARB, glUniform2ivARB, NULL, _gloffset_Uniform2ivARB),
+    NAME_FUNC_OFFSET( 8679, glUniform3fARB, glUniform3fARB, NULL, _gloffset_Uniform3fARB),
+    NAME_FUNC_OFFSET( 8694, glUniform3fvARB, glUniform3fvARB, NULL, _gloffset_Uniform3fvARB),
+    NAME_FUNC_OFFSET( 8710, glUniform3iARB, glUniform3iARB, NULL, _gloffset_Uniform3iARB),
+    NAME_FUNC_OFFSET( 8725, glUniform3ivARB, glUniform3ivARB, NULL, _gloffset_Uniform3ivARB),
+    NAME_FUNC_OFFSET( 8741, glUniform4fARB, glUniform4fARB, NULL, _gloffset_Uniform4fARB),
+    NAME_FUNC_OFFSET( 8756, glUniform4fvARB, glUniform4fvARB, NULL, _gloffset_Uniform4fvARB),
+    NAME_FUNC_OFFSET( 8772, glUniform4iARB, glUniform4iARB, NULL, _gloffset_Uniform4iARB),
+    NAME_FUNC_OFFSET( 8787, glUniform4ivARB, glUniform4ivARB, NULL, _gloffset_Uniform4ivARB),
+    NAME_FUNC_OFFSET( 8803, glUniformMatrix2fvARB, glUniformMatrix2fvARB, NULL, _gloffset_UniformMatrix2fvARB),
+    NAME_FUNC_OFFSET( 8825, glUniformMatrix3fvARB, glUniformMatrix3fvARB, NULL, _gloffset_UniformMatrix3fvARB),
+    NAME_FUNC_OFFSET( 8847, glUniformMatrix4fvARB, glUniformMatrix4fvARB, NULL, _gloffset_UniformMatrix4fvARB),
+    NAME_FUNC_OFFSET( 8869, glUseProgramObjectARB, glUseProgramObjectARB, NULL, _gloffset_UseProgramObjectARB),
+    NAME_FUNC_OFFSET( 8891, glValidateProgramARB, glValidateProgramARB, NULL, _gloffset_ValidateProgramARB),
+    NAME_FUNC_OFFSET( 8912, glBindAttribLocationARB, glBindAttribLocationARB, NULL, _gloffset_BindAttribLocationARB),
+    NAME_FUNC_OFFSET( 8936, glGetActiveAttribARB, glGetActiveAttribARB, NULL, _gloffset_GetActiveAttribARB),
+    NAME_FUNC_OFFSET( 8957, glGetAttribLocationARB, glGetAttribLocationARB, NULL, _gloffset_GetAttribLocationARB),
+    NAME_FUNC_OFFSET( 8980, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
+    NAME_FUNC_OFFSET( 8997, glRenderbufferStorageMultisample, glRenderbufferStorageMultisample, NULL, _gloffset_RenderbufferStorageMultisample),
+    NAME_FUNC_OFFSET( 9030, glFlushMappedBufferRange, glFlushMappedBufferRange, NULL, _gloffset_FlushMappedBufferRange),
+    NAME_FUNC_OFFSET( 9055, glMapBufferRange, glMapBufferRange, NULL, _gloffset_MapBufferRange),
+    NAME_FUNC_OFFSET( 9072, glBindVertexArray, glBindVertexArray, NULL, _gloffset_BindVertexArray),
+    NAME_FUNC_OFFSET( 9090, glGenVertexArrays, glGenVertexArrays, NULL, _gloffset_GenVertexArrays),
+    NAME_FUNC_OFFSET( 9108, glCopyBufferSubData, glCopyBufferSubData, NULL, _gloffset_CopyBufferSubData),
+    NAME_FUNC_OFFSET( 9128, glClientWaitSync, glClientWaitSync, NULL, _gloffset_ClientWaitSync),
+    NAME_FUNC_OFFSET( 9145, glDeleteSync, glDeleteSync, NULL, _gloffset_DeleteSync),
+    NAME_FUNC_OFFSET( 9158, glFenceSync, glFenceSync, NULL, _gloffset_FenceSync),
+    NAME_FUNC_OFFSET( 9170, glGetInteger64v, glGetInteger64v, NULL, _gloffset_GetInteger64v),
+    NAME_FUNC_OFFSET( 9186, glGetSynciv, glGetSynciv, NULL, _gloffset_GetSynciv),
+    NAME_FUNC_OFFSET( 9198, glIsSync, glIsSync, NULL, _gloffset_IsSync),
+    NAME_FUNC_OFFSET( 9207, glWaitSync, glWaitSync, NULL, _gloffset_WaitSync),
+    NAME_FUNC_OFFSET( 9218, glDrawElementsBaseVertex, glDrawElementsBaseVertex, NULL, _gloffset_DrawElementsBaseVertex),
+    NAME_FUNC_OFFSET( 9243, glDrawRangeElementsBaseVertex, glDrawRangeElementsBaseVertex, NULL, _gloffset_DrawRangeElementsBaseVertex),
+    NAME_FUNC_OFFSET( 9273, glMultiDrawElementsBaseVertex, glMultiDrawElementsBaseVertex, NULL, _gloffset_MultiDrawElementsBaseVertex),
+    NAME_FUNC_OFFSET( 9303, glPolygonOffsetEXT, glPolygonOffsetEXT, NULL, _gloffset_PolygonOffsetEXT),
+    NAME_FUNC_OFFSET( 9322, gl_dispatch_stub_580, gl_dispatch_stub_580, NULL, _gloffset_GetPixelTexGenParameterfvSGIS),
+    NAME_FUNC_OFFSET( 9354, gl_dispatch_stub_581, gl_dispatch_stub_581, NULL, _gloffset_GetPixelTexGenParameterivSGIS),
+    NAME_FUNC_OFFSET( 9386, gl_dispatch_stub_582, gl_dispatch_stub_582, NULL, _gloffset_PixelTexGenParameterfSGIS),
+    NAME_FUNC_OFFSET( 9414, gl_dispatch_stub_583, gl_dispatch_stub_583, NULL, _gloffset_PixelTexGenParameterfvSGIS),
+    NAME_FUNC_OFFSET( 9443, gl_dispatch_stub_584, gl_dispatch_stub_584, NULL, _gloffset_PixelTexGenParameteriSGIS),
+    NAME_FUNC_OFFSET( 9471, gl_dispatch_stub_585, gl_dispatch_stub_585, NULL, _gloffset_PixelTexGenParameterivSGIS),
+    NAME_FUNC_OFFSET( 9500, gl_dispatch_stub_586, gl_dispatch_stub_586, NULL, _gloffset_SampleMaskSGIS),
+    NAME_FUNC_OFFSET( 9517, gl_dispatch_stub_587, gl_dispatch_stub_587, NULL, _gloffset_SamplePatternSGIS),
+    NAME_FUNC_OFFSET( 9537, glColorPointerEXT, glColorPointerEXT, NULL, _gloffset_ColorPointerEXT),
+    NAME_FUNC_OFFSET( 9555, glEdgeFlagPointerEXT, glEdgeFlagPointerEXT, NULL, _gloffset_EdgeFlagPointerEXT),
+    NAME_FUNC_OFFSET( 9576, glIndexPointerEXT, glIndexPointerEXT, NULL, _gloffset_IndexPointerEXT),
+    NAME_FUNC_OFFSET( 9594, glNormalPointerEXT, glNormalPointerEXT, NULL, _gloffset_NormalPointerEXT),
+    NAME_FUNC_OFFSET( 9613, glTexCoordPointerEXT, glTexCoordPointerEXT, NULL, _gloffset_TexCoordPointerEXT),
+    NAME_FUNC_OFFSET( 9634, glVertexPointerEXT, glVertexPointerEXT, NULL, _gloffset_VertexPointerEXT),
+    NAME_FUNC_OFFSET( 9653, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+    NAME_FUNC_OFFSET( 9674, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+    NAME_FUNC_OFFSET( 9696, glLockArraysEXT, glLockArraysEXT, NULL, _gloffset_LockArraysEXT),
+    NAME_FUNC_OFFSET( 9712, glUnlockArraysEXT, glUnlockArraysEXT, NULL, _gloffset_UnlockArraysEXT),
+    NAME_FUNC_OFFSET( 9730, gl_dispatch_stub_598, gl_dispatch_stub_598, NULL, _gloffset_CullParameterdvEXT),
+    NAME_FUNC_OFFSET( 9751, gl_dispatch_stub_599, gl_dispatch_stub_599, NULL, _gloffset_CullParameterfvEXT),
+    NAME_FUNC_OFFSET( 9772, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
+    NAME_FUNC_OFFSET( 9794, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
+    NAME_FUNC_OFFSET( 9817, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
+    NAME_FUNC_OFFSET( 9839, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
+    NAME_FUNC_OFFSET( 9862, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
+    NAME_FUNC_OFFSET( 9884, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
+    NAME_FUNC_OFFSET( 9907, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
+    NAME_FUNC_OFFSET( 9929, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
+    NAME_FUNC_OFFSET( 9952, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
+    NAME_FUNC_OFFSET( 9974, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
+    NAME_FUNC_OFFSET( 9997, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
+    NAME_FUNC_OFFSET(10020, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
+    NAME_FUNC_OFFSET(10044, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
+    NAME_FUNC_OFFSET(10067, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
+    NAME_FUNC_OFFSET(10091, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
+    NAME_FUNC_OFFSET(10114, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
+    NAME_FUNC_OFFSET(10138, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
+    NAME_FUNC_OFFSET(10165, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
+    NAME_FUNC_OFFSET(10186, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
+    NAME_FUNC_OFFSET(10209, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
+    NAME_FUNC_OFFSET(10230, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
+    NAME_FUNC_OFFSET(10245, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
+    NAME_FUNC_OFFSET(10261, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
+    NAME_FUNC_OFFSET(10276, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
+    NAME_FUNC_OFFSET(10292, gl_dispatch_stub_624, gl_dispatch_stub_624, NULL, _gloffset_PixelTexGenSGIX),
+    NAME_FUNC_OFFSET(10310, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
+    NAME_FUNC_OFFSET(10333, glFlushVertexArrayRangeNV, glFlushVertexArrayRangeNV, NULL, _gloffset_FlushVertexArrayRangeNV),
+    NAME_FUNC_OFFSET(10359, glVertexArrayRangeNV, glVertexArrayRangeNV, NULL, _gloffset_VertexArrayRangeNV),
+    NAME_FUNC_OFFSET(10380, glCombinerInputNV, glCombinerInputNV, NULL, _gloffset_CombinerInputNV),
+    NAME_FUNC_OFFSET(10398, glCombinerOutputNV, glCombinerOutputNV, NULL, _gloffset_CombinerOutputNV),
+    NAME_FUNC_OFFSET(10417, glCombinerParameterfNV, glCombinerParameterfNV, NULL, _gloffset_CombinerParameterfNV),
+    NAME_FUNC_OFFSET(10440, glCombinerParameterfvNV, glCombinerParameterfvNV, NULL, _gloffset_CombinerParameterfvNV),
+    NAME_FUNC_OFFSET(10464, glCombinerParameteriNV, glCombinerParameteriNV, NULL, _gloffset_CombinerParameteriNV),
+    NAME_FUNC_OFFSET(10487, glCombinerParameterivNV, glCombinerParameterivNV, NULL, _gloffset_CombinerParameterivNV),
+    NAME_FUNC_OFFSET(10511, glFinalCombinerInputNV, glFinalCombinerInputNV, NULL, _gloffset_FinalCombinerInputNV),
+    NAME_FUNC_OFFSET(10534, glGetCombinerInputParameterfvNV, glGetCombinerInputParameterfvNV, NULL, _gloffset_GetCombinerInputParameterfvNV),
+    NAME_FUNC_OFFSET(10566, glGetCombinerInputParameterivNV, glGetCombinerInputParameterivNV, NULL, _gloffset_GetCombinerInputParameterivNV),
+    NAME_FUNC_OFFSET(10598, glGetCombinerOutputParameterfvNV, glGetCombinerOutputParameterfvNV, NULL, _gloffset_GetCombinerOutputParameterfvNV),
+    NAME_FUNC_OFFSET(10631, glGetCombinerOutputParameterivNV, glGetCombinerOutputParameterivNV, NULL, _gloffset_GetCombinerOutputParameterivNV),
+    NAME_FUNC_OFFSET(10664, glGetFinalCombinerInputParameterfvNV, glGetFinalCombinerInputParameterfvNV, NULL, _gloffset_GetFinalCombinerInputParameterfvNV),
+    NAME_FUNC_OFFSET(10701, glGetFinalCombinerInputParameterivNV, glGetFinalCombinerInputParameterivNV, NULL, _gloffset_GetFinalCombinerInputParameterivNV),
+    NAME_FUNC_OFFSET(10738, glResizeBuffersMESA, glResizeBuffersMESA, NULL, _gloffset_ResizeBuffersMESA),
+    NAME_FUNC_OFFSET(10758, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
+    NAME_FUNC_OFFSET(10776, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
+    NAME_FUNC_OFFSET(10795, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
+    NAME_FUNC_OFFSET(10813, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
+    NAME_FUNC_OFFSET(10832, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
+    NAME_FUNC_OFFSET(10850, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
+    NAME_FUNC_OFFSET(10869, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
+    NAME_FUNC_OFFSET(10887, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
+    NAME_FUNC_OFFSET(10906, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
+    NAME_FUNC_OFFSET(10924, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
+    NAME_FUNC_OFFSET(10943, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
+    NAME_FUNC_OFFSET(10961, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
+    NAME_FUNC_OFFSET(10980, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
+    NAME_FUNC_OFFSET(10998, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
+    NAME_FUNC_OFFSET(11017, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
+    NAME_FUNC_OFFSET(11035, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
+    NAME_FUNC_OFFSET(11054, glWindowPos4dMESA, glWindowPos4dMESA, NULL, _gloffset_WindowPos4dMESA),
+    NAME_FUNC_OFFSET(11072, glWindowPos4dvMESA, glWindowPos4dvMESA, NULL, _gloffset_WindowPos4dvMESA),
+    NAME_FUNC_OFFSET(11091, glWindowPos4fMESA, glWindowPos4fMESA, NULL, _gloffset_WindowPos4fMESA),
+    NAME_FUNC_OFFSET(11109, glWindowPos4fvMESA, glWindowPos4fvMESA, NULL, _gloffset_WindowPos4fvMESA),
+    NAME_FUNC_OFFSET(11128, glWindowPos4iMESA, glWindowPos4iMESA, NULL, _gloffset_WindowPos4iMESA),
+    NAME_FUNC_OFFSET(11146, glWindowPos4ivMESA, glWindowPos4ivMESA, NULL, _gloffset_WindowPos4ivMESA),
+    NAME_FUNC_OFFSET(11165, glWindowPos4sMESA, glWindowPos4sMESA, NULL, _gloffset_WindowPos4sMESA),
+    NAME_FUNC_OFFSET(11183, glWindowPos4svMESA, glWindowPos4svMESA, NULL, _gloffset_WindowPos4svMESA),
+    NAME_FUNC_OFFSET(11202, gl_dispatch_stub_666, gl_dispatch_stub_666, NULL, _gloffset_MultiModeDrawArraysIBM),
+    NAME_FUNC_OFFSET(11227, gl_dispatch_stub_667, gl_dispatch_stub_667, NULL, _gloffset_MultiModeDrawElementsIBM),
+    NAME_FUNC_OFFSET(11254, gl_dispatch_stub_668, gl_dispatch_stub_668, NULL, _gloffset_DeleteFencesNV),
+    NAME_FUNC_OFFSET(11271, gl_dispatch_stub_669, gl_dispatch_stub_669, NULL, _gloffset_FinishFenceNV),
+    NAME_FUNC_OFFSET(11287, gl_dispatch_stub_670, gl_dispatch_stub_670, NULL, _gloffset_GenFencesNV),
+    NAME_FUNC_OFFSET(11301, gl_dispatch_stub_671, gl_dispatch_stub_671, NULL, _gloffset_GetFenceivNV),
+    NAME_FUNC_OFFSET(11316, gl_dispatch_stub_672, gl_dispatch_stub_672, NULL, _gloffset_IsFenceNV),
+    NAME_FUNC_OFFSET(11328, gl_dispatch_stub_673, gl_dispatch_stub_673, NULL, _gloffset_SetFenceNV),
+    NAME_FUNC_OFFSET(11341, gl_dispatch_stub_674, gl_dispatch_stub_674, NULL, _gloffset_TestFenceNV),
+    NAME_FUNC_OFFSET(11355, glAreProgramsResidentNV, glAreProgramsResidentNV, NULL, _gloffset_AreProgramsResidentNV),
+    NAME_FUNC_OFFSET(11379, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
+    NAME_FUNC_OFFSET(11395, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
+    NAME_FUNC_OFFSET(11414, glExecuteProgramNV, glExecuteProgramNV, NULL, _gloffset_ExecuteProgramNV),
+    NAME_FUNC_OFFSET(11433, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
+    NAME_FUNC_OFFSET(11449, glGetProgramParameterdvNV, glGetProgramParameterdvNV, NULL, _gloffset_GetProgramParameterdvNV),
+    NAME_FUNC_OFFSET(11475, glGetProgramParameterfvNV, glGetProgramParameterfvNV, NULL, _gloffset_GetProgramParameterfvNV),
+    NAME_FUNC_OFFSET(11501, glGetProgramStringNV, glGetProgramStringNV, NULL, _gloffset_GetProgramStringNV),
+    NAME_FUNC_OFFSET(11522, glGetProgramivNV, glGetProgramivNV, NULL, _gloffset_GetProgramivNV),
+    NAME_FUNC_OFFSET(11539, glGetTrackMatrixivNV, glGetTrackMatrixivNV, NULL, _gloffset_GetTrackMatrixivNV),
+    NAME_FUNC_OFFSET(11560, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
+    NAME_FUNC_OFFSET(11588, glGetVertexAttribdvNV, glGetVertexAttribdvNV, NULL, _gloffset_GetVertexAttribdvNV),
+    NAME_FUNC_OFFSET(11610, glGetVertexAttribfvNV, glGetVertexAttribfvNV, NULL, _gloffset_GetVertexAttribfvNV),
+    NAME_FUNC_OFFSET(11632, glGetVertexAttribivNV, glGetVertexAttribivNV, NULL, _gloffset_GetVertexAttribivNV),
+    NAME_FUNC_OFFSET(11654, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
+    NAME_FUNC_OFFSET(11668, glLoadProgramNV, glLoadProgramNV, NULL, _gloffset_LoadProgramNV),
+    NAME_FUNC_OFFSET(11684, glProgramParameters4dvNV, glProgramParameters4dvNV, NULL, _gloffset_ProgramParameters4dvNV),
+    NAME_FUNC_OFFSET(11709, glProgramParameters4fvNV, glProgramParameters4fvNV, NULL, _gloffset_ProgramParameters4fvNV),
+    NAME_FUNC_OFFSET(11734, glRequestResidentProgramsNV, glRequestResidentProgramsNV, NULL, _gloffset_RequestResidentProgramsNV),
+    NAME_FUNC_OFFSET(11762, glTrackMatrixNV, glTrackMatrixNV, NULL, _gloffset_TrackMatrixNV),
+    NAME_FUNC_OFFSET(11778, glVertexAttrib1dNV, glVertexAttrib1dNV, NULL, _gloffset_VertexAttrib1dNV),
+    NAME_FUNC_OFFSET(11797, glVertexAttrib1dvNV, glVertexAttrib1dvNV, NULL, _gloffset_VertexAttrib1dvNV),
+    NAME_FUNC_OFFSET(11817, glVertexAttrib1fNV, glVertexAttrib1fNV, NULL, _gloffset_VertexAttrib1fNV),
+    NAME_FUNC_OFFSET(11836, glVertexAttrib1fvNV, glVertexAttrib1fvNV, NULL, _gloffset_VertexAttrib1fvNV),
+    NAME_FUNC_OFFSET(11856, glVertexAttrib1sNV, glVertexAttrib1sNV, NULL, _gloffset_VertexAttrib1sNV),
+    NAME_FUNC_OFFSET(11875, glVertexAttrib1svNV, glVertexAttrib1svNV, NULL, _gloffset_VertexAttrib1svNV),
+    NAME_FUNC_OFFSET(11895, glVertexAttrib2dNV, glVertexAttrib2dNV, NULL, _gloffset_VertexAttrib2dNV),
+    NAME_FUNC_OFFSET(11914, glVertexAttrib2dvNV, glVertexAttrib2dvNV, NULL, _gloffset_VertexAttrib2dvNV),
+    NAME_FUNC_OFFSET(11934, glVertexAttrib2fNV, glVertexAttrib2fNV, NULL, _gloffset_VertexAttrib2fNV),
+    NAME_FUNC_OFFSET(11953, glVertexAttrib2fvNV, glVertexAttrib2fvNV, NULL, _gloffset_VertexAttrib2fvNV),
+    NAME_FUNC_OFFSET(11973, glVertexAttrib2sNV, glVertexAttrib2sNV, NULL, _gloffset_VertexAttrib2sNV),
+    NAME_FUNC_OFFSET(11992, glVertexAttrib2svNV, glVertexAttrib2svNV, NULL, _gloffset_VertexAttrib2svNV),
+    NAME_FUNC_OFFSET(12012, glVertexAttrib3dNV, glVertexAttrib3dNV, NULL, _gloffset_VertexAttrib3dNV),
+    NAME_FUNC_OFFSET(12031, glVertexAttrib3dvNV, glVertexAttrib3dvNV, NULL, _gloffset_VertexAttrib3dvNV),
+    NAME_FUNC_OFFSET(12051, glVertexAttrib3fNV, glVertexAttrib3fNV, NULL, _gloffset_VertexAttrib3fNV),
+    NAME_FUNC_OFFSET(12070, glVertexAttrib3fvNV, glVertexAttrib3fvNV, NULL, _gloffset_VertexAttrib3fvNV),
+    NAME_FUNC_OFFSET(12090, glVertexAttrib3sNV, glVertexAttrib3sNV, NULL, _gloffset_VertexAttrib3sNV),
+    NAME_FUNC_OFFSET(12109, glVertexAttrib3svNV, glVertexAttrib3svNV, NULL, _gloffset_VertexAttrib3svNV),
+    NAME_FUNC_OFFSET(12129, glVertexAttrib4dNV, glVertexAttrib4dNV, NULL, _gloffset_VertexAttrib4dNV),
+    NAME_FUNC_OFFSET(12148, glVertexAttrib4dvNV, glVertexAttrib4dvNV, NULL, _gloffset_VertexAttrib4dvNV),
+    NAME_FUNC_OFFSET(12168, glVertexAttrib4fNV, glVertexAttrib4fNV, NULL, _gloffset_VertexAttrib4fNV),
+    NAME_FUNC_OFFSET(12187, glVertexAttrib4fvNV, glVertexAttrib4fvNV, NULL, _gloffset_VertexAttrib4fvNV),
+    NAME_FUNC_OFFSET(12207, glVertexAttrib4sNV, glVertexAttrib4sNV, NULL, _gloffset_VertexAttrib4sNV),
+    NAME_FUNC_OFFSET(12226, glVertexAttrib4svNV, glVertexAttrib4svNV, NULL, _gloffset_VertexAttrib4svNV),
+    NAME_FUNC_OFFSET(12246, glVertexAttrib4ubNV, glVertexAttrib4ubNV, NULL, _gloffset_VertexAttrib4ubNV),
+    NAME_FUNC_OFFSET(12266, glVertexAttrib4ubvNV, glVertexAttrib4ubvNV, NULL, _gloffset_VertexAttrib4ubvNV),
+    NAME_FUNC_OFFSET(12287, glVertexAttribPointerNV, glVertexAttribPointerNV, NULL, _gloffset_VertexAttribPointerNV),
+    NAME_FUNC_OFFSET(12311, glVertexAttribs1dvNV, glVertexAttribs1dvNV, NULL, _gloffset_VertexAttribs1dvNV),
+    NAME_FUNC_OFFSET(12332, glVertexAttribs1fvNV, glVertexAttribs1fvNV, NULL, _gloffset_VertexAttribs1fvNV),
+    NAME_FUNC_OFFSET(12353, glVertexAttribs1svNV, glVertexAttribs1svNV, NULL, _gloffset_VertexAttribs1svNV),
+    NAME_FUNC_OFFSET(12374, glVertexAttribs2dvNV, glVertexAttribs2dvNV, NULL, _gloffset_VertexAttribs2dvNV),
+    NAME_FUNC_OFFSET(12395, glVertexAttribs2fvNV, glVertexAttribs2fvNV, NULL, _gloffset_VertexAttribs2fvNV),
+    NAME_FUNC_OFFSET(12416, glVertexAttribs2svNV, glVertexAttribs2svNV, NULL, _gloffset_VertexAttribs2svNV),
+    NAME_FUNC_OFFSET(12437, glVertexAttribs3dvNV, glVertexAttribs3dvNV, NULL, _gloffset_VertexAttribs3dvNV),
+    NAME_FUNC_OFFSET(12458, glVertexAttribs3fvNV, glVertexAttribs3fvNV, NULL, _gloffset_VertexAttribs3fvNV),
+    NAME_FUNC_OFFSET(12479, glVertexAttribs3svNV, glVertexAttribs3svNV, NULL, _gloffset_VertexAttribs3svNV),
+    NAME_FUNC_OFFSET(12500, glVertexAttribs4dvNV, glVertexAttribs4dvNV, NULL, _gloffset_VertexAttribs4dvNV),
+    NAME_FUNC_OFFSET(12521, glVertexAttribs4fvNV, glVertexAttribs4fvNV, NULL, _gloffset_VertexAttribs4fvNV),
+    NAME_FUNC_OFFSET(12542, glVertexAttribs4svNV, glVertexAttribs4svNV, NULL, _gloffset_VertexAttribs4svNV),
+    NAME_FUNC_OFFSET(12563, glVertexAttribs4ubvNV, glVertexAttribs4ubvNV, NULL, _gloffset_VertexAttribs4ubvNV),
+    NAME_FUNC_OFFSET(12585, glGetTexBumpParameterfvATI, glGetTexBumpParameterfvATI, NULL, _gloffset_GetTexBumpParameterfvATI),
+    NAME_FUNC_OFFSET(12612, glGetTexBumpParameterivATI, glGetTexBumpParameterivATI, NULL, _gloffset_GetTexBumpParameterivATI),
+    NAME_FUNC_OFFSET(12639, glTexBumpParameterfvATI, glTexBumpParameterfvATI, NULL, _gloffset_TexBumpParameterfvATI),
+    NAME_FUNC_OFFSET(12663, glTexBumpParameterivATI, glTexBumpParameterivATI, NULL, _gloffset_TexBumpParameterivATI),
+    NAME_FUNC_OFFSET(12687, glAlphaFragmentOp1ATI, glAlphaFragmentOp1ATI, NULL, _gloffset_AlphaFragmentOp1ATI),
+    NAME_FUNC_OFFSET(12709, glAlphaFragmentOp2ATI, glAlphaFragmentOp2ATI, NULL, _gloffset_AlphaFragmentOp2ATI),
+    NAME_FUNC_OFFSET(12731, glAlphaFragmentOp3ATI, glAlphaFragmentOp3ATI, NULL, _gloffset_AlphaFragmentOp3ATI),
+    NAME_FUNC_OFFSET(12753, glBeginFragmentShaderATI, glBeginFragmentShaderATI, NULL, _gloffset_BeginFragmentShaderATI),
+    NAME_FUNC_OFFSET(12778, glBindFragmentShaderATI, glBindFragmentShaderATI, NULL, _gloffset_BindFragmentShaderATI),
+    NAME_FUNC_OFFSET(12802, glColorFragmentOp1ATI, glColorFragmentOp1ATI, NULL, _gloffset_ColorFragmentOp1ATI),
+    NAME_FUNC_OFFSET(12824, glColorFragmentOp2ATI, glColorFragmentOp2ATI, NULL, _gloffset_ColorFragmentOp2ATI),
+    NAME_FUNC_OFFSET(12846, glColorFragmentOp3ATI, glColorFragmentOp3ATI, NULL, _gloffset_ColorFragmentOp3ATI),
+    NAME_FUNC_OFFSET(12868, glDeleteFragmentShaderATI, glDeleteFragmentShaderATI, NULL, _gloffset_DeleteFragmentShaderATI),
+    NAME_FUNC_OFFSET(12894, glEndFragmentShaderATI, glEndFragmentShaderATI, NULL, _gloffset_EndFragmentShaderATI),
+    NAME_FUNC_OFFSET(12917, glGenFragmentShadersATI, glGenFragmentShadersATI, NULL, _gloffset_GenFragmentShadersATI),
+    NAME_FUNC_OFFSET(12941, glPassTexCoordATI, glPassTexCoordATI, NULL, _gloffset_PassTexCoordATI),
+    NAME_FUNC_OFFSET(12959, glSampleMapATI, glSampleMapATI, NULL, _gloffset_SampleMapATI),
+    NAME_FUNC_OFFSET(12974, glSetFragmentShaderConstantATI, glSetFragmentShaderConstantATI, NULL, _gloffset_SetFragmentShaderConstantATI),
+    NAME_FUNC_OFFSET(13005, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
+    NAME_FUNC_OFFSET(13025, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
+    NAME_FUNC_OFFSET(13046, gl_dispatch_stub_755, gl_dispatch_stub_755, NULL, _gloffset_ActiveStencilFaceEXT),
+    NAME_FUNC_OFFSET(13069, gl_dispatch_stub_756, gl_dispatch_stub_756, NULL, _gloffset_BindVertexArrayAPPLE),
+    NAME_FUNC_OFFSET(13092, gl_dispatch_stub_757, gl_dispatch_stub_757, NULL, _gloffset_DeleteVertexArraysAPPLE),
+    NAME_FUNC_OFFSET(13118, gl_dispatch_stub_758, gl_dispatch_stub_758, NULL, _gloffset_GenVertexArraysAPPLE),
+    NAME_FUNC_OFFSET(13141, gl_dispatch_stub_759, gl_dispatch_stub_759, NULL, _gloffset_IsVertexArrayAPPLE),
+    NAME_FUNC_OFFSET(13162, glGetProgramNamedParameterdvNV, glGetProgramNamedParameterdvNV, NULL, _gloffset_GetProgramNamedParameterdvNV),
+    NAME_FUNC_OFFSET(13193, glGetProgramNamedParameterfvNV, glGetProgramNamedParameterfvNV, NULL, _gloffset_GetProgramNamedParameterfvNV),
+    NAME_FUNC_OFFSET(13224, glProgramNamedParameter4dNV, glProgramNamedParameter4dNV, NULL, _gloffset_ProgramNamedParameter4dNV),
+    NAME_FUNC_OFFSET(13252, glProgramNamedParameter4dvNV, glProgramNamedParameter4dvNV, NULL, _gloffset_ProgramNamedParameter4dvNV),
+    NAME_FUNC_OFFSET(13281, glProgramNamedParameter4fNV, glProgramNamedParameter4fNV, NULL, _gloffset_ProgramNamedParameter4fNV),
+    NAME_FUNC_OFFSET(13309, glProgramNamedParameter4fvNV, glProgramNamedParameter4fvNV, NULL, _gloffset_ProgramNamedParameter4fvNV),
+    NAME_FUNC_OFFSET(13338, gl_dispatch_stub_766, gl_dispatch_stub_766, NULL, _gloffset_DepthBoundsEXT),
+    NAME_FUNC_OFFSET(13355, gl_dispatch_stub_767, gl_dispatch_stub_767, NULL, _gloffset_BlendEquationSeparateEXT),
+    NAME_FUNC_OFFSET(13382, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
+    NAME_FUNC_OFFSET(13403, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
+    NAME_FUNC_OFFSET(13425, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
+    NAME_FUNC_OFFSET(13453, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
+    NAME_FUNC_OFFSET(13477, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
+    NAME_FUNC_OFFSET(13502, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
+    NAME_FUNC_OFFSET(13531, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
+    NAME_FUNC_OFFSET(13557, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
+    NAME_FUNC_OFFSET(13583, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
+    NAME_FUNC_OFFSET(13609, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
+    NAME_FUNC_OFFSET(13630, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
+    NAME_FUNC_OFFSET(13652, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
+    NAME_FUNC_OFFSET(13672, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
+    NAME_FUNC_OFFSET(13713, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
+    NAME_FUNC_OFFSET(13745, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
+    NAME_FUNC_OFFSET(13764, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
+    NAME_FUNC_OFFSET(13784, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
+    NAME_FUNC_OFFSET(13809, gl_dispatch_stub_785, gl_dispatch_stub_785, NULL, _gloffset_BlitFramebufferEXT),
+    NAME_FUNC_OFFSET(13830, gl_dispatch_stub_786, gl_dispatch_stub_786, NULL, _gloffset_BufferParameteriAPPLE),
+    NAME_FUNC_OFFSET(13854, gl_dispatch_stub_787, gl_dispatch_stub_787, NULL, _gloffset_FlushMappedBufferRangeAPPLE),
+    NAME_FUNC_OFFSET(13884, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
+    NAME_FUNC_OFFSET(13913, glColorMaskIndexedEXT, glColorMaskIndexedEXT, NULL, _gloffset_ColorMaskIndexedEXT),
+    NAME_FUNC_OFFSET(13935, glDisableIndexedEXT, glDisableIndexedEXT, NULL, _gloffset_DisableIndexedEXT),
+    NAME_FUNC_OFFSET(13955, glEnableIndexedEXT, glEnableIndexedEXT, NULL, _gloffset_EnableIndexedEXT),
+    NAME_FUNC_OFFSET(13974, glGetBooleanIndexedvEXT, glGetBooleanIndexedvEXT, NULL, _gloffset_GetBooleanIndexedvEXT),
+    NAME_FUNC_OFFSET(13998, glGetIntegerIndexedvEXT, glGetIntegerIndexedvEXT, NULL, _gloffset_GetIntegerIndexedvEXT),
+    NAME_FUNC_OFFSET(14022, glIsEnabledIndexedEXT, glIsEnabledIndexedEXT, NULL, _gloffset_IsEnabledIndexedEXT),
+    NAME_FUNC_OFFSET(14044, glBeginConditionalRenderNV, glBeginConditionalRenderNV, NULL, _gloffset_BeginConditionalRenderNV),
+    NAME_FUNC_OFFSET(14071, glEndConditionalRenderNV, glEndConditionalRenderNV, NULL, _gloffset_EndConditionalRenderNV),
+    NAME_FUNC_OFFSET(14096, glBeginTransformFeedbackEXT, glBeginTransformFeedbackEXT, NULL, _gloffset_BeginTransformFeedbackEXT),
+    NAME_FUNC_OFFSET(14124, glBindBufferBaseEXT, glBindBufferBaseEXT, NULL, _gloffset_BindBufferBaseEXT),
+    NAME_FUNC_OFFSET(14144, glBindBufferOffsetEXT, glBindBufferOffsetEXT, NULL, _gloffset_BindBufferOffsetEXT),
+    NAME_FUNC_OFFSET(14166, glBindBufferRangeEXT, glBindBufferRangeEXT, NULL, _gloffset_BindBufferRangeEXT),
+    NAME_FUNC_OFFSET(14187, glEndTransformFeedbackEXT, glEndTransformFeedbackEXT, NULL, _gloffset_EndTransformFeedbackEXT),
+    NAME_FUNC_OFFSET(14213, glGetTransformFeedbackVaryingEXT, glGetTransformFeedbackVaryingEXT, NULL, _gloffset_GetTransformFeedbackVaryingEXT),
+    NAME_FUNC_OFFSET(14246, glTransformFeedbackVaryingsEXT, glTransformFeedbackVaryingsEXT, NULL, _gloffset_TransformFeedbackVaryingsEXT),
+    NAME_FUNC_OFFSET(14277, glProvokingVertexEXT, glProvokingVertexEXT, NULL, _gloffset_ProvokingVertexEXT),
+    NAME_FUNC_OFFSET(14298, gl_dispatch_stub_805, gl_dispatch_stub_805, NULL, _gloffset_GetTexParameterPointervAPPLE),
+    NAME_FUNC_OFFSET(14329, gl_dispatch_stub_806, gl_dispatch_stub_806, NULL, _gloffset_TextureRangeAPPLE),
+    NAME_FUNC_OFFSET(14349, glGetObjectParameterivAPPLE, glGetObjectParameterivAPPLE, NULL, _gloffset_GetObjectParameterivAPPLE),
+    NAME_FUNC_OFFSET(14377, glObjectPurgeableAPPLE, glObjectPurgeableAPPLE, NULL, _gloffset_ObjectPurgeableAPPLE),
+    NAME_FUNC_OFFSET(14400, glObjectUnpurgeableAPPLE, glObjectUnpurgeableAPPLE, NULL, _gloffset_ObjectUnpurgeableAPPLE),
+    NAME_FUNC_OFFSET(14425, gl_dispatch_stub_810, gl_dispatch_stub_810, NULL, _gloffset_StencilFuncSeparateATI),
+    NAME_FUNC_OFFSET(14450, gl_dispatch_stub_811, gl_dispatch_stub_811, NULL, _gloffset_ProgramEnvParameters4fvEXT),
+    NAME_FUNC_OFFSET(14479, gl_dispatch_stub_812, gl_dispatch_stub_812, NULL, _gloffset_ProgramLocalParameters4fvEXT),
+    NAME_FUNC_OFFSET(14510, gl_dispatch_stub_813, gl_dispatch_stub_813, NULL, _gloffset_GetQueryObjecti64vEXT),
+    NAME_FUNC_OFFSET(14534, gl_dispatch_stub_814, gl_dispatch_stub_814, NULL, _gloffset_GetQueryObjectui64vEXT),
+    NAME_FUNC_OFFSET(14559, glEGLImageTargetRenderbufferStorageOES, glEGLImageTargetRenderbufferStorageOES, NULL, _gloffset_EGLImageTargetRenderbufferStorageOES),
+    NAME_FUNC_OFFSET(14598, glEGLImageTargetTexture2DOES, glEGLImageTargetTexture2DOES, NULL, _gloffset_EGLImageTargetTexture2DOES),
+    NAME_FUNC_OFFSET(14627, glArrayElement, glArrayElement, NULL, _gloffset_ArrayElement),
+    NAME_FUNC_OFFSET(14645, glBindTexture, glBindTexture, NULL, _gloffset_BindTexture),
+    NAME_FUNC_OFFSET(14662, glDrawArrays, glDrawArrays, NULL, _gloffset_DrawArrays),
+    NAME_FUNC_OFFSET(14678, glAreTexturesResident, glAreTexturesResidentEXT, glAreTexturesResidentEXT, _gloffset_AreTexturesResident),
+    NAME_FUNC_OFFSET(14703, glCopyTexImage1D, glCopyTexImage1D, NULL, _gloffset_CopyTexImage1D),
+    NAME_FUNC_OFFSET(14723, glCopyTexImage2D, glCopyTexImage2D, NULL, _gloffset_CopyTexImage2D),
+    NAME_FUNC_OFFSET(14743, glCopyTexSubImage1D, glCopyTexSubImage1D, NULL, _gloffset_CopyTexSubImage1D),
+    NAME_FUNC_OFFSET(14766, glCopyTexSubImage2D, glCopyTexSubImage2D, NULL, _gloffset_CopyTexSubImage2D),
+    NAME_FUNC_OFFSET(14789, glDeleteTextures, glDeleteTexturesEXT, glDeleteTexturesEXT, _gloffset_DeleteTextures),
+    NAME_FUNC_OFFSET(14809, glGenTextures, glGenTexturesEXT, glGenTexturesEXT, _gloffset_GenTextures),
+    NAME_FUNC_OFFSET(14826, glGetPointerv, glGetPointerv, NULL, _gloffset_GetPointerv),
+    NAME_FUNC_OFFSET(14843, glIsTexture, glIsTextureEXT, glIsTextureEXT, _gloffset_IsTexture),
+    NAME_FUNC_OFFSET(14858, glPrioritizeTextures, glPrioritizeTextures, NULL, _gloffset_PrioritizeTextures),
+    NAME_FUNC_OFFSET(14882, glTexSubImage1D, glTexSubImage1D, NULL, _gloffset_TexSubImage1D),
+    NAME_FUNC_OFFSET(14901, glTexSubImage2D, glTexSubImage2D, NULL, _gloffset_TexSubImage2D),
+    NAME_FUNC_OFFSET(14920, glBlendColor, glBlendColor, NULL, _gloffset_BlendColor),
+    NAME_FUNC_OFFSET(14936, glBlendEquation, glBlendEquation, NULL, _gloffset_BlendEquation),
+    NAME_FUNC_OFFSET(14955, glDrawRangeElements, glDrawRangeElements, NULL, _gloffset_DrawRangeElements),
+    NAME_FUNC_OFFSET(14978, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
+    NAME_FUNC_OFFSET(14994, glColorTable, glColorTable, NULL, _gloffset_ColorTable),
+    NAME_FUNC_OFFSET(15010, glColorTableParameterfv, glColorTableParameterfv, NULL, _gloffset_ColorTableParameterfv),
+    NAME_FUNC_OFFSET(15037, glColorTableParameteriv, glColorTableParameteriv, NULL, _gloffset_ColorTableParameteriv),
+    NAME_FUNC_OFFSET(15064, glCopyColorTable, glCopyColorTable, NULL, _gloffset_CopyColorTable),
+    NAME_FUNC_OFFSET(15084, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
+    NAME_FUNC_OFFSET(15103, glGetColorTable, glGetColorTableEXT, glGetColorTableEXT, _gloffset_GetColorTable),
+    NAME_FUNC_OFFSET(15122, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
+    NAME_FUNC_OFFSET(15152, glGetColorTableParameterfv, glGetColorTableParameterfvEXT, glGetColorTableParameterfvEXT, _gloffset_GetColorTableParameterfv),
+    NAME_FUNC_OFFSET(15182, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
+    NAME_FUNC_OFFSET(15212, glGetColorTableParameteriv, glGetColorTableParameterivEXT, glGetColorTableParameterivEXT, _gloffset_GetColorTableParameteriv),
+    NAME_FUNC_OFFSET(15242, glColorSubTable, glColorSubTable, NULL, _gloffset_ColorSubTable),
+    NAME_FUNC_OFFSET(15261, glCopyColorSubTable, glCopyColorSubTable, NULL, _gloffset_CopyColorSubTable),
+    NAME_FUNC_OFFSET(15284, glConvolutionFilter1D, glConvolutionFilter1D, NULL, _gloffset_ConvolutionFilter1D),
+    NAME_FUNC_OFFSET(15309, glConvolutionFilter2D, glConvolutionFilter2D, NULL, _gloffset_ConvolutionFilter2D),
+    NAME_FUNC_OFFSET(15334, glConvolutionParameterf, glConvolutionParameterf, NULL, _gloffset_ConvolutionParameterf),
+    NAME_FUNC_OFFSET(15361, glConvolutionParameterfv, glConvolutionParameterfv, NULL, _gloffset_ConvolutionParameterfv),
+    NAME_FUNC_OFFSET(15389, glConvolutionParameteri, glConvolutionParameteri, NULL, _gloffset_ConvolutionParameteri),
+    NAME_FUNC_OFFSET(15416, glConvolutionParameteriv, glConvolutionParameteriv, NULL, _gloffset_ConvolutionParameteriv),
+    NAME_FUNC_OFFSET(15444, glCopyConvolutionFilter1D, glCopyConvolutionFilter1D, NULL, _gloffset_CopyConvolutionFilter1D),
+    NAME_FUNC_OFFSET(15473, glCopyConvolutionFilter2D, glCopyConvolutionFilter2D, NULL, _gloffset_CopyConvolutionFilter2D),
+    NAME_FUNC_OFFSET(15502, glGetConvolutionFilter, gl_dispatch_stub_356, gl_dispatch_stub_356, _gloffset_GetConvolutionFilter),
+    NAME_FUNC_OFFSET(15528, glGetConvolutionParameterfv, gl_dispatch_stub_357, gl_dispatch_stub_357, _gloffset_GetConvolutionParameterfv),
+    NAME_FUNC_OFFSET(15559, glGetConvolutionParameteriv, gl_dispatch_stub_358, gl_dispatch_stub_358, _gloffset_GetConvolutionParameteriv),
+    NAME_FUNC_OFFSET(15590, glGetSeparableFilter, gl_dispatch_stub_359, gl_dispatch_stub_359, _gloffset_GetSeparableFilter),
+    NAME_FUNC_OFFSET(15614, glSeparableFilter2D, glSeparableFilter2D, NULL, _gloffset_SeparableFilter2D),
+    NAME_FUNC_OFFSET(15637, glGetHistogram, gl_dispatch_stub_361, gl_dispatch_stub_361, _gloffset_GetHistogram),
+    NAME_FUNC_OFFSET(15655, glGetHistogramParameterfv, gl_dispatch_stub_362, gl_dispatch_stub_362, _gloffset_GetHistogramParameterfv),
+    NAME_FUNC_OFFSET(15684, glGetHistogramParameteriv, gl_dispatch_stub_363, gl_dispatch_stub_363, _gloffset_GetHistogramParameteriv),
+    NAME_FUNC_OFFSET(15713, glGetMinmax, gl_dispatch_stub_364, gl_dispatch_stub_364, _gloffset_GetMinmax),
+    NAME_FUNC_OFFSET(15728, glGetMinmaxParameterfv, gl_dispatch_stub_365, gl_dispatch_stub_365, _gloffset_GetMinmaxParameterfv),
+    NAME_FUNC_OFFSET(15754, glGetMinmaxParameteriv, gl_dispatch_stub_366, gl_dispatch_stub_366, _gloffset_GetMinmaxParameteriv),
+    NAME_FUNC_OFFSET(15780, glHistogram, glHistogram, NULL, _gloffset_Histogram),
+    NAME_FUNC_OFFSET(15795, glMinmax, glMinmax, NULL, _gloffset_Minmax),
+    NAME_FUNC_OFFSET(15807, glResetHistogram, glResetHistogram, NULL, _gloffset_ResetHistogram),
+    NAME_FUNC_OFFSET(15827, glResetMinmax, glResetMinmax, NULL, _gloffset_ResetMinmax),
+    NAME_FUNC_OFFSET(15844, glTexImage3D, glTexImage3D, NULL, _gloffset_TexImage3D),
+    NAME_FUNC_OFFSET(15860, glTexSubImage3D, glTexSubImage3D, NULL, _gloffset_TexSubImage3D),
+    NAME_FUNC_OFFSET(15879, glCopyTexSubImage3D, glCopyTexSubImage3D, NULL, _gloffset_CopyTexSubImage3D),
+    NAME_FUNC_OFFSET(15902, glActiveTextureARB, glActiveTextureARB, NULL, _gloffset_ActiveTextureARB),
+    NAME_FUNC_OFFSET(15918, glClientActiveTextureARB, glClientActiveTextureARB, NULL, _gloffset_ClientActiveTextureARB),
+    NAME_FUNC_OFFSET(15940, glMultiTexCoord1dARB, glMultiTexCoord1dARB, NULL, _gloffset_MultiTexCoord1dARB),
+    NAME_FUNC_OFFSET(15958, glMultiTexCoord1dvARB, glMultiTexCoord1dvARB, NULL, _gloffset_MultiTexCoord1dvARB),
+    NAME_FUNC_OFFSET(15977, glMultiTexCoord1fARB, glMultiTexCoord1fARB, NULL, _gloffset_MultiTexCoord1fARB),
+    NAME_FUNC_OFFSET(15995, glMultiTexCoord1fvARB, glMultiTexCoord1fvARB, NULL, _gloffset_MultiTexCoord1fvARB),
+    NAME_FUNC_OFFSET(16014, glMultiTexCoord1iARB, glMultiTexCoord1iARB, NULL, _gloffset_MultiTexCoord1iARB),
+    NAME_FUNC_OFFSET(16032, glMultiTexCoord1ivARB, glMultiTexCoord1ivARB, NULL, _gloffset_MultiTexCoord1ivARB),
+    NAME_FUNC_OFFSET(16051, glMultiTexCoord1sARB, glMultiTexCoord1sARB, NULL, _gloffset_MultiTexCoord1sARB),
+    NAME_FUNC_OFFSET(16069, glMultiTexCoord1svARB, glMultiTexCoord1svARB, NULL, _gloffset_MultiTexCoord1svARB),
+    NAME_FUNC_OFFSET(16088, glMultiTexCoord2dARB, glMultiTexCoord2dARB, NULL, _gloffset_MultiTexCoord2dARB),
+    NAME_FUNC_OFFSET(16106, glMultiTexCoord2dvARB, glMultiTexCoord2dvARB, NULL, _gloffset_MultiTexCoord2dvARB),
+    NAME_FUNC_OFFSET(16125, glMultiTexCoord2fARB, glMultiTexCoord2fARB, NULL, _gloffset_MultiTexCoord2fARB),
+    NAME_FUNC_OFFSET(16143, glMultiTexCoord2fvARB, glMultiTexCoord2fvARB, NULL, _gloffset_MultiTexCoord2fvARB),
+    NAME_FUNC_OFFSET(16162, glMultiTexCoord2iARB, glMultiTexCoord2iARB, NULL, _gloffset_MultiTexCoord2iARB),
+    NAME_FUNC_OFFSET(16180, glMultiTexCoord2ivARB, glMultiTexCoord2ivARB, NULL, _gloffset_MultiTexCoord2ivARB),
+    NAME_FUNC_OFFSET(16199, glMultiTexCoord2sARB, glMultiTexCoord2sARB, NULL, _gloffset_MultiTexCoord2sARB),
+    NAME_FUNC_OFFSET(16217, glMultiTexCoord2svARB, glMultiTexCoord2svARB, NULL, _gloffset_MultiTexCoord2svARB),
+    NAME_FUNC_OFFSET(16236, glMultiTexCoord3dARB, glMultiTexCoord3dARB, NULL, _gloffset_MultiTexCoord3dARB),
+    NAME_FUNC_OFFSET(16254, glMultiTexCoord3dvARB, glMultiTexCoord3dvARB, NULL, _gloffset_MultiTexCoord3dvARB),
+    NAME_FUNC_OFFSET(16273, glMultiTexCoord3fARB, glMultiTexCoord3fARB, NULL, _gloffset_MultiTexCoord3fARB),
+    NAME_FUNC_OFFSET(16291, glMultiTexCoord3fvARB, glMultiTexCoord3fvARB, NULL, _gloffset_MultiTexCoord3fvARB),
+    NAME_FUNC_OFFSET(16310, glMultiTexCoord3iARB, glMultiTexCoord3iARB, NULL, _gloffset_MultiTexCoord3iARB),
+    NAME_FUNC_OFFSET(16328, glMultiTexCoord3ivARB, glMultiTexCoord3ivARB, NULL, _gloffset_MultiTexCoord3ivARB),
+    NAME_FUNC_OFFSET(16347, glMultiTexCoord3sARB, glMultiTexCoord3sARB, NULL, _gloffset_MultiTexCoord3sARB),
+    NAME_FUNC_OFFSET(16365, glMultiTexCoord3svARB, glMultiTexCoord3svARB, NULL, _gloffset_MultiTexCoord3svARB),
+    NAME_FUNC_OFFSET(16384, glMultiTexCoord4dARB, glMultiTexCoord4dARB, NULL, _gloffset_MultiTexCoord4dARB),
+    NAME_FUNC_OFFSET(16402, glMultiTexCoord4dvARB, glMultiTexCoord4dvARB, NULL, _gloffset_MultiTexCoord4dvARB),
+    NAME_FUNC_OFFSET(16421, glMultiTexCoord4fARB, glMultiTexCoord4fARB, NULL, _gloffset_MultiTexCoord4fARB),
+    NAME_FUNC_OFFSET(16439, glMultiTexCoord4fvARB, glMultiTexCoord4fvARB, NULL, _gloffset_MultiTexCoord4fvARB),
+    NAME_FUNC_OFFSET(16458, glMultiTexCoord4iARB, glMultiTexCoord4iARB, NULL, _gloffset_MultiTexCoord4iARB),
+    NAME_FUNC_OFFSET(16476, glMultiTexCoord4ivARB, glMultiTexCoord4ivARB, NULL, _gloffset_MultiTexCoord4ivARB),
+    NAME_FUNC_OFFSET(16495, glMultiTexCoord4sARB, glMultiTexCoord4sARB, NULL, _gloffset_MultiTexCoord4sARB),
+    NAME_FUNC_OFFSET(16513, glMultiTexCoord4svARB, glMultiTexCoord4svARB, NULL, _gloffset_MultiTexCoord4svARB),
+    NAME_FUNC_OFFSET(16532, glStencilOpSeparate, glStencilOpSeparate, NULL, _gloffset_StencilOpSeparate),
+    NAME_FUNC_OFFSET(16555, glDrawArraysInstanced, glDrawArraysInstanced, NULL, _gloffset_DrawArraysInstanced),
+    NAME_FUNC_OFFSET(16580, glDrawArraysInstanced, glDrawArraysInstanced, NULL, _gloffset_DrawArraysInstanced),
+    NAME_FUNC_OFFSET(16605, glDrawElementsInstanced, glDrawElementsInstanced, NULL, _gloffset_DrawElementsInstanced),
+    NAME_FUNC_OFFSET(16632, glDrawElementsInstanced, glDrawElementsInstanced, NULL, _gloffset_DrawElementsInstanced),
+    NAME_FUNC_OFFSET(16659, glLoadTransposeMatrixdARB, glLoadTransposeMatrixdARB, NULL, _gloffset_LoadTransposeMatrixdARB),
+    NAME_FUNC_OFFSET(16682, glLoadTransposeMatrixfARB, glLoadTransposeMatrixfARB, NULL, _gloffset_LoadTransposeMatrixfARB),
+    NAME_FUNC_OFFSET(16705, glMultTransposeMatrixdARB, glMultTransposeMatrixdARB, NULL, _gloffset_MultTransposeMatrixdARB),
+    NAME_FUNC_OFFSET(16728, glMultTransposeMatrixfARB, glMultTransposeMatrixfARB, NULL, _gloffset_MultTransposeMatrixfARB),
+    NAME_FUNC_OFFSET(16751, glSampleCoverageARB, glSampleCoverageARB, NULL, _gloffset_SampleCoverageARB),
+    NAME_FUNC_OFFSET(16768, glCompressedTexImage1DARB, glCompressedTexImage1DARB, NULL, _gloffset_CompressedTexImage1DARB),
+    NAME_FUNC_OFFSET(16791, glCompressedTexImage2DARB, glCompressedTexImage2DARB, NULL, _gloffset_CompressedTexImage2DARB),
+    NAME_FUNC_OFFSET(16814, glCompressedTexImage3DARB, glCompressedTexImage3DARB, NULL, _gloffset_CompressedTexImage3DARB),
+    NAME_FUNC_OFFSET(16837, glCompressedTexSubImage1DARB, glCompressedTexSubImage1DARB, NULL, _gloffset_CompressedTexSubImage1DARB),
+    NAME_FUNC_OFFSET(16863, glCompressedTexSubImage2DARB, glCompressedTexSubImage2DARB, NULL, _gloffset_CompressedTexSubImage2DARB),
+    NAME_FUNC_OFFSET(16889, glCompressedTexSubImage3DARB, glCompressedTexSubImage3DARB, NULL, _gloffset_CompressedTexSubImage3DARB),
+    NAME_FUNC_OFFSET(16915, glGetCompressedTexImageARB, glGetCompressedTexImageARB, NULL, _gloffset_GetCompressedTexImageARB),
+    NAME_FUNC_OFFSET(16939, glDisableVertexAttribArrayARB, glDisableVertexAttribArrayARB, NULL, _gloffset_DisableVertexAttribArrayARB),
+    NAME_FUNC_OFFSET(16966, glEnableVertexAttribArrayARB, glEnableVertexAttribArrayARB, NULL, _gloffset_EnableVertexAttribArrayARB),
+    NAME_FUNC_OFFSET(16992, glGetVertexAttribdvARB, glGetVertexAttribdvARB, NULL, _gloffset_GetVertexAttribdvARB),
+    NAME_FUNC_OFFSET(17012, glGetVertexAttribfvARB, glGetVertexAttribfvARB, NULL, _gloffset_GetVertexAttribfvARB),
+    NAME_FUNC_OFFSET(17032, glGetVertexAttribivARB, glGetVertexAttribivARB, NULL, _gloffset_GetVertexAttribivARB),
+    NAME_FUNC_OFFSET(17052, glProgramEnvParameter4dARB, glProgramEnvParameter4dARB, NULL, _gloffset_ProgramEnvParameter4dARB),
+    NAME_FUNC_OFFSET(17075, glProgramEnvParameter4dvARB, glProgramEnvParameter4dvARB, NULL, _gloffset_ProgramEnvParameter4dvARB),
+    NAME_FUNC_OFFSET(17099, glProgramEnvParameter4fARB, glProgramEnvParameter4fARB, NULL, _gloffset_ProgramEnvParameter4fARB),
+    NAME_FUNC_OFFSET(17122, glProgramEnvParameter4fvARB, glProgramEnvParameter4fvARB, NULL, _gloffset_ProgramEnvParameter4fvARB),
+    NAME_FUNC_OFFSET(17146, glVertexAttrib1dARB, glVertexAttrib1dARB, NULL, _gloffset_VertexAttrib1dARB),
+    NAME_FUNC_OFFSET(17163, glVertexAttrib1dvARB, glVertexAttrib1dvARB, NULL, _gloffset_VertexAttrib1dvARB),
+    NAME_FUNC_OFFSET(17181, glVertexAttrib1fARB, glVertexAttrib1fARB, NULL, _gloffset_VertexAttrib1fARB),
+    NAME_FUNC_OFFSET(17198, glVertexAttrib1fvARB, glVertexAttrib1fvARB, NULL, _gloffset_VertexAttrib1fvARB),
+    NAME_FUNC_OFFSET(17216, glVertexAttrib1sARB, glVertexAttrib1sARB, NULL, _gloffset_VertexAttrib1sARB),
+    NAME_FUNC_OFFSET(17233, glVertexAttrib1svARB, glVertexAttrib1svARB, NULL, _gloffset_VertexAttrib1svARB),
+    NAME_FUNC_OFFSET(17251, glVertexAttrib2dARB, glVertexAttrib2dARB, NULL, _gloffset_VertexAttrib2dARB),
+    NAME_FUNC_OFFSET(17268, glVertexAttrib2dvARB, glVertexAttrib2dvARB, NULL, _gloffset_VertexAttrib2dvARB),
+    NAME_FUNC_OFFSET(17286, glVertexAttrib2fARB, glVertexAttrib2fARB, NULL, _gloffset_VertexAttrib2fARB),
+    NAME_FUNC_OFFSET(17303, glVertexAttrib2fvARB, glVertexAttrib2fvARB, NULL, _gloffset_VertexAttrib2fvARB),
+    NAME_FUNC_OFFSET(17321, glVertexAttrib2sARB, glVertexAttrib2sARB, NULL, _gloffset_VertexAttrib2sARB),
+    NAME_FUNC_OFFSET(17338, glVertexAttrib2svARB, glVertexAttrib2svARB, NULL, _gloffset_VertexAttrib2svARB),
+    NAME_FUNC_OFFSET(17356, glVertexAttrib3dARB, glVertexAttrib3dARB, NULL, _gloffset_VertexAttrib3dARB),
+    NAME_FUNC_OFFSET(17373, glVertexAttrib3dvARB, glVertexAttrib3dvARB, NULL, _gloffset_VertexAttrib3dvARB),
+    NAME_FUNC_OFFSET(17391, glVertexAttrib3fARB, glVertexAttrib3fARB, NULL, _gloffset_VertexAttrib3fARB),
+    NAME_FUNC_OFFSET(17408, glVertexAttrib3fvARB, glVertexAttrib3fvARB, NULL, _gloffset_VertexAttrib3fvARB),
+    NAME_FUNC_OFFSET(17426, glVertexAttrib3sARB, glVertexAttrib3sARB, NULL, _gloffset_VertexAttrib3sARB),
+    NAME_FUNC_OFFSET(17443, glVertexAttrib3svARB, glVertexAttrib3svARB, NULL, _gloffset_VertexAttrib3svARB),
+    NAME_FUNC_OFFSET(17461, glVertexAttrib4NbvARB, glVertexAttrib4NbvARB, NULL, _gloffset_VertexAttrib4NbvARB),
+    NAME_FUNC_OFFSET(17480, glVertexAttrib4NivARB, glVertexAttrib4NivARB, NULL, _gloffset_VertexAttrib4NivARB),
+    NAME_FUNC_OFFSET(17499, glVertexAttrib4NsvARB, glVertexAttrib4NsvARB, NULL, _gloffset_VertexAttrib4NsvARB),
+    NAME_FUNC_OFFSET(17518, glVertexAttrib4NubARB, glVertexAttrib4NubARB, NULL, _gloffset_VertexAttrib4NubARB),
+    NAME_FUNC_OFFSET(17537, glVertexAttrib4NubvARB, glVertexAttrib4NubvARB, NULL, _gloffset_VertexAttrib4NubvARB),
+    NAME_FUNC_OFFSET(17557, glVertexAttrib4NuivARB, glVertexAttrib4NuivARB, NULL, _gloffset_VertexAttrib4NuivARB),
+    NAME_FUNC_OFFSET(17577, glVertexAttrib4NusvARB, glVertexAttrib4NusvARB, NULL, _gloffset_VertexAttrib4NusvARB),
+    NAME_FUNC_OFFSET(17597, glVertexAttrib4bvARB, glVertexAttrib4bvARB, NULL, _gloffset_VertexAttrib4bvARB),
+    NAME_FUNC_OFFSET(17615, glVertexAttrib4dARB, glVertexAttrib4dARB, NULL, _gloffset_VertexAttrib4dARB),
+    NAME_FUNC_OFFSET(17632, glVertexAttrib4dvARB, glVertexAttrib4dvARB, NULL, _gloffset_VertexAttrib4dvARB),
+    NAME_FUNC_OFFSET(17650, glVertexAttrib4fARB, glVertexAttrib4fARB, NULL, _gloffset_VertexAttrib4fARB),
+    NAME_FUNC_OFFSET(17667, glVertexAttrib4fvARB, glVertexAttrib4fvARB, NULL, _gloffset_VertexAttrib4fvARB),
+    NAME_FUNC_OFFSET(17685, glVertexAttrib4ivARB, glVertexAttrib4ivARB, NULL, _gloffset_VertexAttrib4ivARB),
+    NAME_FUNC_OFFSET(17703, glVertexAttrib4sARB, glVertexAttrib4sARB, NULL, _gloffset_VertexAttrib4sARB),
+    NAME_FUNC_OFFSET(17720, glVertexAttrib4svARB, glVertexAttrib4svARB, NULL, _gloffset_VertexAttrib4svARB),
+    NAME_FUNC_OFFSET(17738, glVertexAttrib4ubvARB, glVertexAttrib4ubvARB, NULL, _gloffset_VertexAttrib4ubvARB),
+    NAME_FUNC_OFFSET(17757, glVertexAttrib4uivARB, glVertexAttrib4uivARB, NULL, _gloffset_VertexAttrib4uivARB),
+    NAME_FUNC_OFFSET(17776, glVertexAttrib4usvARB, glVertexAttrib4usvARB, NULL, _gloffset_VertexAttrib4usvARB),
+    NAME_FUNC_OFFSET(17795, glVertexAttribPointerARB, glVertexAttribPointerARB, NULL, _gloffset_VertexAttribPointerARB),
+    NAME_FUNC_OFFSET(17817, glBindBufferARB, glBindBufferARB, NULL, _gloffset_BindBufferARB),
+    NAME_FUNC_OFFSET(17830, glBufferDataARB, glBufferDataARB, NULL, _gloffset_BufferDataARB),
+    NAME_FUNC_OFFSET(17843, glBufferSubDataARB, glBufferSubDataARB, NULL, _gloffset_BufferSubDataARB),
+    NAME_FUNC_OFFSET(17859, glDeleteBuffersARB, glDeleteBuffersARB, NULL, _gloffset_DeleteBuffersARB),
+    NAME_FUNC_OFFSET(17875, glGenBuffersARB, glGenBuffersARB, NULL, _gloffset_GenBuffersARB),
+    NAME_FUNC_OFFSET(17888, glGetBufferParameterivARB, glGetBufferParameterivARB, NULL, _gloffset_GetBufferParameterivARB),
+    NAME_FUNC_OFFSET(17911, glGetBufferPointervARB, glGetBufferPointervARB, NULL, _gloffset_GetBufferPointervARB),
+    NAME_FUNC_OFFSET(17931, glGetBufferSubDataARB, glGetBufferSubDataARB, NULL, _gloffset_GetBufferSubDataARB),
+    NAME_FUNC_OFFSET(17950, glIsBufferARB, glIsBufferARB, NULL, _gloffset_IsBufferARB),
+    NAME_FUNC_OFFSET(17961, glMapBufferARB, glMapBufferARB, NULL, _gloffset_MapBufferARB),
+    NAME_FUNC_OFFSET(17973, glUnmapBufferARB, glUnmapBufferARB, NULL, _gloffset_UnmapBufferARB),
+    NAME_FUNC_OFFSET(17987, glBeginQueryARB, glBeginQueryARB, NULL, _gloffset_BeginQueryARB),
+    NAME_FUNC_OFFSET(18000, glDeleteQueriesARB, glDeleteQueriesARB, NULL, _gloffset_DeleteQueriesARB),
+    NAME_FUNC_OFFSET(18016, glEndQueryARB, glEndQueryARB, NULL, _gloffset_EndQueryARB),
+    NAME_FUNC_OFFSET(18027, glGenQueriesARB, glGenQueriesARB, NULL, _gloffset_GenQueriesARB),
+    NAME_FUNC_OFFSET(18040, glGetQueryObjectivARB, glGetQueryObjectivARB, NULL, _gloffset_GetQueryObjectivARB),
+    NAME_FUNC_OFFSET(18059, glGetQueryObjectuivARB, glGetQueryObjectuivARB, NULL, _gloffset_GetQueryObjectuivARB),
+    NAME_FUNC_OFFSET(18079, glGetQueryivARB, glGetQueryivARB, NULL, _gloffset_GetQueryivARB),
+    NAME_FUNC_OFFSET(18092, glIsQueryARB, glIsQueryARB, NULL, _gloffset_IsQueryARB),
+    NAME_FUNC_OFFSET(18102, glCompileShaderARB, glCompileShaderARB, NULL, _gloffset_CompileShaderARB),
+    NAME_FUNC_OFFSET(18118, glGetActiveUniformARB, glGetActiveUniformARB, NULL, _gloffset_GetActiveUniformARB),
+    NAME_FUNC_OFFSET(18137, glGetShaderSourceARB, glGetShaderSourceARB, NULL, _gloffset_GetShaderSourceARB),
+    NAME_FUNC_OFFSET(18155, glGetUniformLocationARB, glGetUniformLocationARB, NULL, _gloffset_GetUniformLocationARB),
+    NAME_FUNC_OFFSET(18176, glGetUniformfvARB, glGetUniformfvARB, NULL, _gloffset_GetUniformfvARB),
+    NAME_FUNC_OFFSET(18191, glGetUniformivARB, glGetUniformivARB, NULL, _gloffset_GetUniformivARB),
+    NAME_FUNC_OFFSET(18206, glLinkProgramARB, glLinkProgramARB, NULL, _gloffset_LinkProgramARB),
+    NAME_FUNC_OFFSET(18220, glShaderSourceARB, glShaderSourceARB, NULL, _gloffset_ShaderSourceARB),
+    NAME_FUNC_OFFSET(18235, glUniform1fARB, glUniform1fARB, NULL, _gloffset_Uniform1fARB),
+    NAME_FUNC_OFFSET(18247, glUniform1fvARB, glUniform1fvARB, NULL, _gloffset_Uniform1fvARB),
+    NAME_FUNC_OFFSET(18260, glUniform1iARB, glUniform1iARB, NULL, _gloffset_Uniform1iARB),
+    NAME_FUNC_OFFSET(18272, glUniform1ivARB, glUniform1ivARB, NULL, _gloffset_Uniform1ivARB),
+    NAME_FUNC_OFFSET(18285, glUniform2fARB, glUniform2fARB, NULL, _gloffset_Uniform2fARB),
+    NAME_FUNC_OFFSET(18297, glUniform2fvARB, glUniform2fvARB, NULL, _gloffset_Uniform2fvARB),
+    NAME_FUNC_OFFSET(18310, glUniform2iARB, glUniform2iARB, NULL, _gloffset_Uniform2iARB),
+    NAME_FUNC_OFFSET(18322, glUniform2ivARB, glUniform2ivARB, NULL, _gloffset_Uniform2ivARB),
+    NAME_FUNC_OFFSET(18335, glUniform3fARB, glUniform3fARB, NULL, _gloffset_Uniform3fARB),
+    NAME_FUNC_OFFSET(18347, glUniform3fvARB, glUniform3fvARB, NULL, _gloffset_Uniform3fvARB),
+    NAME_FUNC_OFFSET(18360, glUniform3iARB, glUniform3iARB, NULL, _gloffset_Uniform3iARB),
+    NAME_FUNC_OFFSET(18372, glUniform3ivARB, glUniform3ivARB, NULL, _gloffset_Uniform3ivARB),
+    NAME_FUNC_OFFSET(18385, glUniform4fARB, glUniform4fARB, NULL, _gloffset_Uniform4fARB),
+    NAME_FUNC_OFFSET(18397, glUniform4fvARB, glUniform4fvARB, NULL, _gloffset_Uniform4fvARB),
+    NAME_FUNC_OFFSET(18410, glUniform4iARB, glUniform4iARB, NULL, _gloffset_Uniform4iARB),
+    NAME_FUNC_OFFSET(18422, glUniform4ivARB, glUniform4ivARB, NULL, _gloffset_Uniform4ivARB),
+    NAME_FUNC_OFFSET(18435, glUniformMatrix2fvARB, glUniformMatrix2fvARB, NULL, _gloffset_UniformMatrix2fvARB),
+    NAME_FUNC_OFFSET(18454, glUniformMatrix3fvARB, glUniformMatrix3fvARB, NULL, _gloffset_UniformMatrix3fvARB),
+    NAME_FUNC_OFFSET(18473, glUniformMatrix4fvARB, glUniformMatrix4fvARB, NULL, _gloffset_UniformMatrix4fvARB),
+    NAME_FUNC_OFFSET(18492, glUseProgramObjectARB, glUseProgramObjectARB, NULL, _gloffset_UseProgramObjectARB),
+    NAME_FUNC_OFFSET(18505, glValidateProgramARB, glValidateProgramARB, NULL, _gloffset_ValidateProgramARB),
+    NAME_FUNC_OFFSET(18523, glBindAttribLocationARB, glBindAttribLocationARB, NULL, _gloffset_BindAttribLocationARB),
+    NAME_FUNC_OFFSET(18544, glGetActiveAttribARB, glGetActiveAttribARB, NULL, _gloffset_GetActiveAttribARB),
+    NAME_FUNC_OFFSET(18562, glGetAttribLocationARB, glGetAttribLocationARB, NULL, _gloffset_GetAttribLocationARB),
+    NAME_FUNC_OFFSET(18582, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
+    NAME_FUNC_OFFSET(18596, glDrawBuffersARB, glDrawBuffersARB, NULL, _gloffset_DrawBuffersARB),
+    NAME_FUNC_OFFSET(18613, glRenderbufferStorageMultisample, glRenderbufferStorageMultisample, NULL, _gloffset_RenderbufferStorageMultisample),
+    NAME_FUNC_OFFSET(18649, gl_dispatch_stub_586, gl_dispatch_stub_586, NULL, _gloffset_SampleMaskSGIS),
+    NAME_FUNC_OFFSET(18665, gl_dispatch_stub_587, gl_dispatch_stub_587, NULL, _gloffset_SamplePatternSGIS),
+    NAME_FUNC_OFFSET(18684, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+    NAME_FUNC_OFFSET(18702, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+    NAME_FUNC_OFFSET(18723, glPointParameterfEXT, glPointParameterfEXT, NULL, _gloffset_PointParameterfEXT),
+    NAME_FUNC_OFFSET(18745, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+    NAME_FUNC_OFFSET(18764, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+    NAME_FUNC_OFFSET(18786, glPointParameterfvEXT, glPointParameterfvEXT, NULL, _gloffset_PointParameterfvEXT),
+    NAME_FUNC_OFFSET(18809, glSecondaryColor3bEXT, glSecondaryColor3bEXT, NULL, _gloffset_SecondaryColor3bEXT),
+    NAME_FUNC_OFFSET(18828, glSecondaryColor3bvEXT, glSecondaryColor3bvEXT, NULL, _gloffset_SecondaryColor3bvEXT),
+    NAME_FUNC_OFFSET(18848, glSecondaryColor3dEXT, glSecondaryColor3dEXT, NULL, _gloffset_SecondaryColor3dEXT),
+    NAME_FUNC_OFFSET(18867, glSecondaryColor3dvEXT, glSecondaryColor3dvEXT, NULL, _gloffset_SecondaryColor3dvEXT),
+    NAME_FUNC_OFFSET(18887, glSecondaryColor3fEXT, glSecondaryColor3fEXT, NULL, _gloffset_SecondaryColor3fEXT),
+    NAME_FUNC_OFFSET(18906, glSecondaryColor3fvEXT, glSecondaryColor3fvEXT, NULL, _gloffset_SecondaryColor3fvEXT),
+    NAME_FUNC_OFFSET(18926, glSecondaryColor3iEXT, glSecondaryColor3iEXT, NULL, _gloffset_SecondaryColor3iEXT),
+    NAME_FUNC_OFFSET(18945, glSecondaryColor3ivEXT, glSecondaryColor3ivEXT, NULL, _gloffset_SecondaryColor3ivEXT),
+    NAME_FUNC_OFFSET(18965, glSecondaryColor3sEXT, glSecondaryColor3sEXT, NULL, _gloffset_SecondaryColor3sEXT),
+    NAME_FUNC_OFFSET(18984, glSecondaryColor3svEXT, glSecondaryColor3svEXT, NULL, _gloffset_SecondaryColor3svEXT),
+    NAME_FUNC_OFFSET(19004, glSecondaryColor3ubEXT, glSecondaryColor3ubEXT, NULL, _gloffset_SecondaryColor3ubEXT),
+    NAME_FUNC_OFFSET(19024, glSecondaryColor3ubvEXT, glSecondaryColor3ubvEXT, NULL, _gloffset_SecondaryColor3ubvEXT),
+    NAME_FUNC_OFFSET(19045, glSecondaryColor3uiEXT, glSecondaryColor3uiEXT, NULL, _gloffset_SecondaryColor3uiEXT),
+    NAME_FUNC_OFFSET(19065, glSecondaryColor3uivEXT, glSecondaryColor3uivEXT, NULL, _gloffset_SecondaryColor3uivEXT),
+    NAME_FUNC_OFFSET(19086, glSecondaryColor3usEXT, glSecondaryColor3usEXT, NULL, _gloffset_SecondaryColor3usEXT),
+    NAME_FUNC_OFFSET(19106, glSecondaryColor3usvEXT, glSecondaryColor3usvEXT, NULL, _gloffset_SecondaryColor3usvEXT),
+    NAME_FUNC_OFFSET(19127, glSecondaryColorPointerEXT, glSecondaryColorPointerEXT, NULL, _gloffset_SecondaryColorPointerEXT),
+    NAME_FUNC_OFFSET(19151, glMultiDrawArraysEXT, glMultiDrawArraysEXT, NULL, _gloffset_MultiDrawArraysEXT),
+    NAME_FUNC_OFFSET(19169, glMultiDrawElementsEXT, glMultiDrawElementsEXT, NULL, _gloffset_MultiDrawElementsEXT),
+    NAME_FUNC_OFFSET(19189, glFogCoordPointerEXT, glFogCoordPointerEXT, NULL, _gloffset_FogCoordPointerEXT),
+    NAME_FUNC_OFFSET(19207, glFogCoorddEXT, glFogCoorddEXT, NULL, _gloffset_FogCoorddEXT),
+    NAME_FUNC_OFFSET(19219, glFogCoorddvEXT, glFogCoorddvEXT, NULL, _gloffset_FogCoorddvEXT),
+    NAME_FUNC_OFFSET(19232, glFogCoordfEXT, glFogCoordfEXT, NULL, _gloffset_FogCoordfEXT),
+    NAME_FUNC_OFFSET(19244, glFogCoordfvEXT, glFogCoordfvEXT, NULL, _gloffset_FogCoordfvEXT),
+    NAME_FUNC_OFFSET(19257, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
+    NAME_FUNC_OFFSET(19277, glBlendFuncSeparateEXT, glBlendFuncSeparateEXT, NULL, _gloffset_BlendFuncSeparateEXT),
+    NAME_FUNC_OFFSET(19301, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
+    NAME_FUNC_OFFSET(19315, glWindowPos2dMESA, glWindowPos2dMESA, NULL, _gloffset_WindowPos2dMESA),
+    NAME_FUNC_OFFSET(19332, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
+    NAME_FUNC_OFFSET(19347, glWindowPos2dvMESA, glWindowPos2dvMESA, NULL, _gloffset_WindowPos2dvMESA),
+    NAME_FUNC_OFFSET(19365, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
+    NAME_FUNC_OFFSET(19379, glWindowPos2fMESA, glWindowPos2fMESA, NULL, _gloffset_WindowPos2fMESA),
+    NAME_FUNC_OFFSET(19396, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
+    NAME_FUNC_OFFSET(19411, glWindowPos2fvMESA, glWindowPos2fvMESA, NULL, _gloffset_WindowPos2fvMESA),
+    NAME_FUNC_OFFSET(19429, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
+    NAME_FUNC_OFFSET(19443, glWindowPos2iMESA, glWindowPos2iMESA, NULL, _gloffset_WindowPos2iMESA),
+    NAME_FUNC_OFFSET(19460, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
+    NAME_FUNC_OFFSET(19475, glWindowPos2ivMESA, glWindowPos2ivMESA, NULL, _gloffset_WindowPos2ivMESA),
+    NAME_FUNC_OFFSET(19493, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
+    NAME_FUNC_OFFSET(19507, glWindowPos2sMESA, glWindowPos2sMESA, NULL, _gloffset_WindowPos2sMESA),
+    NAME_FUNC_OFFSET(19524, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
+    NAME_FUNC_OFFSET(19539, glWindowPos2svMESA, glWindowPos2svMESA, NULL, _gloffset_WindowPos2svMESA),
+    NAME_FUNC_OFFSET(19557, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
+    NAME_FUNC_OFFSET(19571, glWindowPos3dMESA, glWindowPos3dMESA, NULL, _gloffset_WindowPos3dMESA),
+    NAME_FUNC_OFFSET(19588, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
+    NAME_FUNC_OFFSET(19603, glWindowPos3dvMESA, glWindowPos3dvMESA, NULL, _gloffset_WindowPos3dvMESA),
+    NAME_FUNC_OFFSET(19621, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
+    NAME_FUNC_OFFSET(19635, glWindowPos3fMESA, glWindowPos3fMESA, NULL, _gloffset_WindowPos3fMESA),
+    NAME_FUNC_OFFSET(19652, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
+    NAME_FUNC_OFFSET(19667, glWindowPos3fvMESA, glWindowPos3fvMESA, NULL, _gloffset_WindowPos3fvMESA),
+    NAME_FUNC_OFFSET(19685, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
+    NAME_FUNC_OFFSET(19699, glWindowPos3iMESA, glWindowPos3iMESA, NULL, _gloffset_WindowPos3iMESA),
+    NAME_FUNC_OFFSET(19716, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
+    NAME_FUNC_OFFSET(19731, glWindowPos3ivMESA, glWindowPos3ivMESA, NULL, _gloffset_WindowPos3ivMESA),
+    NAME_FUNC_OFFSET(19749, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
+    NAME_FUNC_OFFSET(19763, glWindowPos3sMESA, glWindowPos3sMESA, NULL, _gloffset_WindowPos3sMESA),
+    NAME_FUNC_OFFSET(19780, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
+    NAME_FUNC_OFFSET(19795, glWindowPos3svMESA, glWindowPos3svMESA, NULL, _gloffset_WindowPos3svMESA),
+    NAME_FUNC_OFFSET(19813, glBindProgramNV, glBindProgramNV, NULL, _gloffset_BindProgramNV),
+    NAME_FUNC_OFFSET(19830, glDeleteProgramsNV, glDeleteProgramsNV, NULL, _gloffset_DeleteProgramsNV),
+    NAME_FUNC_OFFSET(19850, glGenProgramsNV, glGenProgramsNV, NULL, _gloffset_GenProgramsNV),
+    NAME_FUNC_OFFSET(19867, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
+    NAME_FUNC_OFFSET(19893, glGetVertexAttribPointervNV, glGetVertexAttribPointervNV, NULL, _gloffset_GetVertexAttribPointervNV),
+    NAME_FUNC_OFFSET(19922, glIsProgramNV, glIsProgramNV, NULL, _gloffset_IsProgramNV),
+    NAME_FUNC_OFFSET(19937, glPointParameteriNV, glPointParameteriNV, NULL, _gloffset_PointParameteriNV),
+    NAME_FUNC_OFFSET(19955, glPointParameterivNV, glPointParameterivNV, NULL, _gloffset_PointParameterivNV),
+    NAME_FUNC_OFFSET(19974, gl_dispatch_stub_757, gl_dispatch_stub_757, NULL, _gloffset_DeleteVertexArraysAPPLE),
+    NAME_FUNC_OFFSET(19995, gl_dispatch_stub_759, gl_dispatch_stub_759, NULL, _gloffset_IsVertexArrayAPPLE),
+    NAME_FUNC_OFFSET(20011, gl_dispatch_stub_767, gl_dispatch_stub_767, NULL, _gloffset_BlendEquationSeparateEXT),
+    NAME_FUNC_OFFSET(20035, gl_dispatch_stub_767, gl_dispatch_stub_767, NULL, _gloffset_BlendEquationSeparateEXT),
+    NAME_FUNC_OFFSET(20062, glBindFramebufferEXT, glBindFramebufferEXT, NULL, _gloffset_BindFramebufferEXT),
+    NAME_FUNC_OFFSET(20080, glBindRenderbufferEXT, glBindRenderbufferEXT, NULL, _gloffset_BindRenderbufferEXT),
+    NAME_FUNC_OFFSET(20099, glCheckFramebufferStatusEXT, glCheckFramebufferStatusEXT, NULL, _gloffset_CheckFramebufferStatusEXT),
+    NAME_FUNC_OFFSET(20124, glDeleteFramebuffersEXT, glDeleteFramebuffersEXT, NULL, _gloffset_DeleteFramebuffersEXT),
+    NAME_FUNC_OFFSET(20145, glDeleteRenderbuffersEXT, glDeleteRenderbuffersEXT, NULL, _gloffset_DeleteRenderbuffersEXT),
+    NAME_FUNC_OFFSET(20167, glFramebufferRenderbufferEXT, glFramebufferRenderbufferEXT, NULL, _gloffset_FramebufferRenderbufferEXT),
+    NAME_FUNC_OFFSET(20193, glFramebufferTexture1DEXT, glFramebufferTexture1DEXT, NULL, _gloffset_FramebufferTexture1DEXT),
+    NAME_FUNC_OFFSET(20216, glFramebufferTexture2DEXT, glFramebufferTexture2DEXT, NULL, _gloffset_FramebufferTexture2DEXT),
+    NAME_FUNC_OFFSET(20239, glFramebufferTexture3DEXT, glFramebufferTexture3DEXT, NULL, _gloffset_FramebufferTexture3DEXT),
+    NAME_FUNC_OFFSET(20262, glGenFramebuffersEXT, glGenFramebuffersEXT, NULL, _gloffset_GenFramebuffersEXT),
+    NAME_FUNC_OFFSET(20280, glGenRenderbuffersEXT, glGenRenderbuffersEXT, NULL, _gloffset_GenRenderbuffersEXT),
+    NAME_FUNC_OFFSET(20299, glGenerateMipmapEXT, glGenerateMipmapEXT, NULL, _gloffset_GenerateMipmapEXT),
+    NAME_FUNC_OFFSET(20316, glGetFramebufferAttachmentParameterivEXT, glGetFramebufferAttachmentParameterivEXT, NULL, _gloffset_GetFramebufferAttachmentParameterivEXT),
+    NAME_FUNC_OFFSET(20354, glGetRenderbufferParameterivEXT, glGetRenderbufferParameterivEXT, NULL, _gloffset_GetRenderbufferParameterivEXT),
+    NAME_FUNC_OFFSET(20383, glIsFramebufferEXT, glIsFramebufferEXT, NULL, _gloffset_IsFramebufferEXT),
+    NAME_FUNC_OFFSET(20399, glIsRenderbufferEXT, glIsRenderbufferEXT, NULL, _gloffset_IsRenderbufferEXT),
+    NAME_FUNC_OFFSET(20416, glRenderbufferStorageEXT, glRenderbufferStorageEXT, NULL, _gloffset_RenderbufferStorageEXT),
+    NAME_FUNC_OFFSET(20438, gl_dispatch_stub_785, gl_dispatch_stub_785, NULL, _gloffset_BlitFramebufferEXT),
+    NAME_FUNC_OFFSET(20456, glFramebufferTextureLayerEXT, glFramebufferTextureLayerEXT, NULL, _gloffset_FramebufferTextureLayerEXT),
+    NAME_FUNC_OFFSET(20482, glBeginTransformFeedbackEXT, glBeginTransformFeedbackEXT, NULL, _gloffset_BeginTransformFeedbackEXT),
+    NAME_FUNC_OFFSET(20507, glBindBufferBaseEXT, glBindBufferBaseEXT, NULL, _gloffset_BindBufferBaseEXT),
+    NAME_FUNC_OFFSET(20524, glBindBufferRangeEXT, glBindBufferRangeEXT, NULL, _gloffset_BindBufferRangeEXT),
+    NAME_FUNC_OFFSET(20542, glEndTransformFeedbackEXT, glEndTransformFeedbackEXT, NULL, _gloffset_EndTransformFeedbackEXT),
+    NAME_FUNC_OFFSET(20565, glGetTransformFeedbackVaryingEXT, glGetTransformFeedbackVaryingEXT, NULL, _gloffset_GetTransformFeedbackVaryingEXT),
+    NAME_FUNC_OFFSET(20595, glTransformFeedbackVaryingsEXT, glTransformFeedbackVaryingsEXT, NULL, _gloffset_TransformFeedbackVaryingsEXT),
+    NAME_FUNC_OFFSET(20623, glProvokingVertexEXT, glProvokingVertexEXT, NULL, _gloffset_ProvokingVertexEXT),
     NAME_FUNC_OFFSET(-1, NULL, NULL, NULL, 0)
 };
 
diff --git a/src/mesa/main/api_exec.c b/src/mesa/main/api_exec.c
index fa8d409caa8..1e1aa416118 100644
--- a/src/mesa/main/api_exec.c
+++ b/src/mesa/main/api_exec.c
@@ -89,6 +89,7 @@
 #include "texobj.h"
 #include "texparam.h"
 #include "texstate.h"
+#include "transformfeedback.h"
 #include "mtypes.h"
 #include "varray.h"
 #include "viewport.h"
@@ -477,6 +478,18 @@ _mesa_init_exec_table(struct _glapi_table *exec)
    /* ???. GL_EXT_depth_bounds_test */
    SET_DepthBoundsEXT(exec, _mesa_DepthBoundsEXT);
 
+   /* 352. GL_EXT_transform_feedback */
+#if _HAVE_FULL_GL
+   SET_BeginTransformFeedbackEXT(exec, _mesa_BeginTransformFeedback);
+   SET_EndTransformFeedbackEXT(exec, _mesa_EndTransformFeedback);
+   SET_BindBufferRangeEXT(exec, _mesa_BindBufferRange);
+   SET_BindBufferBaseEXT(exec, _mesa_BindBufferBase);
+   SET_BindBufferOffsetEXT(exec, _mesa_BindBufferOffsetEXT);
+   SET_TransformFeedbackVaryingsEXT(exec, _mesa_TransformFeedbackVaryings);
+   SET_GetTransformFeedbackVaryingEXT(exec, _mesa_GetTransformFeedbackVarying);
+#endif
+
+   /* 364. GL_EXT_provoking_vertex */
    SET_ProvokingVertexEXT(exec, _mesa_ProvokingVertexEXT);
 
    /* ARB 1. GL_ARB_multitexture */
diff --git a/src/mesa/main/api_validate.c b/src/mesa/main/api_validate.c
index 4fb7b5ad61f..f6da86d2961 100644
--- a/src/mesa/main/api_validate.c
+++ b/src/mesa/main/api_validate.c
@@ -175,7 +175,7 @@ _mesa_validate_DrawElements(GLcontext *ctx,
 			    GLenum mode, GLsizei count, GLenum type,
 			    const GLvoid *indices, GLint basevertex)
 {
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx,  GL_FALSE);
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 
    if (count <= 0) {
       if (count < 0)
@@ -314,3 +314,108 @@ _mesa_validate_DrawArrays(GLcontext *ctx,
 
    return GL_TRUE;
 }
+
+
+GLboolean
+_mesa_validate_DrawArraysInstanced(GLcontext *ctx, GLenum mode, GLint first,
+                                   GLsizei count, GLsizei primcount)
+{
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
+
+   if (count <= 0) {
+      if (count < 0)
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glDrawArraysInstanced(count=%d)", count);
+      return GL_FALSE;
+   }
+
+   if (mode > GL_POLYGON) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glDrawArraysInstanced(mode=0x%x)", mode);
+      return GL_FALSE;
+   }
+
+   if (primcount <= 0) {
+      if (primcount < 0)
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glDrawArraysInstanced(primcount=%d)", primcount);
+      return GL_FALSE;
+   }
+
+   if (!check_valid_to_render(ctx, "glDrawArraysInstanced(invalid to render)"))
+      return GL_FALSE;
+
+   if (ctx->CompileFlag) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glDrawArraysInstanced(display list");
+      return GL_FALSE;
+   }
+
+   if (ctx->Const.CheckArrayBounds) {
+      if (first + count > (GLint) ctx->Array.ArrayObj->_MaxElement)
+         return GL_FALSE;
+   }
+
+   return GL_TRUE;
+}
+
+
+GLboolean
+_mesa_validate_DrawElementsInstanced(GLcontext *ctx,
+                                     GLenum mode, GLsizei count, GLenum type,
+                                     const GLvoid *indices, GLsizei primcount)
+{
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
+
+   if (count <= 0) {
+      if (count < 0)
+	 _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glDrawElementsInstanced(count=%d)", count);
+      return GL_FALSE;
+   }
+
+   if (mode > GL_POLYGON) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glDrawElementsInstanced(mode = 0x%x)", mode);
+      return GL_FALSE;
+   }
+
+   if (type != GL_UNSIGNED_INT &&
+       type != GL_UNSIGNED_BYTE &&
+       type != GL_UNSIGNED_SHORT) {
+      _mesa_error(ctx, GL_INVALID_ENUM,
+                  "glDrawElementsInstanced(type=0x%x)", type);
+      return GL_FALSE;
+   }
+
+   if (primcount <= 0) {
+      if (primcount < 0)
+         _mesa_error(ctx, GL_INVALID_VALUE,
+                     "glDrawElementsInstanced(primcount=%d)", primcount);
+      return GL_FALSE;
+   }
+
+   if (!check_valid_to_render(ctx, "glDrawElementsInstanced"))
+      return GL_FALSE;
+
+   /* Vertex buffer object tests */
+   if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {
+      /* use indices in the buffer object */
+      /* make sure count doesn't go outside buffer bounds */
+      if (index_bytes(type, count) > ctx->Array.ElementArrayBufferObj->Size) {
+         _mesa_warning(ctx,
+                       "glDrawElementsInstanced index out of buffer bounds");
+         return GL_FALSE;
+      }
+   }
+   else {
+      /* not using a VBO */
+      if (!indices)
+         return GL_FALSE;
+   }
+
+   if (!check_index_bounds(ctx, count, type, indices, 0))
+      return GL_FALSE;
+
+   return GL_TRUE;
+}
diff --git a/src/mesa/main/api_validate.h b/src/mesa/main/api_validate.h
index 6064d15fe6c..cd27d58aa7d 100644
--- a/src/mesa/main/api_validate.h
+++ b/src/mesa/main/api_validate.h
@@ -52,4 +52,14 @@ _mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode,
 				 const GLvoid *indices, GLint basevertex);
 
 
+extern GLboolean
+_mesa_validate_DrawArraysInstanced(GLcontext *ctx, GLenum mode, GLint first,
+                                   GLsizei count, GLsizei primcount);
+
+extern GLboolean
+_mesa_validate_DrawElementsInstanced(GLcontext *ctx,
+                                     GLenum mode, GLsizei count, GLenum type,
+                                     const GLvoid *indices, GLsizei primcount);
+
+
 #endif
diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h
index 7c02faaa535..4679be72f76 100644
--- a/src/mesa/main/dd.h
+++ b/src/mesa/main/dd.h
@@ -1186,6 +1186,11 @@ typedef struct {
 						   const GLvoid **indices,
 						   GLsizei primcount,
 						   const GLint *basevertex);
+   void (GLAPIENTRYP DrawArraysInstanced)(GLenum mode, GLint first,
+                                          GLsizei count, GLsizei primcount);
+   void (GLAPIENTRYP DrawElementsInstanced)(GLenum mode, GLsizei count,
+                                            GLenum type, const GLvoid *indices,
+                                            GLsizei primcount);
    /*@}*/
 
    /**
diff --git a/src/mesa/main/dlist.c b/src/mesa/main/dlist.c
index 43aadb1de57..f869a585d6b 100644
--- a/src/mesa/main/dlist.c
+++ b/src/mesa/main/dlist.c
@@ -396,6 +396,10 @@ typedef enum
    /* GL_EXT_provoking_vertex */
    OPCODE_PROVOKING_VERTEX,
 
+   /* GL_EXT_transform_feedback */
+   OPCODE_BEGIN_TRANSFORM_FEEDBACK,
+   OPCODE_END_TRANSFORM_FEEDBACK,
+
    /* The following three are meta instructions */
    OPCODE_ERROR,                /* raise compiled-in error */
    OPCODE_CONTINUE,
@@ -6104,6 +6108,36 @@ save_ProvokingVertexEXT(GLenum mode)
 }
 
 
+/** GL_EXT_transform_feedback */
+static void GLAPIENTRY
+save_BeginTransformFeedback(GLenum mode)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = alloc_instruction(ctx, OPCODE_BEGIN_TRANSFORM_FEEDBACK, 1);
+   if (n) {
+      n[1].e = mode;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_BeginTransformFeedbackEXT(ctx->Exec, (mode));
+   }
+}
+
+
+/** GL_EXT_transform_feedback */
+static void GLAPIENTRY
+save_EndTransformFeedback(void)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   (void) alloc_instruction(ctx, OPCODE_END_TRANSFORM_FEEDBACK, 0);
+   if (ctx->ExecuteFlag) {
+      CALL_EndTransformFeedbackEXT(ctx->Exec, ());
+   }
+}
+
+
 /* aka UseProgram() */
 static void GLAPIENTRY
 save_UseProgramObjectARB(GLhandleARB program)
@@ -7199,6 +7233,12 @@ execute_list(GLcontext *ctx, GLuint list)
          case OPCODE_PROVOKING_VERTEX:
             CALL_ProvokingVertexEXT(ctx->Exec, (n[1].e));
             break;
+         case OPCODE_BEGIN_TRANSFORM_FEEDBACK:
+            CALL_BeginTransformFeedbackEXT(ctx->Exec, (n[1].e));
+            break;
+         case OPCODE_END_TRANSFORM_FEEDBACK:
+            CALL_EndTransformFeedbackEXT(ctx->Exec, ());
+            break;
          case OPCODE_STENCIL_FUNC:
             CALL_StencilFunc(ctx->Exec, (n[1].e, n[2].i, n[3].ui));
             break;
@@ -9267,7 +9307,7 @@ _mesa_init_save_table(struct _glapi_table *table)
    /* 299. GL_EXT_blend_equation_separate */
    SET_BlendEquationSeparateEXT(table, save_BlendEquationSeparateEXT);
 
-   /* GL_EXT_gpu_program_parmaeters */
+   /* GL_EXT_gpu_program_parameters */
 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
    SET_ProgramEnvParameters4fvEXT(table, save_ProgramEnvParameters4fvEXT);
    SET_ProgramLocalParameters4fvEXT(table, save_ProgramLocalParameters4fvEXT);
@@ -9282,6 +9322,12 @@ _mesa_init_save_table(struct _glapi_table *table)
    /* ARB 59. GL_ARB_copy_buffer */
    SET_CopyBufferSubData(table, _mesa_CopyBufferSubData); /* no dlist save */
 
+   /* 352. GL_EXT_transform_feedback */
+#if FEATURE_EXT_transform_feedback
+   SET_BeginTransformFeedbackEXT(table, save_BeginTransformFeedback);
+   SET_EndTransformFeedbackEXT(table, save_EndTransformFeedback);
+#endif
+
    /* 364. GL_EXT_provoking_vertex */
    SET_ProvokingVertexEXT(table, save_ProvokingVertexEXT);
 
diff --git a/src/mesa/main/enums.c b/src/mesa/main/enums.c
index 06d51d4e5cd..45f6a64356a 100644
--- a/src/mesa/main/enums.c
+++ b/src/mesa/main/enums.c
@@ -694,6 +694,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_INTENSITY8\0"
    "GL_INTENSITY8_EXT\0"
    "GL_INTENSITY_EXT\0"
+   "GL_INTERLEAVED_ATTRIBS_EXT\0"
    "GL_INTERPOLATE\0"
    "GL_INTERPOLATE_ARB\0"
    "GL_INTERPOLATE_EXT\0"
@@ -976,6 +977,9 @@ LONGSTRING static const char enum_string_table[] =
    "GL_MAX_TEXTURE_UNITS_ARB\0"
    "GL_MAX_TRACK_MATRICES_NV\0"
    "GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV\0"
+   "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT\0"
+   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT\0"
+   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT\0"
    "GL_MAX_VARYING_FLOATS\0"
    "GL_MAX_VARYING_FLOATS_ARB\0"
    "GL_MAX_VERTEX_ATTRIBS\0"
@@ -1268,6 +1272,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_PRIMARY_COLOR\0"
    "GL_PRIMARY_COLOR_ARB\0"
    "GL_PRIMARY_COLOR_EXT\0"
+   "GL_PRIMITIVES_GENERATED_EXT\0"
    "GL_PROGRAM_ADDRESS_REGISTERS_ARB\0"
    "GL_PROGRAM_ALU_INSTRUCTIONS_ARB\0"
    "GL_PROGRAM_ATTRIBS_ARB\0"
@@ -1341,6 +1346,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_QUERY_WAIT_NV\0"
    "GL_R\0"
    "GL_R3_G3_B2\0"
+   "GL_RASTERIZER_DISCARD_EXT\0"
    "GL_RASTER_POSITION_UNCLIPPED_IBM\0"
    "GL_READ_BUFFER\0"
    "GL_READ_FRAMEBUFFER\0"
@@ -1471,6 +1477,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_SELECTION_BUFFER_POINTER\0"
    "GL_SELECTION_BUFFER_SIZE\0"
    "GL_SEPARABLE_2D\0"
+   "GL_SEPARATE_ATTRIBS_EXT\0"
    "GL_SEPARATE_SPECULAR_COLOR\0"
    "GL_SEPARATE_SPECULAR_COLOR_EXT\0"
    "GL_SET\0"
@@ -1800,6 +1807,14 @@ LONGSTRING static const char enum_string_table[] =
    "GL_TRACK_MATRIX_NV\0"
    "GL_TRACK_MATRIX_TRANSFORM_NV\0"
    "GL_TRANSFORM_BIT\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_VARYINGS_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT\0"
    "GL_TRANSPOSE_COLOR_MATRIX\0"
    "GL_TRANSPOSE_COLOR_MATRIX_ARB\0"
    "GL_TRANSPOSE_CURRENT_MATRIX_ARB\0"
@@ -1929,7 +1944,7 @@ LONGSTRING static const char enum_string_table[] =
    "GL_ZOOM_Y\0"
    ;
 
-static const enum_elt all_enums[1891] =
+static const enum_elt all_enums[1906] =
 {
    {     0, 0x00000600 }, /* GL_2D */
    {     6, 0x00001407 }, /* GL_2_BYTES */
@@ -2589,1318 +2604,1333 @@ static const enum_elt all_enums[1891] =
    { 13839, 0x0000804B }, /* GL_INTENSITY8 */
    { 13853, 0x0000804B }, /* GL_INTENSITY8_EXT */
    { 13871, 0x00008049 }, /* GL_INTENSITY_EXT */
-   { 13888, 0x00008575 }, /* GL_INTERPOLATE */
-   { 13903, 0x00008575 }, /* GL_INTERPOLATE_ARB */
-   { 13922, 0x00008575 }, /* GL_INTERPOLATE_EXT */
-   { 13941, 0x00008B53 }, /* GL_INT_VEC2 */
-   { 13953, 0x00008B53 }, /* GL_INT_VEC2_ARB */
-   { 13969, 0x00008B54 }, /* GL_INT_VEC3 */
-   { 13981, 0x00008B54 }, /* GL_INT_VEC3_ARB */
-   { 13997, 0x00008B55 }, /* GL_INT_VEC4 */
-   { 14009, 0x00008B55 }, /* GL_INT_VEC4_ARB */
-   { 14025, 0x00000500 }, /* GL_INVALID_ENUM */
-   { 14041, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */
-   { 14074, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
-   { 14111, 0x00000502 }, /* GL_INVALID_OPERATION */
-   { 14132, 0x00000501 }, /* GL_INVALID_VALUE */
-   { 14149, 0x0000862B }, /* GL_INVERSE_NV */
-   { 14163, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
-   { 14187, 0x0000150A }, /* GL_INVERT */
-   { 14197, 0x00001E00 }, /* GL_KEEP */
-   { 14205, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION */
-   { 14231, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */
-   { 14261, 0x00000406 }, /* GL_LEFT */
-   { 14269, 0x00000203 }, /* GL_LEQUAL */
-   { 14279, 0x00000201 }, /* GL_LESS */
-   { 14287, 0x00004000 }, /* GL_LIGHT0 */
-   { 14297, 0x00004001 }, /* GL_LIGHT1 */
-   { 14307, 0x00004002 }, /* GL_LIGHT2 */
-   { 14317, 0x00004003 }, /* GL_LIGHT3 */
-   { 14327, 0x00004004 }, /* GL_LIGHT4 */
-   { 14337, 0x00004005 }, /* GL_LIGHT5 */
-   { 14347, 0x00004006 }, /* GL_LIGHT6 */
-   { 14357, 0x00004007 }, /* GL_LIGHT7 */
-   { 14367, 0x00000B50 }, /* GL_LIGHTING */
-   { 14379, 0x00000040 }, /* GL_LIGHTING_BIT */
-   { 14395, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
-   { 14418, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-   { 14447, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
-   { 14480, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-   { 14508, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
-   { 14532, 0x00001B01 }, /* GL_LINE */
-   { 14540, 0x00002601 }, /* GL_LINEAR */
-   { 14550, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
-   { 14572, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-   { 14602, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-   { 14633, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
-   { 14657, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
-   { 14682, 0x00000001 }, /* GL_LINES */
-   { 14691, 0x00000004 }, /* GL_LINE_BIT */
-   { 14703, 0x00000002 }, /* GL_LINE_LOOP */
-   { 14716, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
-   { 14736, 0x00000B20 }, /* GL_LINE_SMOOTH */
-   { 14751, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
-   { 14771, 0x00000B24 }, /* GL_LINE_STIPPLE */
-   { 14787, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
-   { 14811, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
-   { 14834, 0x00000003 }, /* GL_LINE_STRIP */
-   { 14848, 0x00000702 }, /* GL_LINE_TOKEN */
-   { 14862, 0x00000B21 }, /* GL_LINE_WIDTH */
-   { 14876, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
-   { 14902, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
-   { 14922, 0x00008B82 }, /* GL_LINK_STATUS */
-   { 14937, 0x00000B32 }, /* GL_LIST_BASE */
-   { 14950, 0x00020000 }, /* GL_LIST_BIT */
-   { 14962, 0x00000B33 }, /* GL_LIST_INDEX */
-   { 14976, 0x00000B30 }, /* GL_LIST_MODE */
-   { 14989, 0x00000101 }, /* GL_LOAD */
-   { 14997, 0x00000BF1 }, /* GL_LOGIC_OP */
-   { 15009, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
-   { 15026, 0x00008CA1 }, /* GL_LOWER_LEFT */
-   { 15040, 0x00001909 }, /* GL_LUMINANCE */
-   { 15053, 0x00008041 }, /* GL_LUMINANCE12 */
-   { 15068, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
-   { 15091, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
-   { 15118, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
-   { 15140, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
-   { 15166, 0x00008041 }, /* GL_LUMINANCE12_EXT */
-   { 15185, 0x00008042 }, /* GL_LUMINANCE16 */
-   { 15200, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
-   { 15223, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
-   { 15250, 0x00008042 }, /* GL_LUMINANCE16_EXT */
-   { 15269, 0x0000803F }, /* GL_LUMINANCE4 */
-   { 15283, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
-   { 15304, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
-   { 15329, 0x0000803F }, /* GL_LUMINANCE4_EXT */
-   { 15347, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
-   { 15368, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
-   { 15393, 0x00008040 }, /* GL_LUMINANCE8 */
-   { 15407, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
-   { 15428, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
-   { 15453, 0x00008040 }, /* GL_LUMINANCE8_EXT */
-   { 15471, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
-   { 15490, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
-   { 15506, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
-   { 15526, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
-   { 15548, 0x00000D91 }, /* GL_MAP1_INDEX */
-   { 15562, 0x00000D92 }, /* GL_MAP1_NORMAL */
-   { 15577, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
-   { 15601, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
-   { 15625, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
-   { 15649, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
-   { 15673, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
-   { 15690, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
-   { 15707, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-   { 15735, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-   { 15764, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-   { 15793, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-   { 15822, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-   { 15851, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-   { 15880, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-   { 15909, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-   { 15937, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-   { 15965, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-   { 15993, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-   { 16021, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-   { 16049, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-   { 16077, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-   { 16105, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-   { 16133, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-   { 16161, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
-   { 16177, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
-   { 16197, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
-   { 16219, 0x00000DB1 }, /* GL_MAP2_INDEX */
-   { 16233, 0x00000DB2 }, /* GL_MAP2_NORMAL */
-   { 16248, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
-   { 16272, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
-   { 16296, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
-   { 16320, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
-   { 16344, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
-   { 16361, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
-   { 16378, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-   { 16406, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-   { 16435, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-   { 16464, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-   { 16493, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-   { 16522, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-   { 16551, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-   { 16580, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-   { 16608, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-   { 16636, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-   { 16664, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-   { 16692, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-   { 16720, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-   { 16748, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
-   { 16776, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-   { 16804, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-   { 16832, 0x00000D10 }, /* GL_MAP_COLOR */
-   { 16845, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */
-   { 16871, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */
-   { 16900, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */
-   { 16928, 0x00000001 }, /* GL_MAP_READ_BIT */
-   { 16944, 0x00000D11 }, /* GL_MAP_STENCIL */
-   { 16959, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */
-   { 16985, 0x00000002 }, /* GL_MAP_WRITE_BIT */
-   { 17002, 0x000088C0 }, /* GL_MATRIX0_ARB */
-   { 17017, 0x00008630 }, /* GL_MATRIX0_NV */
-   { 17031, 0x000088CA }, /* GL_MATRIX10_ARB */
-   { 17047, 0x000088CB }, /* GL_MATRIX11_ARB */
-   { 17063, 0x000088CC }, /* GL_MATRIX12_ARB */
-   { 17079, 0x000088CD }, /* GL_MATRIX13_ARB */
-   { 17095, 0x000088CE }, /* GL_MATRIX14_ARB */
-   { 17111, 0x000088CF }, /* GL_MATRIX15_ARB */
-   { 17127, 0x000088D0 }, /* GL_MATRIX16_ARB */
-   { 17143, 0x000088D1 }, /* GL_MATRIX17_ARB */
-   { 17159, 0x000088D2 }, /* GL_MATRIX18_ARB */
-   { 17175, 0x000088D3 }, /* GL_MATRIX19_ARB */
-   { 17191, 0x000088C1 }, /* GL_MATRIX1_ARB */
-   { 17206, 0x00008631 }, /* GL_MATRIX1_NV */
-   { 17220, 0x000088D4 }, /* GL_MATRIX20_ARB */
-   { 17236, 0x000088D5 }, /* GL_MATRIX21_ARB */
-   { 17252, 0x000088D6 }, /* GL_MATRIX22_ARB */
-   { 17268, 0x000088D7 }, /* GL_MATRIX23_ARB */
-   { 17284, 0x000088D8 }, /* GL_MATRIX24_ARB */
-   { 17300, 0x000088D9 }, /* GL_MATRIX25_ARB */
-   { 17316, 0x000088DA }, /* GL_MATRIX26_ARB */
-   { 17332, 0x000088DB }, /* GL_MATRIX27_ARB */
-   { 17348, 0x000088DC }, /* GL_MATRIX28_ARB */
-   { 17364, 0x000088DD }, /* GL_MATRIX29_ARB */
-   { 17380, 0x000088C2 }, /* GL_MATRIX2_ARB */
-   { 17395, 0x00008632 }, /* GL_MATRIX2_NV */
-   { 17409, 0x000088DE }, /* GL_MATRIX30_ARB */
-   { 17425, 0x000088DF }, /* GL_MATRIX31_ARB */
-   { 17441, 0x000088C3 }, /* GL_MATRIX3_ARB */
-   { 17456, 0x00008633 }, /* GL_MATRIX3_NV */
-   { 17470, 0x000088C4 }, /* GL_MATRIX4_ARB */
-   { 17485, 0x00008634 }, /* GL_MATRIX4_NV */
-   { 17499, 0x000088C5 }, /* GL_MATRIX5_ARB */
-   { 17514, 0x00008635 }, /* GL_MATRIX5_NV */
-   { 17528, 0x000088C6 }, /* GL_MATRIX6_ARB */
-   { 17543, 0x00008636 }, /* GL_MATRIX6_NV */
-   { 17557, 0x000088C7 }, /* GL_MATRIX7_ARB */
-   { 17572, 0x00008637 }, /* GL_MATRIX7_NV */
-   { 17586, 0x000088C8 }, /* GL_MATRIX8_ARB */
-   { 17601, 0x000088C9 }, /* GL_MATRIX9_ARB */
-   { 17616, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
-   { 17642, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-   { 17676, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-   { 17707, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-   { 17740, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-   { 17771, 0x00000BA0 }, /* GL_MATRIX_MODE */
-   { 17786, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
-   { 17808, 0x00008008 }, /* GL_MAX */
-   { 17815, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
-   { 17838, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-   { 17870, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
-   { 17896, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-   { 17929, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-   { 17955, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-   { 17989, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
-   { 18008, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS */
-   { 18033, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
-   { 18062, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-   { 18094, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
-   { 18130, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-   { 18166, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
-   { 18206, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
-   { 18232, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
-   { 18262, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
-   { 18287, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
-   { 18316, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-   { 18345, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
-   { 18378, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
-   { 18398, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
-   { 18422, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
-   { 18446, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
-   { 18470, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
-   { 18495, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
-   { 18513, 0x00008008 }, /* GL_MAX_EXT */
-   { 18524, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-   { 18559, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
-   { 18598, 0x00000D31 }, /* GL_MAX_LIGHTS */
-   { 18612, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
-   { 18632, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-   { 18670, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-   { 18699, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
-   { 18723, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
-   { 18751, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
-   { 18774, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-   { 18811, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-   { 18847, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-   { 18874, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-   { 18903, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-   { 18937, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
-   { 18973, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-   { 19000, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-   { 19032, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-   { 19068, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-   { 19097, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-   { 19126, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
-   { 19154, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-   { 19192, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-   { 19236, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-   { 19279, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-   { 19313, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-   { 19352, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-   { 19389, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-   { 19427, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-   { 19470, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-   { 19513, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-   { 19543, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-   { 19574, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-   { 19610, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-   { 19646, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
-   { 19676, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-   { 19710, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
-   { 19743, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE */
-   { 19768, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
-   { 19797, 0x00008D57 }, /* GL_MAX_SAMPLES */
-   { 19812, 0x00008D57 }, /* GL_MAX_SAMPLES_EXT */
-   { 19831, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */
-   { 19858, 0x00008504 }, /* GL_MAX_SHININESS_NV */
-   { 19878, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
-   { 19902, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
-   { 19924, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
-   { 19950, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-   { 19977, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
-   { 20008, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
-   { 20032, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-   { 20066, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
-   { 20086, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
-   { 20113, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
-   { 20134, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
-   { 20159, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
-   { 20184, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
-   { 20219, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
-   { 20241, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
-   { 20267, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
-   { 20289, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
-   { 20315, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-   { 20349, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
-   { 20387, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-   { 20420, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
-   { 20457, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
-   { 20481, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
-   { 20502, 0x00008007 }, /* GL_MIN */
-   { 20509, 0x0000802E }, /* GL_MINMAX */
-   { 20519, 0x0000802E }, /* GL_MINMAX_EXT */
-   { 20533, 0x0000802F }, /* GL_MINMAX_FORMAT */
-   { 20550, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
-   { 20571, 0x00008030 }, /* GL_MINMAX_SINK */
-   { 20586, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
-   { 20605, 0x00008007 }, /* GL_MIN_EXT */
-   { 20616, 0x00008370 }, /* GL_MIRRORED_REPEAT */
-   { 20635, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
-   { 20658, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
-   { 20681, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
-   { 20701, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
-   { 20721, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-   { 20751, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
-   { 20779, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-   { 20807, 0x00001700 }, /* GL_MODELVIEW */
-   { 20820, 0x00001700 }, /* GL_MODELVIEW0_ARB */
-   { 20838, 0x0000872A }, /* GL_MODELVIEW10_ARB */
-   { 20857, 0x0000872B }, /* GL_MODELVIEW11_ARB */
-   { 20876, 0x0000872C }, /* GL_MODELVIEW12_ARB */
-   { 20895, 0x0000872D }, /* GL_MODELVIEW13_ARB */
-   { 20914, 0x0000872E }, /* GL_MODELVIEW14_ARB */
-   { 20933, 0x0000872F }, /* GL_MODELVIEW15_ARB */
-   { 20952, 0x00008730 }, /* GL_MODELVIEW16_ARB */
-   { 20971, 0x00008731 }, /* GL_MODELVIEW17_ARB */
-   { 20990, 0x00008732 }, /* GL_MODELVIEW18_ARB */
-   { 21009, 0x00008733 }, /* GL_MODELVIEW19_ARB */
-   { 21028, 0x0000850A }, /* GL_MODELVIEW1_ARB */
-   { 21046, 0x00008734 }, /* GL_MODELVIEW20_ARB */
-   { 21065, 0x00008735 }, /* GL_MODELVIEW21_ARB */
-   { 21084, 0x00008736 }, /* GL_MODELVIEW22_ARB */
-   { 21103, 0x00008737 }, /* GL_MODELVIEW23_ARB */
-   { 21122, 0x00008738 }, /* GL_MODELVIEW24_ARB */
-   { 21141, 0x00008739 }, /* GL_MODELVIEW25_ARB */
-   { 21160, 0x0000873A }, /* GL_MODELVIEW26_ARB */
-   { 21179, 0x0000873B }, /* GL_MODELVIEW27_ARB */
-   { 21198, 0x0000873C }, /* GL_MODELVIEW28_ARB */
-   { 21217, 0x0000873D }, /* GL_MODELVIEW29_ARB */
-   { 21236, 0x00008722 }, /* GL_MODELVIEW2_ARB */
-   { 21254, 0x0000873E }, /* GL_MODELVIEW30_ARB */
-   { 21273, 0x0000873F }, /* GL_MODELVIEW31_ARB */
-   { 21292, 0x00008723 }, /* GL_MODELVIEW3_ARB */
-   { 21310, 0x00008724 }, /* GL_MODELVIEW4_ARB */
-   { 21328, 0x00008725 }, /* GL_MODELVIEW5_ARB */
-   { 21346, 0x00008726 }, /* GL_MODELVIEW6_ARB */
-   { 21364, 0x00008727 }, /* GL_MODELVIEW7_ARB */
-   { 21382, 0x00008728 }, /* GL_MODELVIEW8_ARB */
-   { 21400, 0x00008729 }, /* GL_MODELVIEW9_ARB */
-   { 21418, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
-   { 21438, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
-   { 21465, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
-   { 21490, 0x00002100 }, /* GL_MODULATE */
-   { 21502, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
-   { 21522, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
-   { 21549, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
-   { 21574, 0x00000103 }, /* GL_MULT */
-   { 21582, 0x0000809D }, /* GL_MULTISAMPLE */
-   { 21597, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
-   { 21617, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
-   { 21636, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
-   { 21655, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
-   { 21679, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
-   { 21702, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-   { 21732, 0x00002A25 }, /* GL_N3F_V3F */
-   { 21743, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
-   { 21763, 0x0000150E }, /* GL_NAND */
-   { 21771, 0x00002600 }, /* GL_NEAREST */
-   { 21782, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-   { 21813, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-   { 21845, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
-   { 21870, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
-   { 21896, 0x00000200 }, /* GL_NEVER */
-   { 21905, 0x00001102 }, /* GL_NICEST */
-   { 21915, 0x00000000 }, /* GL_NONE */
-   { 21923, 0x00001505 }, /* GL_NOOP */
-   { 21931, 0x00001508 }, /* GL_NOR */
-   { 21938, 0x00000BA1 }, /* GL_NORMALIZE */
-   { 21951, 0x00008075 }, /* GL_NORMAL_ARRAY */
-   { 21967, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
-   { 21998, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
-   { 22033, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
-   { 22057, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
-   { 22080, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
-   { 22101, 0x00008511 }, /* GL_NORMAL_MAP */
-   { 22115, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
-   { 22133, 0x00008511 }, /* GL_NORMAL_MAP_NV */
-   { 22150, 0x00000205 }, /* GL_NOTEQUAL */
-   { 22162, 0x00000000 }, /* GL_NO_ERROR */
-   { 22174, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
-   { 22208, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
-   { 22246, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
-   { 22278, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
-   { 22320, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
-   { 22350, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
-   { 22390, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
-   { 22421, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
-   { 22450, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
-   { 22478, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
-   { 22508, 0x00002401 }, /* GL_OBJECT_LINEAR */
-   { 22525, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
-   { 22551, 0x00002501 }, /* GL_OBJECT_PLANE */
-   { 22567, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
-   { 22602, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
-   { 22624, 0x00009112 }, /* GL_OBJECT_TYPE */
-   { 22639, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
-   { 22658, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
-   { 22688, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
-   { 22709, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
-   { 22737, 0x00000001 }, /* GL_ONE */
-   { 22744, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
-   { 22772, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
-   { 22804, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
-   { 22832, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
-   { 22864, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
-   { 22887, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
-   { 22910, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
-   { 22933, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
-   { 22956, 0x00008598 }, /* GL_OPERAND0_ALPHA */
-   { 22974, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
-   { 22996, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
-   { 23018, 0x00008590 }, /* GL_OPERAND0_RGB */
-   { 23034, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
-   { 23054, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
-   { 23074, 0x00008599 }, /* GL_OPERAND1_ALPHA */
-   { 23092, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
-   { 23114, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
-   { 23136, 0x00008591 }, /* GL_OPERAND1_RGB */
-   { 23152, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
-   { 23172, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
-   { 23192, 0x0000859A }, /* GL_OPERAND2_ALPHA */
-   { 23210, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
-   { 23232, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
-   { 23254, 0x00008592 }, /* GL_OPERAND2_RGB */
-   { 23270, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
-   { 23290, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
-   { 23310, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
-   { 23331, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
-   { 23350, 0x00001507 }, /* GL_OR */
-   { 23356, 0x00000A01 }, /* GL_ORDER */
-   { 23365, 0x0000150D }, /* GL_OR_INVERTED */
-   { 23380, 0x0000150B }, /* GL_OR_REVERSE */
-   { 23394, 0x00000505 }, /* GL_OUT_OF_MEMORY */
-   { 23411, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
-   { 23429, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
-   { 23450, 0x00008758 }, /* GL_PACK_INVERT_MESA */
-   { 23470, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
-   { 23488, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
-   { 23507, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
-   { 23527, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
-   { 23547, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
-   { 23565, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
-   { 23584, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
-   { 23609, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
-   { 23633, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
-   { 23654, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
-   { 23676, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
-   { 23698, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
-   { 23723, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
-   { 23747, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
-   { 23768, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
-   { 23790, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
-   { 23812, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
-   { 23834, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
-   { 23865, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
-   { 23885, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-   { 23910, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
-   { 23930, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-   { 23955, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
-   { 23975, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-   { 24000, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
-   { 24020, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-   { 24045, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
-   { 24065, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-   { 24090, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
-   { 24110, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-   { 24135, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
-   { 24155, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-   { 24180, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
-   { 24200, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-   { 24225, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
-   { 24245, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-   { 24270, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
-   { 24290, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-   { 24315, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
-   { 24333, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */
-   { 24354, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */
-   { 24383, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
-   { 24416, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
-   { 24441, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */
-   { 24464, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
-   { 24495, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
-   { 24530, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
-   { 24557, 0x00001B00 }, /* GL_POINT */
-   { 24566, 0x00000000 }, /* GL_POINTS */
-   { 24576, 0x00000002 }, /* GL_POINT_BIT */
-   { 24589, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
-   { 24619, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
-   { 24653, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
-   { 24687, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
-   { 24722, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
-   { 24751, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
-   { 24784, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
-   { 24817, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
-   { 24851, 0x00000B11 }, /* GL_POINT_SIZE */
-   { 24865, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
-   { 24891, 0x00008127 }, /* GL_POINT_SIZE_MAX */
-   { 24909, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
-   { 24931, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
-   { 24953, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
-   { 24976, 0x00008126 }, /* GL_POINT_SIZE_MIN */
-   { 24994, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
-   { 25016, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
-   { 25038, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
-   { 25061, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
-   { 25081, 0x00000B10 }, /* GL_POINT_SMOOTH */
-   { 25097, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
-   { 25118, 0x00008861 }, /* GL_POINT_SPRITE */
-   { 25134, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
-   { 25154, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
-   { 25183, 0x00008861 }, /* GL_POINT_SPRITE_NV */
-   { 25202, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
-   { 25228, 0x00000701 }, /* GL_POINT_TOKEN */
-   { 25243, 0x00000009 }, /* GL_POLYGON */
-   { 25254, 0x00000008 }, /* GL_POLYGON_BIT */
-   { 25269, 0x00000B40 }, /* GL_POLYGON_MODE */
-   { 25285, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
-   { 25308, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
-   { 25333, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
-   { 25356, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
-   { 25379, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
-   { 25403, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
-   { 25427, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
-   { 25445, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
-   { 25468, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
-   { 25487, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
-   { 25510, 0x00000703 }, /* GL_POLYGON_TOKEN */
-   { 25527, 0x00001203 }, /* GL_POSITION */
-   { 25539, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-   { 25571, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
-   { 25607, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-   { 25640, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
-   { 25677, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-   { 25708, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
-   { 25743, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-   { 25775, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
-   { 25811, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-   { 25844, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-   { 25876, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
-   { 25912, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-   { 25945, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
-   { 25982, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-   { 26012, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
-   { 26046, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-   { 26077, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
-   { 26112, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-   { 26143, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
-   { 26178, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-   { 26210, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
-   { 26246, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-   { 26276, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
-   { 26310, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-   { 26341, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
-   { 26376, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-   { 26408, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-   { 26439, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
-   { 26474, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-   { 26506, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
-   { 26542, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
-   { 26571, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
-   { 26604, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
-   { 26634, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
-   { 26668, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-   { 26707, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-   { 26740, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-   { 26780, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-   { 26814, 0x00008578 }, /* GL_PREVIOUS */
-   { 26826, 0x00008578 }, /* GL_PREVIOUS_ARB */
-   { 26842, 0x00008578 }, /* GL_PREVIOUS_EXT */
-   { 26858, 0x00008577 }, /* GL_PRIMARY_COLOR */
-   { 26875, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
-   { 26896, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
-   { 26917, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-   { 26950, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-   { 26982, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
-   { 27005, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
-   { 27028, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
-   { 27058, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
-   { 27087, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
-   { 27115, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
-   { 27137, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-   { 27165, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-   { 27193, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
-   { 27215, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
-   { 27236, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-   { 27276, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-   { 27315, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-   { 27345, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-   { 27380, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-   { 27413, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-   { 27447, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-   { 27486, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-   { 27525, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
-   { 27547, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
-   { 27573, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
-   { 27597, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
-   { 27620, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
-   { 27642, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
-   { 27663, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
-   { 27684, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
-   { 27711, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-   { 27743, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-   { 27775, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-   { 27810, 0x00001701 }, /* GL_PROJECTION */
-   { 27824, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
-   { 27845, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
-   { 27871, 0x00008E4F }, /* GL_PROVOKING_VERTEX */
-   { 27891, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */
-   { 27915, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
-   { 27936, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
-   { 27955, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
-   { 27978, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
-   { 28017, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-   { 28055, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
-   { 28075, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-   { 28105, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
-   { 28129, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
-   { 28149, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-   { 28179, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
-   { 28203, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
-   { 28223, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-   { 28256, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
-   { 28282, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
-   { 28312, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-   { 28343, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
-   { 28373, 0x00008A1D }, /* GL_PURGEABLE_APPLE */
-   { 28392, 0x00002003 }, /* GL_Q */
-   { 28397, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
-   { 28422, 0x00000007 }, /* GL_QUADS */
-   { 28431, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */
-   { 28475, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
-   { 28523, 0x00008614 }, /* GL_QUAD_MESH_SUN */
-   { 28540, 0x00000008 }, /* GL_QUAD_STRIP */
-   { 28554, 0x00008E16 }, /* GL_QUERY_BY_REGION_NO_WAIT_NV */
-   { 28584, 0x00008E15 }, /* GL_QUERY_BY_REGION_WAIT_NV */
-   { 28611, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
-   { 28633, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
-   { 28659, 0x00008E14 }, /* GL_QUERY_NO_WAIT_NV */
-   { 28679, 0x00008866 }, /* GL_QUERY_RESULT */
-   { 28695, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
-   { 28715, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
-   { 28741, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
-   { 28771, 0x00008E13 }, /* GL_QUERY_WAIT_NV */
-   { 28788, 0x00002002 }, /* GL_R */
-   { 28793, 0x00002A10 }, /* GL_R3_G3_B2 */
-   { 28805, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-   { 28838, 0x00000C02 }, /* GL_READ_BUFFER */
-   { 28853, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */
-   { 28873, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING */
-   { 28901, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
-   { 28933, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
-   { 28957, 0x000088B8 }, /* GL_READ_ONLY */
-   { 28970, 0x000088B8 }, /* GL_READ_ONLY_ARB */
-   { 28987, 0x000088BA }, /* GL_READ_WRITE */
-   { 29001, 0x000088BA }, /* GL_READ_WRITE_ARB */
-   { 29019, 0x00001903 }, /* GL_RED */
-   { 29026, 0x00008016 }, /* GL_REDUCE */
-   { 29036, 0x00008016 }, /* GL_REDUCE_EXT */
-   { 29050, 0x00000D15 }, /* GL_RED_BIAS */
-   { 29062, 0x00000D52 }, /* GL_RED_BITS */
-   { 29074, 0x00000D14 }, /* GL_RED_SCALE */
-   { 29087, 0x00008512 }, /* GL_REFLECTION_MAP */
-   { 29105, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
-   { 29127, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
-   { 29148, 0x00008A19 }, /* GL_RELEASED_APPLE */
-   { 29166, 0x00001C00 }, /* GL_RENDER */
-   { 29176, 0x00008D41 }, /* GL_RENDERBUFFER */
-   { 29192, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */
-   { 29219, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING */
-   { 29243, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
-   { 29271, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */
-   { 29297, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */
-   { 29324, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
-   { 29344, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */
-   { 29371, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */
-   { 29394, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
-   { 29421, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
-   { 29453, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-   { 29489, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */
-   { 29514, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */
-   { 29538, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES_EXT */
-   { 29566, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */
-   { 29595, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */
-   { 29617, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
-   { 29643, 0x00001F01 }, /* GL_RENDERER */
-   { 29655, 0x00000C40 }, /* GL_RENDER_MODE */
-   { 29670, 0x00002901 }, /* GL_REPEAT */
-   { 29680, 0x00001E01 }, /* GL_REPLACE */
-   { 29691, 0x00008062 }, /* GL_REPLACE_EXT */
-   { 29706, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
-   { 29729, 0x0000803A }, /* GL_RESCALE_NORMAL */
-   { 29747, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
-   { 29769, 0x00008A1B }, /* GL_RETAINED_APPLE */
-   { 29787, 0x00000102 }, /* GL_RETURN */
-   { 29797, 0x00001907 }, /* GL_RGB */
-   { 29804, 0x00008052 }, /* GL_RGB10 */
-   { 29813, 0x00008059 }, /* GL_RGB10_A2 */
-   { 29825, 0x00008059 }, /* GL_RGB10_A2_EXT */
-   { 29841, 0x00008052 }, /* GL_RGB10_EXT */
-   { 29854, 0x00008053 }, /* GL_RGB12 */
-   { 29863, 0x00008053 }, /* GL_RGB12_EXT */
-   { 29876, 0x00008054 }, /* GL_RGB16 */
-   { 29885, 0x00008054 }, /* GL_RGB16_EXT */
-   { 29898, 0x0000804E }, /* GL_RGB2_EXT */
-   { 29910, 0x0000804F }, /* GL_RGB4 */
-   { 29918, 0x0000804F }, /* GL_RGB4_EXT */
-   { 29930, 0x000083A1 }, /* GL_RGB4_S3TC */
-   { 29943, 0x00008050 }, /* GL_RGB5 */
-   { 29951, 0x00008057 }, /* GL_RGB5_A1 */
-   { 29962, 0x00008057 }, /* GL_RGB5_A1_EXT */
-   { 29977, 0x00008050 }, /* GL_RGB5_EXT */
-   { 29989, 0x00008051 }, /* GL_RGB8 */
-   { 29997, 0x00008051 }, /* GL_RGB8_EXT */
-   { 30009, 0x00001908 }, /* GL_RGBA */
-   { 30017, 0x0000805A }, /* GL_RGBA12 */
-   { 30027, 0x0000805A }, /* GL_RGBA12_EXT */
-   { 30041, 0x0000805B }, /* GL_RGBA16 */
-   { 30051, 0x0000805B }, /* GL_RGBA16_EXT */
-   { 30065, 0x00008055 }, /* GL_RGBA2 */
-   { 30074, 0x00008055 }, /* GL_RGBA2_EXT */
-   { 30087, 0x00008056 }, /* GL_RGBA4 */
-   { 30096, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
-   { 30115, 0x00008056 }, /* GL_RGBA4_EXT */
-   { 30128, 0x000083A3 }, /* GL_RGBA4_S3TC */
-   { 30142, 0x00008058 }, /* GL_RGBA8 */
-   { 30151, 0x00008058 }, /* GL_RGBA8_EXT */
-   { 30164, 0x00008F97 }, /* GL_RGBA8_SNORM */
-   { 30179, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
-   { 30197, 0x00000C31 }, /* GL_RGBA_MODE */
-   { 30210, 0x000083A2 }, /* GL_RGBA_S3TC */
-   { 30223, 0x00008F93 }, /* GL_RGBA_SNORM */
-   { 30237, 0x000083A0 }, /* GL_RGB_S3TC */
-   { 30249, 0x00008573 }, /* GL_RGB_SCALE */
-   { 30262, 0x00008573 }, /* GL_RGB_SCALE_ARB */
-   { 30279, 0x00008573 }, /* GL_RGB_SCALE_EXT */
-   { 30296, 0x00000407 }, /* GL_RIGHT */
-   { 30305, 0x00002000 }, /* GL_S */
-   { 30310, 0x00008B5D }, /* GL_SAMPLER_1D */
-   { 30324, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
-   { 30345, 0x00008B5E }, /* GL_SAMPLER_2D */
-   { 30359, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
-   { 30380, 0x00008B5F }, /* GL_SAMPLER_3D */
-   { 30394, 0x00008B60 }, /* GL_SAMPLER_CUBE */
-   { 30410, 0x000080A9 }, /* GL_SAMPLES */
-   { 30421, 0x000086B4 }, /* GL_SAMPLES_3DFX */
-   { 30437, 0x000080A9 }, /* GL_SAMPLES_ARB */
-   { 30452, 0x00008914 }, /* GL_SAMPLES_PASSED */
-   { 30470, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
-   { 30492, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-   { 30520, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
-   { 30552, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
-   { 30575, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
-   { 30602, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
-   { 30620, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
-   { 30643, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
-   { 30665, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
-   { 30684, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
-   { 30707, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
-   { 30733, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
-   { 30763, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
-   { 30788, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
-   { 30817, 0x00080000 }, /* GL_SCISSOR_BIT */
-   { 30832, 0x00000C10 }, /* GL_SCISSOR_BOX */
-   { 30847, 0x00000C11 }, /* GL_SCISSOR_TEST */
-   { 30863, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
-   { 30888, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-   { 30928, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
-   { 30972, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-   { 31005, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-   { 31035, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-   { 31067, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-   { 31097, 0x00001C02 }, /* GL_SELECT */
-   { 31107, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
-   { 31135, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
-   { 31160, 0x00008012 }, /* GL_SEPARABLE_2D */
-   { 31176, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
-   { 31203, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
-   { 31234, 0x0000150F }, /* GL_SET */
-   { 31241, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
-   { 31262, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
-   { 31286, 0x00008B4F }, /* GL_SHADER_TYPE */
-   { 31301, 0x00000B54 }, /* GL_SHADE_MODEL */
-   { 31316, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
-   { 31344, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
-   { 31367, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-   { 31397, 0x00001601 }, /* GL_SHININESS */
-   { 31410, 0x00001402 }, /* GL_SHORT */
-   { 31419, 0x00009119 }, /* GL_SIGNALED */
-   { 31431, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */
-   { 31452, 0x000081F9 }, /* GL_SINGLE_COLOR */
-   { 31468, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
-   { 31488, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
-   { 31507, 0x00008C46 }, /* GL_SLUMINANCE */
-   { 31521, 0x00008C47 }, /* GL_SLUMINANCE8 */
-   { 31536, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */
-   { 31558, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */
-   { 31578, 0x00001D01 }, /* GL_SMOOTH */
-   { 31588, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
-   { 31621, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
-   { 31648, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
-   { 31681, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
-   { 31708, 0x00008588 }, /* GL_SOURCE0_ALPHA */
-   { 31725, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
-   { 31746, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
-   { 31767, 0x00008580 }, /* GL_SOURCE0_RGB */
-   { 31782, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
-   { 31801, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
-   { 31820, 0x00008589 }, /* GL_SOURCE1_ALPHA */
-   { 31837, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
-   { 31858, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
-   { 31879, 0x00008581 }, /* GL_SOURCE1_RGB */
-   { 31894, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
-   { 31913, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
-   { 31932, 0x0000858A }, /* GL_SOURCE2_ALPHA */
-   { 31949, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
-   { 31970, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
-   { 31991, 0x00008582 }, /* GL_SOURCE2_RGB */
-   { 32006, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
-   { 32025, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
-   { 32044, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
-   { 32064, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
-   { 32082, 0x00001202 }, /* GL_SPECULAR */
-   { 32094, 0x00002402 }, /* GL_SPHERE_MAP */
-   { 32108, 0x00001206 }, /* GL_SPOT_CUTOFF */
-   { 32123, 0x00001204 }, /* GL_SPOT_DIRECTION */
-   { 32141, 0x00001205 }, /* GL_SPOT_EXPONENT */
-   { 32158, 0x00008588 }, /* GL_SRC0_ALPHA */
-   { 32172, 0x00008580 }, /* GL_SRC0_RGB */
-   { 32184, 0x00008589 }, /* GL_SRC1_ALPHA */
-   { 32198, 0x00008581 }, /* GL_SRC1_RGB */
-   { 32210, 0x0000858A }, /* GL_SRC2_ALPHA */
-   { 32224, 0x00008582 }, /* GL_SRC2_RGB */
-   { 32236, 0x00000302 }, /* GL_SRC_ALPHA */
-   { 32249, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
-   { 32271, 0x00000300 }, /* GL_SRC_COLOR */
-   { 32284, 0x00008C40 }, /* GL_SRGB */
-   { 32292, 0x00008C41 }, /* GL_SRGB8 */
-   { 32301, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */
-   { 32317, 0x00008C42 }, /* GL_SRGB_ALPHA */
-   { 32331, 0x00000503 }, /* GL_STACK_OVERFLOW */
-   { 32349, 0x00000504 }, /* GL_STACK_UNDERFLOW */
-   { 32368, 0x000088E6 }, /* GL_STATIC_COPY */
-   { 32383, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
-   { 32402, 0x000088E4 }, /* GL_STATIC_DRAW */
-   { 32417, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
-   { 32436, 0x000088E5 }, /* GL_STATIC_READ */
-   { 32451, 0x000088E5 }, /* GL_STATIC_READ_ARB */
-   { 32470, 0x00001802 }, /* GL_STENCIL */
-   { 32481, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */
-   { 32503, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
-   { 32529, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
-   { 32550, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */
-   { 32575, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
-   { 32596, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */
-   { 32621, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-   { 32653, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */
-   { 32689, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
-   { 32721, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */
-   { 32757, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
-   { 32777, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
-   { 32804, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
-   { 32830, 0x00000D57 }, /* GL_STENCIL_BITS */
-   { 32846, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
-   { 32868, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
-   { 32891, 0x00000B94 }, /* GL_STENCIL_FAIL */
-   { 32907, 0x00000B92 }, /* GL_STENCIL_FUNC */
-   { 32923, 0x00001901 }, /* GL_STENCIL_INDEX */
-   { 32940, 0x00008D46 }, /* GL_STENCIL_INDEX1 */
-   { 32958, 0x00008D49 }, /* GL_STENCIL_INDEX16 */
-   { 32977, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
-   { 33000, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
-   { 33022, 0x00008D47 }, /* GL_STENCIL_INDEX4 */
-   { 33040, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
-   { 33062, 0x00008D48 }, /* GL_STENCIL_INDEX8 */
-   { 33080, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
-   { 33102, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
-   { 33123, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
-   { 33150, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
-   { 33177, 0x00000B97 }, /* GL_STENCIL_REF */
-   { 33192, 0x00000B90 }, /* GL_STENCIL_TEST */
-   { 33208, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
-   { 33237, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
-   { 33259, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
-   { 33280, 0x00000C33 }, /* GL_STEREO */
-   { 33290, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */
-   { 33314, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */
-   { 33339, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */
-   { 33363, 0x000088E2 }, /* GL_STREAM_COPY */
-   { 33378, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
-   { 33397, 0x000088E0 }, /* GL_STREAM_DRAW */
-   { 33412, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
-   { 33431, 0x000088E1 }, /* GL_STREAM_READ */
-   { 33446, 0x000088E1 }, /* GL_STREAM_READ_ARB */
-   { 33465, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
-   { 33482, 0x000084E7 }, /* GL_SUBTRACT */
-   { 33494, 0x000084E7 }, /* GL_SUBTRACT_ARB */
-   { 33510, 0x00009113 }, /* GL_SYNC_CONDITION */
-   { 33528, 0x00009116 }, /* GL_SYNC_FENCE */
-   { 33542, 0x00009115 }, /* GL_SYNC_FLAGS */
-   { 33556, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */
-   { 33583, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
-   { 33613, 0x00009114 }, /* GL_SYNC_STATUS */
-   { 33628, 0x00002001 }, /* GL_T */
-   { 33633, 0x00002A2A }, /* GL_T2F_C3F_V3F */
-   { 33648, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
-   { 33667, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
-   { 33683, 0x00002A2B }, /* GL_T2F_N3F_V3F */
-   { 33698, 0x00002A27 }, /* GL_T2F_V3F */
-   { 33709, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
-   { 33728, 0x00002A28 }, /* GL_T4F_V4F */
-   { 33739, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
-   { 33762, 0x00001702 }, /* GL_TEXTURE */
-   { 33773, 0x000084C0 }, /* GL_TEXTURE0 */
-   { 33785, 0x000084C0 }, /* GL_TEXTURE0_ARB */
-   { 33801, 0x000084C1 }, /* GL_TEXTURE1 */
-   { 33813, 0x000084CA }, /* GL_TEXTURE10 */
-   { 33826, 0x000084CA }, /* GL_TEXTURE10_ARB */
-   { 33843, 0x000084CB }, /* GL_TEXTURE11 */
-   { 33856, 0x000084CB }, /* GL_TEXTURE11_ARB */
-   { 33873, 0x000084CC }, /* GL_TEXTURE12 */
-   { 33886, 0x000084CC }, /* GL_TEXTURE12_ARB */
-   { 33903, 0x000084CD }, /* GL_TEXTURE13 */
-   { 33916, 0x000084CD }, /* GL_TEXTURE13_ARB */
-   { 33933, 0x000084CE }, /* GL_TEXTURE14 */
-   { 33946, 0x000084CE }, /* GL_TEXTURE14_ARB */
-   { 33963, 0x000084CF }, /* GL_TEXTURE15 */
-   { 33976, 0x000084CF }, /* GL_TEXTURE15_ARB */
-   { 33993, 0x000084D0 }, /* GL_TEXTURE16 */
-   { 34006, 0x000084D0 }, /* GL_TEXTURE16_ARB */
-   { 34023, 0x000084D1 }, /* GL_TEXTURE17 */
-   { 34036, 0x000084D1 }, /* GL_TEXTURE17_ARB */
-   { 34053, 0x000084D2 }, /* GL_TEXTURE18 */
-   { 34066, 0x000084D2 }, /* GL_TEXTURE18_ARB */
-   { 34083, 0x000084D3 }, /* GL_TEXTURE19 */
-   { 34096, 0x000084D3 }, /* GL_TEXTURE19_ARB */
-   { 34113, 0x000084C1 }, /* GL_TEXTURE1_ARB */
-   { 34129, 0x000084C2 }, /* GL_TEXTURE2 */
-   { 34141, 0x000084D4 }, /* GL_TEXTURE20 */
-   { 34154, 0x000084D4 }, /* GL_TEXTURE20_ARB */
-   { 34171, 0x000084D5 }, /* GL_TEXTURE21 */
-   { 34184, 0x000084D5 }, /* GL_TEXTURE21_ARB */
-   { 34201, 0x000084D6 }, /* GL_TEXTURE22 */
-   { 34214, 0x000084D6 }, /* GL_TEXTURE22_ARB */
-   { 34231, 0x000084D7 }, /* GL_TEXTURE23 */
-   { 34244, 0x000084D7 }, /* GL_TEXTURE23_ARB */
-   { 34261, 0x000084D8 }, /* GL_TEXTURE24 */
-   { 34274, 0x000084D8 }, /* GL_TEXTURE24_ARB */
-   { 34291, 0x000084D9 }, /* GL_TEXTURE25 */
-   { 34304, 0x000084D9 }, /* GL_TEXTURE25_ARB */
-   { 34321, 0x000084DA }, /* GL_TEXTURE26 */
-   { 34334, 0x000084DA }, /* GL_TEXTURE26_ARB */
-   { 34351, 0x000084DB }, /* GL_TEXTURE27 */
-   { 34364, 0x000084DB }, /* GL_TEXTURE27_ARB */
-   { 34381, 0x000084DC }, /* GL_TEXTURE28 */
-   { 34394, 0x000084DC }, /* GL_TEXTURE28_ARB */
-   { 34411, 0x000084DD }, /* GL_TEXTURE29 */
-   { 34424, 0x000084DD }, /* GL_TEXTURE29_ARB */
-   { 34441, 0x000084C2 }, /* GL_TEXTURE2_ARB */
-   { 34457, 0x000084C3 }, /* GL_TEXTURE3 */
-   { 34469, 0x000084DE }, /* GL_TEXTURE30 */
-   { 34482, 0x000084DE }, /* GL_TEXTURE30_ARB */
-   { 34499, 0x000084DF }, /* GL_TEXTURE31 */
-   { 34512, 0x000084DF }, /* GL_TEXTURE31_ARB */
-   { 34529, 0x000084C3 }, /* GL_TEXTURE3_ARB */
-   { 34545, 0x000084C4 }, /* GL_TEXTURE4 */
-   { 34557, 0x000084C4 }, /* GL_TEXTURE4_ARB */
-   { 34573, 0x000084C5 }, /* GL_TEXTURE5 */
-   { 34585, 0x000084C5 }, /* GL_TEXTURE5_ARB */
-   { 34601, 0x000084C6 }, /* GL_TEXTURE6 */
-   { 34613, 0x000084C6 }, /* GL_TEXTURE6_ARB */
-   { 34629, 0x000084C7 }, /* GL_TEXTURE7 */
-   { 34641, 0x000084C7 }, /* GL_TEXTURE7_ARB */
-   { 34657, 0x000084C8 }, /* GL_TEXTURE8 */
-   { 34669, 0x000084C8 }, /* GL_TEXTURE8_ARB */
-   { 34685, 0x000084C9 }, /* GL_TEXTURE9 */
-   { 34697, 0x000084C9 }, /* GL_TEXTURE9_ARB */
-   { 34713, 0x00000DE0 }, /* GL_TEXTURE_1D */
-   { 34727, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
-   { 34751, 0x00000DE1 }, /* GL_TEXTURE_2D */
-   { 34765, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
-   { 34789, 0x0000806F }, /* GL_TEXTURE_3D */
-   { 34803, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
-   { 34825, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
-   { 34851, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
-   { 34873, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
-   { 34895, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-   { 34927, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
-   { 34949, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-   { 34981, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
-   { 35003, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
-   { 35031, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
-   { 35063, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-   { 35096, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
-   { 35128, 0x00040000 }, /* GL_TEXTURE_BIT */
-   { 35143, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
-   { 35164, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
-   { 35189, 0x00001005 }, /* GL_TEXTURE_BORDER */
-   { 35207, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
-   { 35231, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-   { 35262, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-   { 35292, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-   { 35322, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-   { 35357, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-   { 35388, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-   { 35426, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
-   { 35453, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-   { 35485, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-   { 35519, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
-   { 35543, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
-   { 35571, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
-   { 35595, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
-   { 35623, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-   { 35656, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
-   { 35680, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
-   { 35702, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
-   { 35724, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
-   { 35750, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
-   { 35784, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-   { 35817, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
-   { 35854, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
-   { 35882, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
-   { 35914, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
-   { 35937, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-   { 35975, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
-   { 36017, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-   { 36048, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-   { 36076, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-   { 36106, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-   { 36134, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
-   { 36154, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
-   { 36178, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-   { 36209, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
-   { 36244, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-   { 36275, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
-   { 36310, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-   { 36341, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
-   { 36376, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-   { 36407, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
-   { 36442, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-   { 36473, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
-   { 36508, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-   { 36539, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
-   { 36574, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
-   { 36603, 0x00008071 }, /* GL_TEXTURE_DEPTH */
-   { 36620, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
-   { 36642, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
-   { 36668, 0x00002300 }, /* GL_TEXTURE_ENV */
-   { 36683, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
-   { 36704, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
-   { 36724, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
-   { 36750, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
-   { 36770, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
-   { 36787, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
-   { 36804, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
-   { 36821, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
-   { 36838, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
-   { 36863, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
-   { 36885, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
-   { 36911, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
-   { 36929, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
-   { 36955, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
-   { 36981, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
-   { 37011, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
-   { 37038, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
-   { 37063, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
-   { 37083, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
-   { 37107, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-   { 37134, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-   { 37161, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-   { 37188, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
-   { 37214, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
-   { 37244, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
-   { 37266, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
-   { 37284, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-   { 37314, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-   { 37342, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-   { 37370, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-   { 37398, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
-   { 37419, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
-   { 37438, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
-   { 37460, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
-   { 37479, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
-   { 37499, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
-   { 37529, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */
-   { 37560, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
-   { 37585, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
-   { 37609, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
-   { 37629, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
-   { 37653, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
-   { 37673, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
-   { 37696, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */
-   { 37720, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE_EXT */
-   { 37748, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */
-   { 37778, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
-   { 37803, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
-   { 37837, 0x00001000 }, /* GL_TEXTURE_WIDTH */
-   { 37854, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
-   { 37872, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
-   { 37890, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
-   { 37908, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */
-   { 37927, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
-   { 37947, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
-   { 37966, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-   { 37995, 0x00001000 }, /* GL_TRANSFORM_BIT */
-   { 38012, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
-   { 38038, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
-   { 38068, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-   { 38100, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-   { 38130, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
-   { 38164, 0x0000862C }, /* GL_TRANSPOSE_NV */
-   { 38180, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-   { 38211, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
-   { 38246, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-   { 38274, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
-   { 38306, 0x00000004 }, /* GL_TRIANGLES */
-   { 38319, 0x00000006 }, /* GL_TRIANGLE_FAN */
-   { 38335, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
-   { 38356, 0x00000005 }, /* GL_TRIANGLE_STRIP */
-   { 38374, 0x00000001 }, /* GL_TRUE */
-   { 38382, 0x00008A1C }, /* GL_UNDEFINED_APPLE */
-   { 38401, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
-   { 38421, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
-   { 38444, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
-   { 38464, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
-   { 38485, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
-   { 38507, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
-   { 38529, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
-   { 38549, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
-   { 38570, 0x00009118 }, /* GL_UNSIGNALED */
-   { 38584, 0x00001401 }, /* GL_UNSIGNED_BYTE */
-   { 38601, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-   { 38628, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
-   { 38651, 0x00001405 }, /* GL_UNSIGNED_INT */
-   { 38667, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
-   { 38694, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */
-   { 38715, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_EXT */
-   { 38740, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
-   { 38764, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-   { 38795, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
-   { 38819, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-   { 38847, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */
-   { 38870, 0x00001403 }, /* GL_UNSIGNED_SHORT */
-   { 38888, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-   { 38918, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-   { 38944, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-   { 38974, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-   { 39000, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
-   { 39024, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-   { 39052, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-   { 39080, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
-   { 39107, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-   { 39139, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
-   { 39170, 0x00008CA2 }, /* GL_UPPER_LEFT */
-   { 39184, 0x00002A20 }, /* GL_V2F */
-   { 39191, 0x00002A21 }, /* GL_V3F */
-   { 39198, 0x00008B83 }, /* GL_VALIDATE_STATUS */
-   { 39217, 0x00001F00 }, /* GL_VENDOR */
-   { 39227, 0x00001F02 }, /* GL_VERSION */
-   { 39238, 0x00008074 }, /* GL_VERTEX_ARRAY */
-   { 39254, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */
-   { 39278, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
-   { 39308, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-   { 39339, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
-   { 39374, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
-   { 39398, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
-   { 39419, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
-   { 39442, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
-   { 39463, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-   { 39490, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-   { 39518, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-   { 39546, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-   { 39574, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-   { 39602, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-   { 39630, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-   { 39658, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-   { 39685, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-   { 39712, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-   { 39739, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-   { 39766, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-   { 39793, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-   { 39820, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-   { 39847, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-   { 39874, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-   { 39901, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-   { 39939, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
-   { 39981, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-   { 40012, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
-   { 40047, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
-   { 40081, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
-   { 40119, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-   { 40150, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
-   { 40185, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-   { 40213, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
-   { 40245, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-   { 40275, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
-   { 40309, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
-   { 40337, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
-   { 40369, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
-   { 40389, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
-   { 40411, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
-   { 40440, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
-   { 40461, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-   { 40490, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
-   { 40523, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
-   { 40555, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-   { 40582, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
-   { 40613, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
-   { 40643, 0x00008B31 }, /* GL_VERTEX_SHADER */
-   { 40660, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
-   { 40681, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
-   { 40708, 0x00000BA2 }, /* GL_VIEWPORT */
-   { 40720, 0x00000800 }, /* GL_VIEWPORT_BIT */
-   { 40736, 0x00008A1A }, /* GL_VOLATILE_APPLE */
-   { 40754, 0x0000911D }, /* GL_WAIT_FAILED */
-   { 40769, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
-   { 40789, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-   { 40820, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
-   { 40855, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-   { 40883, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-   { 40908, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-   { 40935, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-   { 40960, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
-   { 40984, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
-   { 41003, 0x000088B9 }, /* GL_WRITE_ONLY */
-   { 41017, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
-   { 41035, 0x00001506 }, /* GL_XOR */
-   { 41042, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
-   { 41061, 0x00008757 }, /* GL_YCBCR_MESA */
-   { 41075, 0x00000000 }, /* GL_ZERO */
-   { 41083, 0x00000D16 }, /* GL_ZOOM_X */
-   { 41093, 0x00000D17 }, /* GL_ZOOM_Y */
+   { 13888, 0x00008C8C }, /* GL_INTERLEAVED_ATTRIBS_EXT */
+   { 13915, 0x00008575 }, /* GL_INTERPOLATE */
+   { 13930, 0x00008575 }, /* GL_INTERPOLATE_ARB */
+   { 13949, 0x00008575 }, /* GL_INTERPOLATE_EXT */
+   { 13968, 0x00008B53 }, /* GL_INT_VEC2 */
+   { 13980, 0x00008B53 }, /* GL_INT_VEC2_ARB */
+   { 13996, 0x00008B54 }, /* GL_INT_VEC3 */
+   { 14008, 0x00008B54 }, /* GL_INT_VEC3_ARB */
+   { 14024, 0x00008B55 }, /* GL_INT_VEC4 */
+   { 14036, 0x00008B55 }, /* GL_INT_VEC4_ARB */
+   { 14052, 0x00000500 }, /* GL_INVALID_ENUM */
+   { 14068, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */
+   { 14101, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
+   { 14138, 0x00000502 }, /* GL_INVALID_OPERATION */
+   { 14159, 0x00000501 }, /* GL_INVALID_VALUE */
+   { 14176, 0x0000862B }, /* GL_INVERSE_NV */
+   { 14190, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
+   { 14214, 0x0000150A }, /* GL_INVERT */
+   { 14224, 0x00001E00 }, /* GL_KEEP */
+   { 14232, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION */
+   { 14258, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */
+   { 14288, 0x00000406 }, /* GL_LEFT */
+   { 14296, 0x00000203 }, /* GL_LEQUAL */
+   { 14306, 0x00000201 }, /* GL_LESS */
+   { 14314, 0x00004000 }, /* GL_LIGHT0 */
+   { 14324, 0x00004001 }, /* GL_LIGHT1 */
+   { 14334, 0x00004002 }, /* GL_LIGHT2 */
+   { 14344, 0x00004003 }, /* GL_LIGHT3 */
+   { 14354, 0x00004004 }, /* GL_LIGHT4 */
+   { 14364, 0x00004005 }, /* GL_LIGHT5 */
+   { 14374, 0x00004006 }, /* GL_LIGHT6 */
+   { 14384, 0x00004007 }, /* GL_LIGHT7 */
+   { 14394, 0x00000B50 }, /* GL_LIGHTING */
+   { 14406, 0x00000040 }, /* GL_LIGHTING_BIT */
+   { 14422, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
+   { 14445, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+   { 14474, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
+   { 14507, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+   { 14535, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
+   { 14559, 0x00001B01 }, /* GL_LINE */
+   { 14567, 0x00002601 }, /* GL_LINEAR */
+   { 14577, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
+   { 14599, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+   { 14629, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+   { 14660, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
+   { 14684, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
+   { 14709, 0x00000001 }, /* GL_LINES */
+   { 14718, 0x00000004 }, /* GL_LINE_BIT */
+   { 14730, 0x00000002 }, /* GL_LINE_LOOP */
+   { 14743, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
+   { 14763, 0x00000B20 }, /* GL_LINE_SMOOTH */
+   { 14778, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
+   { 14798, 0x00000B24 }, /* GL_LINE_STIPPLE */
+   { 14814, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
+   { 14838, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
+   { 14861, 0x00000003 }, /* GL_LINE_STRIP */
+   { 14875, 0x00000702 }, /* GL_LINE_TOKEN */
+   { 14889, 0x00000B21 }, /* GL_LINE_WIDTH */
+   { 14903, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
+   { 14929, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
+   { 14949, 0x00008B82 }, /* GL_LINK_STATUS */
+   { 14964, 0x00000B32 }, /* GL_LIST_BASE */
+   { 14977, 0x00020000 }, /* GL_LIST_BIT */
+   { 14989, 0x00000B33 }, /* GL_LIST_INDEX */
+   { 15003, 0x00000B30 }, /* GL_LIST_MODE */
+   { 15016, 0x00000101 }, /* GL_LOAD */
+   { 15024, 0x00000BF1 }, /* GL_LOGIC_OP */
+   { 15036, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
+   { 15053, 0x00008CA1 }, /* GL_LOWER_LEFT */
+   { 15067, 0x00001909 }, /* GL_LUMINANCE */
+   { 15080, 0x00008041 }, /* GL_LUMINANCE12 */
+   { 15095, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
+   { 15118, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
+   { 15145, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
+   { 15167, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
+   { 15193, 0x00008041 }, /* GL_LUMINANCE12_EXT */
+   { 15212, 0x00008042 }, /* GL_LUMINANCE16 */
+   { 15227, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
+   { 15250, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
+   { 15277, 0x00008042 }, /* GL_LUMINANCE16_EXT */
+   { 15296, 0x0000803F }, /* GL_LUMINANCE4 */
+   { 15310, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
+   { 15331, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
+   { 15356, 0x0000803F }, /* GL_LUMINANCE4_EXT */
+   { 15374, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
+   { 15395, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
+   { 15420, 0x00008040 }, /* GL_LUMINANCE8 */
+   { 15434, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
+   { 15455, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
+   { 15480, 0x00008040 }, /* GL_LUMINANCE8_EXT */
+   { 15498, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
+   { 15517, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
+   { 15533, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
+   { 15553, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
+   { 15575, 0x00000D91 }, /* GL_MAP1_INDEX */
+   { 15589, 0x00000D92 }, /* GL_MAP1_NORMAL */
+   { 15604, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
+   { 15628, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
+   { 15652, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
+   { 15676, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
+   { 15700, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
+   { 15717, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
+   { 15734, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+   { 15762, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+   { 15791, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+   { 15820, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+   { 15849, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+   { 15878, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+   { 15907, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+   { 15936, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+   { 15964, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+   { 15992, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+   { 16020, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+   { 16048, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+   { 16076, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+   { 16104, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+   { 16132, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+   { 16160, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+   { 16188, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
+   { 16204, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
+   { 16224, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
+   { 16246, 0x00000DB1 }, /* GL_MAP2_INDEX */
+   { 16260, 0x00000DB2 }, /* GL_MAP2_NORMAL */
+   { 16275, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
+   { 16299, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
+   { 16323, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
+   { 16347, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
+   { 16371, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
+   { 16388, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
+   { 16405, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+   { 16433, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+   { 16462, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+   { 16491, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+   { 16520, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+   { 16549, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+   { 16578, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+   { 16607, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+   { 16635, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+   { 16663, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+   { 16691, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+   { 16719, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+   { 16747, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+   { 16775, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
+   { 16803, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+   { 16831, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+   { 16859, 0x00000D10 }, /* GL_MAP_COLOR */
+   { 16872, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */
+   { 16898, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */
+   { 16927, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */
+   { 16955, 0x00000001 }, /* GL_MAP_READ_BIT */
+   { 16971, 0x00000D11 }, /* GL_MAP_STENCIL */
+   { 16986, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */
+   { 17012, 0x00000002 }, /* GL_MAP_WRITE_BIT */
+   { 17029, 0x000088C0 }, /* GL_MATRIX0_ARB */
+   { 17044, 0x00008630 }, /* GL_MATRIX0_NV */
+   { 17058, 0x000088CA }, /* GL_MATRIX10_ARB */
+   { 17074, 0x000088CB }, /* GL_MATRIX11_ARB */
+   { 17090, 0x000088CC }, /* GL_MATRIX12_ARB */
+   { 17106, 0x000088CD }, /* GL_MATRIX13_ARB */
+   { 17122, 0x000088CE }, /* GL_MATRIX14_ARB */
+   { 17138, 0x000088CF }, /* GL_MATRIX15_ARB */
+   { 17154, 0x000088D0 }, /* GL_MATRIX16_ARB */
+   { 17170, 0x000088D1 }, /* GL_MATRIX17_ARB */
+   { 17186, 0x000088D2 }, /* GL_MATRIX18_ARB */
+   { 17202, 0x000088D3 }, /* GL_MATRIX19_ARB */
+   { 17218, 0x000088C1 }, /* GL_MATRIX1_ARB */
+   { 17233, 0x00008631 }, /* GL_MATRIX1_NV */
+   { 17247, 0x000088D4 }, /* GL_MATRIX20_ARB */
+   { 17263, 0x000088D5 }, /* GL_MATRIX21_ARB */
+   { 17279, 0x000088D6 }, /* GL_MATRIX22_ARB */
+   { 17295, 0x000088D7 }, /* GL_MATRIX23_ARB */
+   { 17311, 0x000088D8 }, /* GL_MATRIX24_ARB */
+   { 17327, 0x000088D9 }, /* GL_MATRIX25_ARB */
+   { 17343, 0x000088DA }, /* GL_MATRIX26_ARB */
+   { 17359, 0x000088DB }, /* GL_MATRIX27_ARB */
+   { 17375, 0x000088DC }, /* GL_MATRIX28_ARB */
+   { 17391, 0x000088DD }, /* GL_MATRIX29_ARB */
+   { 17407, 0x000088C2 }, /* GL_MATRIX2_ARB */
+   { 17422, 0x00008632 }, /* GL_MATRIX2_NV */
+   { 17436, 0x000088DE }, /* GL_MATRIX30_ARB */
+   { 17452, 0x000088DF }, /* GL_MATRIX31_ARB */
+   { 17468, 0x000088C3 }, /* GL_MATRIX3_ARB */
+   { 17483, 0x00008633 }, /* GL_MATRIX3_NV */
+   { 17497, 0x000088C4 }, /* GL_MATRIX4_ARB */
+   { 17512, 0x00008634 }, /* GL_MATRIX4_NV */
+   { 17526, 0x000088C5 }, /* GL_MATRIX5_ARB */
+   { 17541, 0x00008635 }, /* GL_MATRIX5_NV */
+   { 17555, 0x000088C6 }, /* GL_MATRIX6_ARB */
+   { 17570, 0x00008636 }, /* GL_MATRIX6_NV */
+   { 17584, 0x000088C7 }, /* GL_MATRIX7_ARB */
+   { 17599, 0x00008637 }, /* GL_MATRIX7_NV */
+   { 17613, 0x000088C8 }, /* GL_MATRIX8_ARB */
+   { 17628, 0x000088C9 }, /* GL_MATRIX9_ARB */
+   { 17643, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
+   { 17669, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+   { 17703, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+   { 17734, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+   { 17767, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+   { 17798, 0x00000BA0 }, /* GL_MATRIX_MODE */
+   { 17813, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
+   { 17835, 0x00008008 }, /* GL_MAX */
+   { 17842, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
+   { 17865, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
+   { 17897, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
+   { 17923, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+   { 17956, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+   { 17982, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 18016, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
+   { 18035, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS */
+   { 18060, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
+   { 18089, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+   { 18121, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
+   { 18157, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+   { 18193, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
+   { 18233, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
+   { 18259, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
+   { 18289, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
+   { 18314, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
+   { 18343, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+   { 18372, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
+   { 18405, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
+   { 18425, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
+   { 18449, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
+   { 18473, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
+   { 18497, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
+   { 18522, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
+   { 18540, 0x00008008 }, /* GL_MAX_EXT */
+   { 18551, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+   { 18586, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
+   { 18625, 0x00000D31 }, /* GL_MAX_LIGHTS */
+   { 18639, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
+   { 18659, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+   { 18697, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+   { 18726, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
+   { 18750, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
+   { 18778, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
+   { 18801, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 18838, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 18874, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+   { 18901, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+   { 18930, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+   { 18964, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
+   { 19000, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+   { 19027, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+   { 19059, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+   { 19095, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+   { 19124, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+   { 19153, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
+   { 19181, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+   { 19219, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 19263, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 19306, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 19340, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 19379, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 19416, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 19454, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 19497, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 19540, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+   { 19570, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+   { 19601, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 19637, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 19673, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
+   { 19703, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+   { 19737, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
+   { 19770, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE */
+   { 19795, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
+   { 19824, 0x00008D57 }, /* GL_MAX_SAMPLES */
+   { 19839, 0x00008D57 }, /* GL_MAX_SAMPLES_EXT */
+   { 19858, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+   { 19885, 0x00008504 }, /* GL_MAX_SHININESS_NV */
+   { 19905, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
+   { 19929, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
+   { 19951, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
+   { 19977, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+   { 20004, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
+   { 20035, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
+   { 20059, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 20093, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
+   { 20113, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
+   { 20140, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
+   { 20161, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
+   { 20186, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
+   { 20211, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
+   { 20246, 0x00008C8A }, /* GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT */
+   { 20299, 0x00008C8B }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT */
+   { 20346, 0x00008C80 }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT */
+   { 20396, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
+   { 20418, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
+   { 20444, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
+   { 20466, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
+   { 20492, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+   { 20526, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
+   { 20564, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+   { 20597, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
+   { 20634, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
+   { 20658, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
+   { 20679, 0x00008007 }, /* GL_MIN */
+   { 20686, 0x0000802E }, /* GL_MINMAX */
+   { 20696, 0x0000802E }, /* GL_MINMAX_EXT */
+   { 20710, 0x0000802F }, /* GL_MINMAX_FORMAT */
+   { 20727, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
+   { 20748, 0x00008030 }, /* GL_MINMAX_SINK */
+   { 20763, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
+   { 20782, 0x00008007 }, /* GL_MIN_EXT */
+   { 20793, 0x00008370 }, /* GL_MIRRORED_REPEAT */
+   { 20812, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
+   { 20835, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
+   { 20858, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
+   { 20878, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
+   { 20898, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+   { 20928, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
+   { 20956, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+   { 20984, 0x00001700 }, /* GL_MODELVIEW */
+   { 20997, 0x00001700 }, /* GL_MODELVIEW0_ARB */
+   { 21015, 0x0000872A }, /* GL_MODELVIEW10_ARB */
+   { 21034, 0x0000872B }, /* GL_MODELVIEW11_ARB */
+   { 21053, 0x0000872C }, /* GL_MODELVIEW12_ARB */
+   { 21072, 0x0000872D }, /* GL_MODELVIEW13_ARB */
+   { 21091, 0x0000872E }, /* GL_MODELVIEW14_ARB */
+   { 21110, 0x0000872F }, /* GL_MODELVIEW15_ARB */
+   { 21129, 0x00008730 }, /* GL_MODELVIEW16_ARB */
+   { 21148, 0x00008731 }, /* GL_MODELVIEW17_ARB */
+   { 21167, 0x00008732 }, /* GL_MODELVIEW18_ARB */
+   { 21186, 0x00008733 }, /* GL_MODELVIEW19_ARB */
+   { 21205, 0x0000850A }, /* GL_MODELVIEW1_ARB */
+   { 21223, 0x00008734 }, /* GL_MODELVIEW20_ARB */
+   { 21242, 0x00008735 }, /* GL_MODELVIEW21_ARB */
+   { 21261, 0x00008736 }, /* GL_MODELVIEW22_ARB */
+   { 21280, 0x00008737 }, /* GL_MODELVIEW23_ARB */
+   { 21299, 0x00008738 }, /* GL_MODELVIEW24_ARB */
+   { 21318, 0x00008739 }, /* GL_MODELVIEW25_ARB */
+   { 21337, 0x0000873A }, /* GL_MODELVIEW26_ARB */
+   { 21356, 0x0000873B }, /* GL_MODELVIEW27_ARB */
+   { 21375, 0x0000873C }, /* GL_MODELVIEW28_ARB */
+   { 21394, 0x0000873D }, /* GL_MODELVIEW29_ARB */
+   { 21413, 0x00008722 }, /* GL_MODELVIEW2_ARB */
+   { 21431, 0x0000873E }, /* GL_MODELVIEW30_ARB */
+   { 21450, 0x0000873F }, /* GL_MODELVIEW31_ARB */
+   { 21469, 0x00008723 }, /* GL_MODELVIEW3_ARB */
+   { 21487, 0x00008724 }, /* GL_MODELVIEW4_ARB */
+   { 21505, 0x00008725 }, /* GL_MODELVIEW5_ARB */
+   { 21523, 0x00008726 }, /* GL_MODELVIEW6_ARB */
+   { 21541, 0x00008727 }, /* GL_MODELVIEW7_ARB */
+   { 21559, 0x00008728 }, /* GL_MODELVIEW8_ARB */
+   { 21577, 0x00008729 }, /* GL_MODELVIEW9_ARB */
+   { 21595, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
+   { 21615, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
+   { 21642, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
+   { 21667, 0x00002100 }, /* GL_MODULATE */
+   { 21679, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
+   { 21699, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
+   { 21726, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
+   { 21751, 0x00000103 }, /* GL_MULT */
+   { 21759, 0x0000809D }, /* GL_MULTISAMPLE */
+   { 21774, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
+   { 21794, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
+   { 21813, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
+   { 21832, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
+   { 21856, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
+   { 21879, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+   { 21909, 0x00002A25 }, /* GL_N3F_V3F */
+   { 21920, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
+   { 21940, 0x0000150E }, /* GL_NAND */
+   { 21948, 0x00002600 }, /* GL_NEAREST */
+   { 21959, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+   { 21990, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+   { 22022, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
+   { 22047, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
+   { 22073, 0x00000200 }, /* GL_NEVER */
+   { 22082, 0x00001102 }, /* GL_NICEST */
+   { 22092, 0x00000000 }, /* GL_NONE */
+   { 22100, 0x00001505 }, /* GL_NOOP */
+   { 22108, 0x00001508 }, /* GL_NOR */
+   { 22115, 0x00000BA1 }, /* GL_NORMALIZE */
+   { 22128, 0x00008075 }, /* GL_NORMAL_ARRAY */
+   { 22144, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+   { 22175, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
+   { 22210, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
+   { 22234, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
+   { 22257, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
+   { 22278, 0x00008511 }, /* GL_NORMAL_MAP */
+   { 22292, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
+   { 22310, 0x00008511 }, /* GL_NORMAL_MAP_NV */
+   { 22327, 0x00000205 }, /* GL_NOTEQUAL */
+   { 22339, 0x00000000 }, /* GL_NO_ERROR */
+   { 22351, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+   { 22385, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
+   { 22423, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
+   { 22455, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
+   { 22497, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
+   { 22527, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
+   { 22567, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
+   { 22598, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
+   { 22627, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
+   { 22655, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
+   { 22685, 0x00002401 }, /* GL_OBJECT_LINEAR */
+   { 22702, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
+   { 22728, 0x00002501 }, /* GL_OBJECT_PLANE */
+   { 22744, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
+   { 22779, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
+   { 22801, 0x00009112 }, /* GL_OBJECT_TYPE */
+   { 22816, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
+   { 22835, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
+   { 22865, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
+   { 22886, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
+   { 22914, 0x00000001 }, /* GL_ONE */
+   { 22921, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+   { 22949, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
+   { 22981, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
+   { 23009, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
+   { 23041, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
+   { 23064, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
+   { 23087, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
+   { 23110, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
+   { 23133, 0x00008598 }, /* GL_OPERAND0_ALPHA */
+   { 23151, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
+   { 23173, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
+   { 23195, 0x00008590 }, /* GL_OPERAND0_RGB */
+   { 23211, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
+   { 23231, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
+   { 23251, 0x00008599 }, /* GL_OPERAND1_ALPHA */
+   { 23269, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
+   { 23291, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
+   { 23313, 0x00008591 }, /* GL_OPERAND1_RGB */
+   { 23329, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
+   { 23349, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
+   { 23369, 0x0000859A }, /* GL_OPERAND2_ALPHA */
+   { 23387, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
+   { 23409, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
+   { 23431, 0x00008592 }, /* GL_OPERAND2_RGB */
+   { 23447, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
+   { 23467, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
+   { 23487, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
+   { 23508, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
+   { 23527, 0x00001507 }, /* GL_OR */
+   { 23533, 0x00000A01 }, /* GL_ORDER */
+   { 23542, 0x0000150D }, /* GL_OR_INVERTED */
+   { 23557, 0x0000150B }, /* GL_OR_REVERSE */
+   { 23571, 0x00000505 }, /* GL_OUT_OF_MEMORY */
+   { 23588, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
+   { 23606, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
+   { 23627, 0x00008758 }, /* GL_PACK_INVERT_MESA */
+   { 23647, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
+   { 23665, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
+   { 23684, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
+   { 23704, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
+   { 23724, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
+   { 23742, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
+   { 23761, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
+   { 23786, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
+   { 23810, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
+   { 23831, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
+   { 23853, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
+   { 23875, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
+   { 23900, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
+   { 23924, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
+   { 23945, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
+   { 23967, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
+   { 23989, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
+   { 24011, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
+   { 24042, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
+   { 24062, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+   { 24087, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
+   { 24107, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+   { 24132, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
+   { 24152, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+   { 24177, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
+   { 24197, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+   { 24222, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
+   { 24242, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+   { 24267, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
+   { 24287, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+   { 24312, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
+   { 24332, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+   { 24357, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
+   { 24377, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+   { 24402, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
+   { 24422, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+   { 24447, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
+   { 24467, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+   { 24492, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
+   { 24510, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */
+   { 24531, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */
+   { 24560, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
+   { 24593, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
+   { 24618, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */
+   { 24641, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+   { 24672, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
+   { 24707, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
+   { 24734, 0x00001B00 }, /* GL_POINT */
+   { 24743, 0x00000000 }, /* GL_POINTS */
+   { 24753, 0x00000002 }, /* GL_POINT_BIT */
+   { 24766, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
+   { 24796, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
+   { 24830, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
+   { 24864, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
+   { 24899, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
+   { 24928, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
+   { 24961, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
+   { 24994, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
+   { 25028, 0x00000B11 }, /* GL_POINT_SIZE */
+   { 25042, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
+   { 25068, 0x00008127 }, /* GL_POINT_SIZE_MAX */
+   { 25086, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
+   { 25108, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
+   { 25130, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
+   { 25153, 0x00008126 }, /* GL_POINT_SIZE_MIN */
+   { 25171, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
+   { 25193, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
+   { 25215, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
+   { 25238, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
+   { 25258, 0x00000B10 }, /* GL_POINT_SMOOTH */
+   { 25274, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
+   { 25295, 0x00008861 }, /* GL_POINT_SPRITE */
+   { 25311, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
+   { 25331, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
+   { 25360, 0x00008861 }, /* GL_POINT_SPRITE_NV */
+   { 25379, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
+   { 25405, 0x00000701 }, /* GL_POINT_TOKEN */
+   { 25420, 0x00000009 }, /* GL_POLYGON */
+   { 25431, 0x00000008 }, /* GL_POLYGON_BIT */
+   { 25446, 0x00000B40 }, /* GL_POLYGON_MODE */
+   { 25462, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
+   { 25485, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
+   { 25510, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
+   { 25533, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
+   { 25556, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
+   { 25580, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
+   { 25604, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
+   { 25622, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
+   { 25645, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
+   { 25664, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
+   { 25687, 0x00000703 }, /* GL_POLYGON_TOKEN */
+   { 25704, 0x00001203 }, /* GL_POSITION */
+   { 25716, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+   { 25748, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
+   { 25784, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+   { 25817, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
+   { 25854, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+   { 25885, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
+   { 25920, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+   { 25952, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
+   { 25988, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 26021, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+   { 26053, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
+   { 26089, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+   { 26122, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
+   { 26159, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+   { 26189, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
+   { 26223, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+   { 26254, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
+   { 26289, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+   { 26320, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
+   { 26355, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+   { 26387, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
+   { 26423, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+   { 26453, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
+   { 26487, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+   { 26518, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
+   { 26553, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+   { 26585, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+   { 26616, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
+   { 26651, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+   { 26683, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
+   { 26719, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
+   { 26748, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
+   { 26781, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
+   { 26811, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
+   { 26845, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+   { 26884, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+   { 26917, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+   { 26957, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+   { 26991, 0x00008578 }, /* GL_PREVIOUS */
+   { 27003, 0x00008578 }, /* GL_PREVIOUS_ARB */
+   { 27019, 0x00008578 }, /* GL_PREVIOUS_EXT */
+   { 27035, 0x00008577 }, /* GL_PRIMARY_COLOR */
+   { 27052, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
+   { 27073, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
+   { 27094, 0x00008C87 }, /* GL_PRIMITIVES_GENERATED_EXT */
+   { 27122, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 27155, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 27187, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
+   { 27210, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
+   { 27233, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
+   { 27263, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
+   { 27292, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
+   { 27320, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
+   { 27342, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+   { 27370, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+   { 27398, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
+   { 27420, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
+   { 27441, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 27481, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 27520, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 27550, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 27585, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 27618, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 27652, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 27691, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 27730, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
+   { 27752, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
+   { 27778, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
+   { 27802, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
+   { 27825, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
+   { 27847, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
+   { 27868, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
+   { 27889, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
+   { 27916, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 27948, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 27980, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+   { 28015, 0x00001701 }, /* GL_PROJECTION */
+   { 28029, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
+   { 28050, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
+   { 28076, 0x00008E4F }, /* GL_PROVOKING_VERTEX */
+   { 28096, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */
+   { 28120, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
+   { 28141, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
+   { 28160, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
+   { 28183, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 28222, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+   { 28260, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
+   { 28280, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
+   { 28310, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
+   { 28334, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
+   { 28354, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
+   { 28384, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
+   { 28408, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
+   { 28428, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+   { 28461, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
+   { 28487, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
+   { 28517, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+   { 28548, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
+   { 28578, 0x00008A1D }, /* GL_PURGEABLE_APPLE */
+   { 28597, 0x00002003 }, /* GL_Q */
+   { 28602, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
+   { 28627, 0x00000007 }, /* GL_QUADS */
+   { 28636, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */
+   { 28680, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
+   { 28728, 0x00008614 }, /* GL_QUAD_MESH_SUN */
+   { 28745, 0x00000008 }, /* GL_QUAD_STRIP */
+   { 28759, 0x00008E16 }, /* GL_QUERY_BY_REGION_NO_WAIT_NV */
+   { 28789, 0x00008E15 }, /* GL_QUERY_BY_REGION_WAIT_NV */
+   { 28816, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
+   { 28838, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
+   { 28864, 0x00008E14 }, /* GL_QUERY_NO_WAIT_NV */
+   { 28884, 0x00008866 }, /* GL_QUERY_RESULT */
+   { 28900, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
+   { 28920, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
+   { 28946, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
+   { 28976, 0x00008E13 }, /* GL_QUERY_WAIT_NV */
+   { 28993, 0x00002002 }, /* GL_R */
+   { 28998, 0x00002A10 }, /* GL_R3_G3_B2 */
+   { 29010, 0x00008C89 }, /* GL_RASTERIZER_DISCARD_EXT */
+   { 29036, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+   { 29069, 0x00000C02 }, /* GL_READ_BUFFER */
+   { 29084, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */
+   { 29104, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING */
+   { 29132, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
+   { 29164, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
+   { 29188, 0x000088B8 }, /* GL_READ_ONLY */
+   { 29201, 0x000088B8 }, /* GL_READ_ONLY_ARB */
+   { 29218, 0x000088BA }, /* GL_READ_WRITE */
+   { 29232, 0x000088BA }, /* GL_READ_WRITE_ARB */
+   { 29250, 0x00001903 }, /* GL_RED */
+   { 29257, 0x00008016 }, /* GL_REDUCE */
+   { 29267, 0x00008016 }, /* GL_REDUCE_EXT */
+   { 29281, 0x00000D15 }, /* GL_RED_BIAS */
+   { 29293, 0x00000D52 }, /* GL_RED_BITS */
+   { 29305, 0x00000D14 }, /* GL_RED_SCALE */
+   { 29318, 0x00008512 }, /* GL_REFLECTION_MAP */
+   { 29336, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
+   { 29358, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
+   { 29379, 0x00008A19 }, /* GL_RELEASED_APPLE */
+   { 29397, 0x00001C00 }, /* GL_RENDER */
+   { 29407, 0x00008D41 }, /* GL_RENDERBUFFER */
+   { 29423, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */
+   { 29450, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING */
+   { 29474, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
+   { 29502, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */
+   { 29528, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */
+   { 29555, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
+   { 29575, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */
+   { 29602, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */
+   { 29625, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
+   { 29652, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+   { 29684, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
+   { 29720, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */
+   { 29745, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */
+   { 29769, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES_EXT */
+   { 29797, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */
+   { 29826, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */
+   { 29848, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
+   { 29874, 0x00001F01 }, /* GL_RENDERER */
+   { 29886, 0x00000C40 }, /* GL_RENDER_MODE */
+   { 29901, 0x00002901 }, /* GL_REPEAT */
+   { 29911, 0x00001E01 }, /* GL_REPLACE */
+   { 29922, 0x00008062 }, /* GL_REPLACE_EXT */
+   { 29937, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
+   { 29960, 0x0000803A }, /* GL_RESCALE_NORMAL */
+   { 29978, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
+   { 30000, 0x00008A1B }, /* GL_RETAINED_APPLE */
+   { 30018, 0x00000102 }, /* GL_RETURN */
+   { 30028, 0x00001907 }, /* GL_RGB */
+   { 30035, 0x00008052 }, /* GL_RGB10 */
+   { 30044, 0x00008059 }, /* GL_RGB10_A2 */
+   { 30056, 0x00008059 }, /* GL_RGB10_A2_EXT */
+   { 30072, 0x00008052 }, /* GL_RGB10_EXT */
+   { 30085, 0x00008053 }, /* GL_RGB12 */
+   { 30094, 0x00008053 }, /* GL_RGB12_EXT */
+   { 30107, 0x00008054 }, /* GL_RGB16 */
+   { 30116, 0x00008054 }, /* GL_RGB16_EXT */
+   { 30129, 0x0000804E }, /* GL_RGB2_EXT */
+   { 30141, 0x0000804F }, /* GL_RGB4 */
+   { 30149, 0x0000804F }, /* GL_RGB4_EXT */
+   { 30161, 0x000083A1 }, /* GL_RGB4_S3TC */
+   { 30174, 0x00008050 }, /* GL_RGB5 */
+   { 30182, 0x00008057 }, /* GL_RGB5_A1 */
+   { 30193, 0x00008057 }, /* GL_RGB5_A1_EXT */
+   { 30208, 0x00008050 }, /* GL_RGB5_EXT */
+   { 30220, 0x00008051 }, /* GL_RGB8 */
+   { 30228, 0x00008051 }, /* GL_RGB8_EXT */
+   { 30240, 0x00001908 }, /* GL_RGBA */
+   { 30248, 0x0000805A }, /* GL_RGBA12 */
+   { 30258, 0x0000805A }, /* GL_RGBA12_EXT */
+   { 30272, 0x0000805B }, /* GL_RGBA16 */
+   { 30282, 0x0000805B }, /* GL_RGBA16_EXT */
+   { 30296, 0x00008055 }, /* GL_RGBA2 */
+   { 30305, 0x00008055 }, /* GL_RGBA2_EXT */
+   { 30318, 0x00008056 }, /* GL_RGBA4 */
+   { 30327, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
+   { 30346, 0x00008056 }, /* GL_RGBA4_EXT */
+   { 30359, 0x000083A3 }, /* GL_RGBA4_S3TC */
+   { 30373, 0x00008058 }, /* GL_RGBA8 */
+   { 30382, 0x00008058 }, /* GL_RGBA8_EXT */
+   { 30395, 0x00008F97 }, /* GL_RGBA8_SNORM */
+   { 30410, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
+   { 30428, 0x00000C31 }, /* GL_RGBA_MODE */
+   { 30441, 0x000083A2 }, /* GL_RGBA_S3TC */
+   { 30454, 0x00008F93 }, /* GL_RGBA_SNORM */
+   { 30468, 0x000083A0 }, /* GL_RGB_S3TC */
+   { 30480, 0x00008573 }, /* GL_RGB_SCALE */
+   { 30493, 0x00008573 }, /* GL_RGB_SCALE_ARB */
+   { 30510, 0x00008573 }, /* GL_RGB_SCALE_EXT */
+   { 30527, 0x00000407 }, /* GL_RIGHT */
+   { 30536, 0x00002000 }, /* GL_S */
+   { 30541, 0x00008B5D }, /* GL_SAMPLER_1D */
+   { 30555, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
+   { 30576, 0x00008B5E }, /* GL_SAMPLER_2D */
+   { 30590, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
+   { 30611, 0x00008B5F }, /* GL_SAMPLER_3D */
+   { 30625, 0x00008B60 }, /* GL_SAMPLER_CUBE */
+   { 30641, 0x000080A9 }, /* GL_SAMPLES */
+   { 30652, 0x000086B4 }, /* GL_SAMPLES_3DFX */
+   { 30668, 0x000080A9 }, /* GL_SAMPLES_ARB */
+   { 30683, 0x00008914 }, /* GL_SAMPLES_PASSED */
+   { 30701, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
+   { 30723, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+   { 30751, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
+   { 30783, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
+   { 30806, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
+   { 30833, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
+   { 30851, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
+   { 30874, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
+   { 30896, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
+   { 30915, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
+   { 30938, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
+   { 30964, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
+   { 30994, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
+   { 31019, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
+   { 31048, 0x00080000 }, /* GL_SCISSOR_BIT */
+   { 31063, 0x00000C10 }, /* GL_SCISSOR_BOX */
+   { 31078, 0x00000C11 }, /* GL_SCISSOR_TEST */
+   { 31094, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
+   { 31119, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+   { 31159, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
+   { 31203, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+   { 31236, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+   { 31266, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+   { 31298, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+   { 31328, 0x00001C02 }, /* GL_SELECT */
+   { 31338, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
+   { 31366, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
+   { 31391, 0x00008012 }, /* GL_SEPARABLE_2D */
+   { 31407, 0x00008C8D }, /* GL_SEPARATE_ATTRIBS_EXT */
+   { 31431, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
+   { 31458, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
+   { 31489, 0x0000150F }, /* GL_SET */
+   { 31496, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
+   { 31517, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
+   { 31541, 0x00008B4F }, /* GL_SHADER_TYPE */
+   { 31556, 0x00000B54 }, /* GL_SHADE_MODEL */
+   { 31571, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
+   { 31599, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
+   { 31622, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+   { 31652, 0x00001601 }, /* GL_SHININESS */
+   { 31665, 0x00001402 }, /* GL_SHORT */
+   { 31674, 0x00009119 }, /* GL_SIGNALED */
+   { 31686, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */
+   { 31707, 0x000081F9 }, /* GL_SINGLE_COLOR */
+   { 31723, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
+   { 31743, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
+   { 31762, 0x00008C46 }, /* GL_SLUMINANCE */
+   { 31776, 0x00008C47 }, /* GL_SLUMINANCE8 */
+   { 31791, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */
+   { 31813, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */
+   { 31833, 0x00001D01 }, /* GL_SMOOTH */
+   { 31843, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
+   { 31876, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
+   { 31903, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
+   { 31936, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
+   { 31963, 0x00008588 }, /* GL_SOURCE0_ALPHA */
+   { 31980, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
+   { 32001, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
+   { 32022, 0x00008580 }, /* GL_SOURCE0_RGB */
+   { 32037, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
+   { 32056, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
+   { 32075, 0x00008589 }, /* GL_SOURCE1_ALPHA */
+   { 32092, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
+   { 32113, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
+   { 32134, 0x00008581 }, /* GL_SOURCE1_RGB */
+   { 32149, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
+   { 32168, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
+   { 32187, 0x0000858A }, /* GL_SOURCE2_ALPHA */
+   { 32204, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
+   { 32225, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
+   { 32246, 0x00008582 }, /* GL_SOURCE2_RGB */
+   { 32261, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
+   { 32280, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
+   { 32299, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
+   { 32319, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
+   { 32337, 0x00001202 }, /* GL_SPECULAR */
+   { 32349, 0x00002402 }, /* GL_SPHERE_MAP */
+   { 32363, 0x00001206 }, /* GL_SPOT_CUTOFF */
+   { 32378, 0x00001204 }, /* GL_SPOT_DIRECTION */
+   { 32396, 0x00001205 }, /* GL_SPOT_EXPONENT */
+   { 32413, 0x00008588 }, /* GL_SRC0_ALPHA */
+   { 32427, 0x00008580 }, /* GL_SRC0_RGB */
+   { 32439, 0x00008589 }, /* GL_SRC1_ALPHA */
+   { 32453, 0x00008581 }, /* GL_SRC1_RGB */
+   { 32465, 0x0000858A }, /* GL_SRC2_ALPHA */
+   { 32479, 0x00008582 }, /* GL_SRC2_RGB */
+   { 32491, 0x00000302 }, /* GL_SRC_ALPHA */
+   { 32504, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
+   { 32526, 0x00000300 }, /* GL_SRC_COLOR */
+   { 32539, 0x00008C40 }, /* GL_SRGB */
+   { 32547, 0x00008C41 }, /* GL_SRGB8 */
+   { 32556, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */
+   { 32572, 0x00008C42 }, /* GL_SRGB_ALPHA */
+   { 32586, 0x00000503 }, /* GL_STACK_OVERFLOW */
+   { 32604, 0x00000504 }, /* GL_STACK_UNDERFLOW */
+   { 32623, 0x000088E6 }, /* GL_STATIC_COPY */
+   { 32638, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
+   { 32657, 0x000088E4 }, /* GL_STATIC_DRAW */
+   { 32672, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
+   { 32691, 0x000088E5 }, /* GL_STATIC_READ */
+   { 32706, 0x000088E5 }, /* GL_STATIC_READ_ARB */
+   { 32725, 0x00001802 }, /* GL_STENCIL */
+   { 32736, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */
+   { 32758, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
+   { 32784, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
+   { 32805, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */
+   { 32830, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
+   { 32851, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */
+   { 32876, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+   { 32908, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */
+   { 32944, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+   { 32976, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */
+   { 33012, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
+   { 33032, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
+   { 33059, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
+   { 33085, 0x00000D57 }, /* GL_STENCIL_BITS */
+   { 33101, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
+   { 33123, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
+   { 33146, 0x00000B94 }, /* GL_STENCIL_FAIL */
+   { 33162, 0x00000B92 }, /* GL_STENCIL_FUNC */
+   { 33178, 0x00001901 }, /* GL_STENCIL_INDEX */
+   { 33195, 0x00008D46 }, /* GL_STENCIL_INDEX1 */
+   { 33213, 0x00008D49 }, /* GL_STENCIL_INDEX16 */
+   { 33232, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
+   { 33255, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
+   { 33277, 0x00008D47 }, /* GL_STENCIL_INDEX4 */
+   { 33295, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
+   { 33317, 0x00008D48 }, /* GL_STENCIL_INDEX8 */
+   { 33335, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
+   { 33357, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
+   { 33378, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
+   { 33405, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
+   { 33432, 0x00000B97 }, /* GL_STENCIL_REF */
+   { 33447, 0x00000B90 }, /* GL_STENCIL_TEST */
+   { 33463, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+   { 33492, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
+   { 33514, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
+   { 33535, 0x00000C33 }, /* GL_STEREO */
+   { 33545, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */
+   { 33569, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */
+   { 33594, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */
+   { 33618, 0x000088E2 }, /* GL_STREAM_COPY */
+   { 33633, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
+   { 33652, 0x000088E0 }, /* GL_STREAM_DRAW */
+   { 33667, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
+   { 33686, 0x000088E1 }, /* GL_STREAM_READ */
+   { 33701, 0x000088E1 }, /* GL_STREAM_READ_ARB */
+   { 33720, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
+   { 33737, 0x000084E7 }, /* GL_SUBTRACT */
+   { 33749, 0x000084E7 }, /* GL_SUBTRACT_ARB */
+   { 33765, 0x00009113 }, /* GL_SYNC_CONDITION */
+   { 33783, 0x00009116 }, /* GL_SYNC_FENCE */
+   { 33797, 0x00009115 }, /* GL_SYNC_FLAGS */
+   { 33811, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */
+   { 33838, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+   { 33868, 0x00009114 }, /* GL_SYNC_STATUS */
+   { 33883, 0x00002001 }, /* GL_T */
+   { 33888, 0x00002A2A }, /* GL_T2F_C3F_V3F */
+   { 33903, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
+   { 33922, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
+   { 33938, 0x00002A2B }, /* GL_T2F_N3F_V3F */
+   { 33953, 0x00002A27 }, /* GL_T2F_V3F */
+   { 33964, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
+   { 33983, 0x00002A28 }, /* GL_T4F_V4F */
+   { 33994, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
+   { 34017, 0x00001702 }, /* GL_TEXTURE */
+   { 34028, 0x000084C0 }, /* GL_TEXTURE0 */
+   { 34040, 0x000084C0 }, /* GL_TEXTURE0_ARB */
+   { 34056, 0x000084C1 }, /* GL_TEXTURE1 */
+   { 34068, 0x000084CA }, /* GL_TEXTURE10 */
+   { 34081, 0x000084CA }, /* GL_TEXTURE10_ARB */
+   { 34098, 0x000084CB }, /* GL_TEXTURE11 */
+   { 34111, 0x000084CB }, /* GL_TEXTURE11_ARB */
+   { 34128, 0x000084CC }, /* GL_TEXTURE12 */
+   { 34141, 0x000084CC }, /* GL_TEXTURE12_ARB */
+   { 34158, 0x000084CD }, /* GL_TEXTURE13 */
+   { 34171, 0x000084CD }, /* GL_TEXTURE13_ARB */
+   { 34188, 0x000084CE }, /* GL_TEXTURE14 */
+   { 34201, 0x000084CE }, /* GL_TEXTURE14_ARB */
+   { 34218, 0x000084CF }, /* GL_TEXTURE15 */
+   { 34231, 0x000084CF }, /* GL_TEXTURE15_ARB */
+   { 34248, 0x000084D0 }, /* GL_TEXTURE16 */
+   { 34261, 0x000084D0 }, /* GL_TEXTURE16_ARB */
+   { 34278, 0x000084D1 }, /* GL_TEXTURE17 */
+   { 34291, 0x000084D1 }, /* GL_TEXTURE17_ARB */
+   { 34308, 0x000084D2 }, /* GL_TEXTURE18 */
+   { 34321, 0x000084D2 }, /* GL_TEXTURE18_ARB */
+   { 34338, 0x000084D3 }, /* GL_TEXTURE19 */
+   { 34351, 0x000084D3 }, /* GL_TEXTURE19_ARB */
+   { 34368, 0x000084C1 }, /* GL_TEXTURE1_ARB */
+   { 34384, 0x000084C2 }, /* GL_TEXTURE2 */
+   { 34396, 0x000084D4 }, /* GL_TEXTURE20 */
+   { 34409, 0x000084D4 }, /* GL_TEXTURE20_ARB */
+   { 34426, 0x000084D5 }, /* GL_TEXTURE21 */
+   { 34439, 0x000084D5 }, /* GL_TEXTURE21_ARB */
+   { 34456, 0x000084D6 }, /* GL_TEXTURE22 */
+   { 34469, 0x000084D6 }, /* GL_TEXTURE22_ARB */
+   { 34486, 0x000084D7 }, /* GL_TEXTURE23 */
+   { 34499, 0x000084D7 }, /* GL_TEXTURE23_ARB */
+   { 34516, 0x000084D8 }, /* GL_TEXTURE24 */
+   { 34529, 0x000084D8 }, /* GL_TEXTURE24_ARB */
+   { 34546, 0x000084D9 }, /* GL_TEXTURE25 */
+   { 34559, 0x000084D9 }, /* GL_TEXTURE25_ARB */
+   { 34576, 0x000084DA }, /* GL_TEXTURE26 */
+   { 34589, 0x000084DA }, /* GL_TEXTURE26_ARB */
+   { 34606, 0x000084DB }, /* GL_TEXTURE27 */
+   { 34619, 0x000084DB }, /* GL_TEXTURE27_ARB */
+   { 34636, 0x000084DC }, /* GL_TEXTURE28 */
+   { 34649, 0x000084DC }, /* GL_TEXTURE28_ARB */
+   { 34666, 0x000084DD }, /* GL_TEXTURE29 */
+   { 34679, 0x000084DD }, /* GL_TEXTURE29_ARB */
+   { 34696, 0x000084C2 }, /* GL_TEXTURE2_ARB */
+   { 34712, 0x000084C3 }, /* GL_TEXTURE3 */
+   { 34724, 0x000084DE }, /* GL_TEXTURE30 */
+   { 34737, 0x000084DE }, /* GL_TEXTURE30_ARB */
+   { 34754, 0x000084DF }, /* GL_TEXTURE31 */
+   { 34767, 0x000084DF }, /* GL_TEXTURE31_ARB */
+   { 34784, 0x000084C3 }, /* GL_TEXTURE3_ARB */
+   { 34800, 0x000084C4 }, /* GL_TEXTURE4 */
+   { 34812, 0x000084C4 }, /* GL_TEXTURE4_ARB */
+   { 34828, 0x000084C5 }, /* GL_TEXTURE5 */
+   { 34840, 0x000084C5 }, /* GL_TEXTURE5_ARB */
+   { 34856, 0x000084C6 }, /* GL_TEXTURE6 */
+   { 34868, 0x000084C6 }, /* GL_TEXTURE6_ARB */
+   { 34884, 0x000084C7 }, /* GL_TEXTURE7 */
+   { 34896, 0x000084C7 }, /* GL_TEXTURE7_ARB */
+   { 34912, 0x000084C8 }, /* GL_TEXTURE8 */
+   { 34924, 0x000084C8 }, /* GL_TEXTURE8_ARB */
+   { 34940, 0x000084C9 }, /* GL_TEXTURE9 */
+   { 34952, 0x000084C9 }, /* GL_TEXTURE9_ARB */
+   { 34968, 0x00000DE0 }, /* GL_TEXTURE_1D */
+   { 34982, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
+   { 35006, 0x00000DE1 }, /* GL_TEXTURE_2D */
+   { 35020, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
+   { 35044, 0x0000806F }, /* GL_TEXTURE_3D */
+   { 35058, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
+   { 35080, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
+   { 35106, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
+   { 35128, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
+   { 35150, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
+   { 35182, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
+   { 35204, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
+   { 35236, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
+   { 35258, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
+   { 35286, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
+   { 35318, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+   { 35351, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
+   { 35383, 0x00040000 }, /* GL_TEXTURE_BIT */
+   { 35398, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
+   { 35419, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
+   { 35444, 0x00001005 }, /* GL_TEXTURE_BORDER */
+   { 35462, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
+   { 35486, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+   { 35517, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+   { 35547, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+   { 35577, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+   { 35612, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+   { 35643, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 35681, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
+   { 35708, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+   { 35740, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+   { 35774, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
+   { 35798, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
+   { 35826, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
+   { 35850, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
+   { 35878, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+   { 35911, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
+   { 35935, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
+   { 35957, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
+   { 35979, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
+   { 36005, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
+   { 36039, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+   { 36072, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
+   { 36109, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
+   { 36137, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
+   { 36169, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
+   { 36192, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+   { 36230, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
+   { 36272, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+   { 36303, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+   { 36331, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+   { 36361, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+   { 36389, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
+   { 36409, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
+   { 36433, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+   { 36464, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
+   { 36499, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+   { 36530, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
+   { 36565, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+   { 36596, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
+   { 36631, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+   { 36662, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
+   { 36697, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+   { 36728, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
+   { 36763, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+   { 36794, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
+   { 36829, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+   { 36858, 0x00008071 }, /* GL_TEXTURE_DEPTH */
+   { 36875, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
+   { 36897, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
+   { 36923, 0x00002300 }, /* GL_TEXTURE_ENV */
+   { 36938, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
+   { 36959, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
+   { 36979, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
+   { 37005, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
+   { 37025, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
+   { 37042, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
+   { 37059, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
+   { 37076, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
+   { 37093, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
+   { 37118, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
+   { 37140, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
+   { 37166, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
+   { 37184, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
+   { 37210, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
+   { 37236, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
+   { 37266, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
+   { 37293, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
+   { 37318, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
+   { 37338, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
+   { 37362, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+   { 37389, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+   { 37416, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+   { 37443, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
+   { 37469, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
+   { 37499, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
+   { 37521, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
+   { 37539, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 37569, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+   { 37597, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+   { 37625, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+   { 37653, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
+   { 37674, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
+   { 37693, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
+   { 37715, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
+   { 37734, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
+   { 37754, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+   { 37784, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+   { 37815, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
+   { 37840, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
+   { 37864, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
+   { 37884, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
+   { 37908, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
+   { 37928, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
+   { 37951, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */
+   { 37975, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE_EXT */
+   { 38003, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+   { 38033, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
+   { 38058, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+   { 38092, 0x00001000 }, /* GL_TEXTURE_WIDTH */
+   { 38109, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
+   { 38127, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
+   { 38145, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
+   { 38163, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */
+   { 38182, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
+   { 38202, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
+   { 38221, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+   { 38250, 0x00001000 }, /* GL_TRANSFORM_BIT */
+   { 38267, 0x00008C8F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT */
+   { 38308, 0x00008C8E }, /* GL_TRANSFORM_FEEDBACK_BUFFER_EXT */
+   { 38341, 0x00008C7F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT */
+   { 38379, 0x00008C85 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT */
+   { 38417, 0x00008C84 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT */
+   { 38456, 0x00008C88 }, /* GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT */
+   { 38501, 0x00008C83 }, /* GL_TRANSFORM_FEEDBACK_VARYINGS_EXT */
+   { 38536, 0x00008C76 }, /* GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT */
+   { 38581, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
+   { 38607, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
+   { 38637, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+   { 38669, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+   { 38699, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
+   { 38733, 0x0000862C }, /* GL_TRANSPOSE_NV */
+   { 38749, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+   { 38780, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
+   { 38815, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+   { 38843, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
+   { 38875, 0x00000004 }, /* GL_TRIANGLES */
+   { 38888, 0x00000006 }, /* GL_TRIANGLE_FAN */
+   { 38904, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
+   { 38925, 0x00000005 }, /* GL_TRIANGLE_STRIP */
+   { 38943, 0x00000001 }, /* GL_TRUE */
+   { 38951, 0x00008A1C }, /* GL_UNDEFINED_APPLE */
+   { 38970, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
+   { 38990, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
+   { 39013, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
+   { 39033, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
+   { 39054, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
+   { 39076, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
+   { 39098, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
+   { 39118, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
+   { 39139, 0x00009118 }, /* GL_UNSIGNALED */
+   { 39153, 0x00001401 }, /* GL_UNSIGNED_BYTE */
+   { 39170, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+   { 39197, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
+   { 39220, 0x00001405 }, /* GL_UNSIGNED_INT */
+   { 39236, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
+   { 39263, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */
+   { 39284, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_EXT */
+   { 39309, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
+   { 39333, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+   { 39364, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
+   { 39388, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+   { 39416, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */
+   { 39439, 0x00001403 }, /* GL_UNSIGNED_SHORT */
+   { 39457, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+   { 39487, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+   { 39513, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+   { 39543, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+   { 39569, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
+   { 39593, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+   { 39621, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+   { 39649, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
+   { 39676, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+   { 39708, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
+   { 39739, 0x00008CA2 }, /* GL_UPPER_LEFT */
+   { 39753, 0x00002A20 }, /* GL_V2F */
+   { 39760, 0x00002A21 }, /* GL_V3F */
+   { 39767, 0x00008B83 }, /* GL_VALIDATE_STATUS */
+   { 39786, 0x00001F00 }, /* GL_VENDOR */
+   { 39796, 0x00001F02 }, /* GL_VERSION */
+   { 39807, 0x00008074 }, /* GL_VERTEX_ARRAY */
+   { 39823, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */
+   { 39847, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
+   { 39877, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+   { 39908, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
+   { 39943, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
+   { 39967, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
+   { 39988, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
+   { 40011, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
+   { 40032, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+   { 40059, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+   { 40087, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+   { 40115, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+   { 40143, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+   { 40171, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+   { 40199, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+   { 40227, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+   { 40254, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+   { 40281, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+   { 40308, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+   { 40335, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+   { 40362, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+   { 40389, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+   { 40416, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+   { 40443, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+   { 40470, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+   { 40508, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
+   { 40550, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+   { 40581, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
+   { 40616, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+   { 40650, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
+   { 40688, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+   { 40719, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
+   { 40754, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+   { 40782, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
+   { 40814, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+   { 40844, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
+   { 40878, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+   { 40906, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
+   { 40938, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
+   { 40958, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
+   { 40980, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
+   { 41009, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
+   { 41030, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
+   { 41059, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
+   { 41092, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
+   { 41124, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+   { 41151, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
+   { 41182, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
+   { 41212, 0x00008B31 }, /* GL_VERTEX_SHADER */
+   { 41229, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
+   { 41250, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
+   { 41277, 0x00000BA2 }, /* GL_VIEWPORT */
+   { 41289, 0x00000800 }, /* GL_VIEWPORT_BIT */
+   { 41305, 0x00008A1A }, /* GL_VOLATILE_APPLE */
+   { 41323, 0x0000911D }, /* GL_WAIT_FAILED */
+   { 41338, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
+   { 41358, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+   { 41389, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
+   { 41424, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+   { 41452, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+   { 41477, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+   { 41504, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+   { 41529, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
+   { 41553, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
+   { 41572, 0x000088B9 }, /* GL_WRITE_ONLY */
+   { 41586, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
+   { 41604, 0x00001506 }, /* GL_XOR */
+   { 41611, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
+   { 41630, 0x00008757 }, /* GL_YCBCR_MESA */
+   { 41644, 0x00000000 }, /* GL_ZERO */
+   { 41652, 0x00000D16 }, /* GL_ZOOM_X */
+   { 41662, 0x00000D17 }, /* GL_ZOOM_Y */
 };
 
-static const unsigned reduced_enums[1357] =
+static const unsigned reduced_enums[1372] =
 {
        480, /* GL_FALSE */
-       703, /* GL_LINES */
-       705, /* GL_LINE_LOOP */
-       712, /* GL_LINE_STRIP */
-      1774, /* GL_TRIANGLES */
-      1777, /* GL_TRIANGLE_STRIP */
-      1775, /* GL_TRIANGLE_FAN */
-      1288, /* GL_QUADS */
-      1292, /* GL_QUAD_STRIP */
-      1173, /* GL_POLYGON */
-      1185, /* GL_POLYGON_STIPPLE_BIT */
-      1134, /* GL_PIXEL_MODE_BIT */
-       690, /* GL_LIGHTING_BIT */
+       704, /* GL_LINES */
+       706, /* GL_LINE_LOOP */
+       713, /* GL_LINE_STRIP */
+      1789, /* GL_TRIANGLES */
+      1792, /* GL_TRIANGLE_STRIP */
+      1790, /* GL_TRIANGLE_FAN */
+      1293, /* GL_QUADS */
+      1297, /* GL_QUAD_STRIP */
+      1177, /* GL_POLYGON */
+      1189, /* GL_POLYGON_STIPPLE_BIT */
+      1138, /* GL_PIXEL_MODE_BIT */
+       691, /* GL_LIGHTING_BIT */
        510, /* GL_FOG_BIT */
          8, /* GL_ACCUM */
-       722, /* GL_LOAD */
-      1353, /* GL_RETURN */
-      1006, /* GL_MULT */
+       723, /* GL_LOAD */
+      1359, /* GL_RETURN */
+      1010, /* GL_MULT */
         23, /* GL_ADD */
-      1022, /* GL_NEVER */
-       680, /* GL_LESS */
+      1026, /* GL_NEVER */
+       681, /* GL_LESS */
        470, /* GL_EQUAL */
-       679, /* GL_LEQUAL */
+       680, /* GL_LEQUAL */
        600, /* GL_GREATER */
-      1037, /* GL_NOTEQUAL */
+      1041, /* GL_NOTEQUAL */
        599, /* GL_GEQUAL */
         47, /* GL_ALWAYS */
-      1494, /* GL_SRC_COLOR */
-      1067, /* GL_ONE_MINUS_SRC_COLOR */
-      1492, /* GL_SRC_ALPHA */
-      1066, /* GL_ONE_MINUS_SRC_ALPHA */
+      1501, /* GL_SRC_COLOR */
+      1071, /* GL_ONE_MINUS_SRC_COLOR */
+      1499, /* GL_SRC_ALPHA */
+      1070, /* GL_ONE_MINUS_SRC_ALPHA */
        449, /* GL_DST_ALPHA */
-      1064, /* GL_ONE_MINUS_DST_ALPHA */
+      1068, /* GL_ONE_MINUS_DST_ALPHA */
        450, /* GL_DST_COLOR */
-      1065, /* GL_ONE_MINUS_DST_COLOR */
-      1493, /* GL_SRC_ALPHA_SATURATE */
+      1069, /* GL_ONE_MINUS_DST_COLOR */
+      1500, /* GL_SRC_ALPHA_SATURATE */
        587, /* GL_FRONT_LEFT */
        588, /* GL_FRONT_RIGHT */
         69, /* GL_BACK_LEFT */
         70, /* GL_BACK_RIGHT */
        584, /* GL_FRONT */
         68, /* GL_BACK */
-       678, /* GL_LEFT */
-      1395, /* GL_RIGHT */
+       679, /* GL_LEFT */
+      1401, /* GL_RIGHT */
        585, /* GL_FRONT_AND_BACK */
         63, /* GL_AUX0 */
         64, /* GL_AUX1 */
         65, /* GL_AUX2 */
         66, /* GL_AUX3 */
-       667, /* GL_INVALID_ENUM */
-       671, /* GL_INVALID_VALUE */
-       670, /* GL_INVALID_OPERATION */
-      1499, /* GL_STACK_OVERFLOW */
-      1500, /* GL_STACK_UNDERFLOW */
-      1092, /* GL_OUT_OF_MEMORY */
-       668, /* GL_INVALID_FRAMEBUFFER_OPERATION */
+       668, /* GL_INVALID_ENUM */
+       672, /* GL_INVALID_VALUE */
+       671, /* GL_INVALID_OPERATION */
+      1506, /* GL_STACK_OVERFLOW */
+      1507, /* GL_STACK_UNDERFLOW */
+      1096, /* GL_OUT_OF_MEMORY */
+       669, /* GL_INVALID_FRAMEBUFFER_OPERATION */
          0, /* GL_2D */
          2, /* GL_3D */
          3, /* GL_3D_COLOR */
          4, /* GL_3D_COLOR_TEXTURE */
          6, /* GL_4D_COLOR_TEXTURE */
-      1112, /* GL_PASS_THROUGH_TOKEN */
-      1172, /* GL_POINT_TOKEN */
-       713, /* GL_LINE_TOKEN */
-      1186, /* GL_POLYGON_TOKEN */
+      1116, /* GL_PASS_THROUGH_TOKEN */
+      1176, /* GL_POINT_TOKEN */
+       714, /* GL_LINE_TOKEN */
+      1190, /* GL_POLYGON_TOKEN */
         74, /* GL_BITMAP_TOKEN */
        448, /* GL_DRAW_PIXEL_TOKEN */
        302, /* GL_COPY_PIXEL_TOKEN */
-       706, /* GL_LINE_RESET_TOKEN */
+       707, /* GL_LINE_RESET_TOKEN */
        473, /* GL_EXP */
        474, /* GL_EXP2 */
        338, /* GL_CW */
        126, /* GL_CCW */
        147, /* GL_COEFF */
-      1089, /* GL_ORDER */
+      1093, /* GL_ORDER */
        385, /* GL_DOMAIN */
        312, /* GL_CURRENT_COLOR */
        315, /* GL_CURRENT_INDEX */
@@ -3912,33 +3942,33 @@ static const unsigned reduced_enums[1357] =
        329, /* GL_CURRENT_RASTER_POSITION */
        330, /* GL_CURRENT_RASTER_POSITION_VALID */
        327, /* GL_CURRENT_RASTER_DISTANCE */
-      1165, /* GL_POINT_SMOOTH */
-      1154, /* GL_POINT_SIZE */
-      1164, /* GL_POINT_SIZE_RANGE */
-      1155, /* GL_POINT_SIZE_GRANULARITY */
-       707, /* GL_LINE_SMOOTH */
-       714, /* GL_LINE_WIDTH */
-       716, /* GL_LINE_WIDTH_RANGE */
-       715, /* GL_LINE_WIDTH_GRANULARITY */
-       709, /* GL_LINE_STIPPLE */
-       710, /* GL_LINE_STIPPLE_PATTERN */
-       711, /* GL_LINE_STIPPLE_REPEAT */
-       721, /* GL_LIST_MODE */
-       887, /* GL_MAX_LIST_NESTING */
-       718, /* GL_LIST_BASE */
-       720, /* GL_LIST_INDEX */
-      1175, /* GL_POLYGON_MODE */
-      1182, /* GL_POLYGON_SMOOTH */
-      1184, /* GL_POLYGON_STIPPLE */
+      1169, /* GL_POINT_SMOOTH */
+      1158, /* GL_POINT_SIZE */
+      1168, /* GL_POINT_SIZE_RANGE */
+      1159, /* GL_POINT_SIZE_GRANULARITY */
+       708, /* GL_LINE_SMOOTH */
+       715, /* GL_LINE_WIDTH */
+       717, /* GL_LINE_WIDTH_RANGE */
+       716, /* GL_LINE_WIDTH_GRANULARITY */
+       710, /* GL_LINE_STIPPLE */
+       711, /* GL_LINE_STIPPLE_PATTERN */
+       712, /* GL_LINE_STIPPLE_REPEAT */
+       722, /* GL_LIST_MODE */
+       888, /* GL_MAX_LIST_NESTING */
+       719, /* GL_LIST_BASE */
+       721, /* GL_LIST_INDEX */
+      1179, /* GL_POLYGON_MODE */
+      1186, /* GL_POLYGON_SMOOTH */
+      1188, /* GL_POLYGON_STIPPLE */
        459, /* GL_EDGE_FLAG */
        305, /* GL_CULL_FACE */
        306, /* GL_CULL_FACE_MODE */
        586, /* GL_FRONT_FACE */
-       689, /* GL_LIGHTING */
-       694, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-       695, /* GL_LIGHT_MODEL_TWO_SIDE */
-       691, /* GL_LIGHT_MODEL_AMBIENT */
-      1441, /* GL_SHADE_MODEL */
+       690, /* GL_LIGHTING */
+       695, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+       696, /* GL_LIGHT_MODEL_TWO_SIDE */
+       692, /* GL_LIGHT_MODEL_AMBIENT */
+      1448, /* GL_SHADE_MODEL */
        194, /* GL_COLOR_MATERIAL_FACE */
        195, /* GL_COLOR_MATERIAL_PARAMETER */
        193, /* GL_COLOR_MATERIAL */
@@ -3955,24 +3985,24 @@ static const unsigned reduced_enums[1357] =
        359, /* GL_DEPTH_CLEAR_VALUE */
        370, /* GL_DEPTH_FUNC */
         12, /* GL_ACCUM_CLEAR_VALUE */
-      1539, /* GL_STENCIL_TEST */
-      1523, /* GL_STENCIL_CLEAR_VALUE */
-      1525, /* GL_STENCIL_FUNC */
-      1541, /* GL_STENCIL_VALUE_MASK */
-      1524, /* GL_STENCIL_FAIL */
-      1536, /* GL_STENCIL_PASS_DEPTH_FAIL */
-      1537, /* GL_STENCIL_PASS_DEPTH_PASS */
-      1538, /* GL_STENCIL_REF */
-      1542, /* GL_STENCIL_WRITEMASK */
-       855, /* GL_MATRIX_MODE */
-      1027, /* GL_NORMALIZE */
-      1870, /* GL_VIEWPORT */
-      1001, /* GL_MODELVIEW_STACK_DEPTH */
-      1265, /* GL_PROJECTION_STACK_DEPTH */
-      1749, /* GL_TEXTURE_STACK_DEPTH */
-       999, /* GL_MODELVIEW_MATRIX */
-      1264, /* GL_PROJECTION_MATRIX */
-      1732, /* GL_TEXTURE_MATRIX */
+      1546, /* GL_STENCIL_TEST */
+      1530, /* GL_STENCIL_CLEAR_VALUE */
+      1532, /* GL_STENCIL_FUNC */
+      1548, /* GL_STENCIL_VALUE_MASK */
+      1531, /* GL_STENCIL_FAIL */
+      1543, /* GL_STENCIL_PASS_DEPTH_FAIL */
+      1544, /* GL_STENCIL_PASS_DEPTH_PASS */
+      1545, /* GL_STENCIL_REF */
+      1549, /* GL_STENCIL_WRITEMASK */
+       856, /* GL_MATRIX_MODE */
+      1031, /* GL_NORMALIZE */
+      1885, /* GL_VIEWPORT */
+      1005, /* GL_MODELVIEW_STACK_DEPTH */
+      1270, /* GL_PROJECTION_STACK_DEPTH */
+      1756, /* GL_TEXTURE_STACK_DEPTH */
+      1003, /* GL_MODELVIEW_MATRIX */
+      1269, /* GL_PROJECTION_MATRIX */
+      1739, /* GL_TEXTURE_MATRIX */
         61, /* GL_ATTRIB_STACK_DEPTH */
        137, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
         43, /* GL_ALPHA_TEST */
@@ -3982,72 +4012,72 @@ static const unsigned reduced_enums[1357] =
         78, /* GL_BLEND_DST */
         87, /* GL_BLEND_SRC */
         75, /* GL_BLEND */
-       724, /* GL_LOGIC_OP_MODE */
+       725, /* GL_LOGIC_OP_MODE */
        641, /* GL_INDEX_LOGIC_OP */
        192, /* GL_COLOR_LOGIC_OP */
         67, /* GL_AUX_BUFFERS */
        395, /* GL_DRAW_BUFFER */
-      1306, /* GL_READ_BUFFER */
-      1422, /* GL_SCISSOR_BOX */
-      1423, /* GL_SCISSOR_TEST */
+      1312, /* GL_READ_BUFFER */
+      1428, /* GL_SCISSOR_BOX */
+      1429, /* GL_SCISSOR_TEST */
        640, /* GL_INDEX_CLEAR_VALUE */
        645, /* GL_INDEX_WRITEMASK */
        189, /* GL_COLOR_CLEAR_VALUE */
        231, /* GL_COLOR_WRITEMASK */
        642, /* GL_INDEX_MODE */
-      1388, /* GL_RGBA_MODE */
+      1394, /* GL_RGBA_MODE */
        394, /* GL_DOUBLEBUFFER */
-      1543, /* GL_STEREO */
-      1345, /* GL_RENDER_MODE */
-      1113, /* GL_PERSPECTIVE_CORRECTION_HINT */
-      1166, /* GL_POINT_SMOOTH_HINT */
-       708, /* GL_LINE_SMOOTH_HINT */
-      1183, /* GL_POLYGON_SMOOTH_HINT */
+      1550, /* GL_STEREO */
+      1351, /* GL_RENDER_MODE */
+      1117, /* GL_PERSPECTIVE_CORRECTION_HINT */
+      1170, /* GL_POINT_SMOOTH_HINT */
+       709, /* GL_LINE_SMOOTH_HINT */
+      1187, /* GL_POLYGON_SMOOTH_HINT */
        530, /* GL_FOG_HINT */
-      1713, /* GL_TEXTURE_GEN_S */
-      1714, /* GL_TEXTURE_GEN_T */
-      1712, /* GL_TEXTURE_GEN_R */
-      1711, /* GL_TEXTURE_GEN_Q */
-      1126, /* GL_PIXEL_MAP_I_TO_I */
-      1132, /* GL_PIXEL_MAP_S_TO_S */
-      1128, /* GL_PIXEL_MAP_I_TO_R */
-      1124, /* GL_PIXEL_MAP_I_TO_G */
-      1122, /* GL_PIXEL_MAP_I_TO_B */
-      1120, /* GL_PIXEL_MAP_I_TO_A */
-      1130, /* GL_PIXEL_MAP_R_TO_R */
-      1118, /* GL_PIXEL_MAP_G_TO_G */
-      1116, /* GL_PIXEL_MAP_B_TO_B */
-      1114, /* GL_PIXEL_MAP_A_TO_A */
-      1127, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-      1133, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-      1129, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-      1125, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-      1123, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-      1121, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-      1131, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-      1119, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-      1117, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-      1115, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-      1787, /* GL_UNPACK_SWAP_BYTES */
-      1782, /* GL_UNPACK_LSB_FIRST */
-      1783, /* GL_UNPACK_ROW_LENGTH */
-      1786, /* GL_UNPACK_SKIP_ROWS */
-      1785, /* GL_UNPACK_SKIP_PIXELS */
-      1780, /* GL_UNPACK_ALIGNMENT */
-      1101, /* GL_PACK_SWAP_BYTES */
-      1096, /* GL_PACK_LSB_FIRST */
-      1097, /* GL_PACK_ROW_LENGTH */
-      1100, /* GL_PACK_SKIP_ROWS */
-      1099, /* GL_PACK_SKIP_PIXELS */
-      1093, /* GL_PACK_ALIGNMENT */
-       802, /* GL_MAP_COLOR */
-       807, /* GL_MAP_STENCIL */
+      1720, /* GL_TEXTURE_GEN_S */
+      1721, /* GL_TEXTURE_GEN_T */
+      1719, /* GL_TEXTURE_GEN_R */
+      1718, /* GL_TEXTURE_GEN_Q */
+      1130, /* GL_PIXEL_MAP_I_TO_I */
+      1136, /* GL_PIXEL_MAP_S_TO_S */
+      1132, /* GL_PIXEL_MAP_I_TO_R */
+      1128, /* GL_PIXEL_MAP_I_TO_G */
+      1126, /* GL_PIXEL_MAP_I_TO_B */
+      1124, /* GL_PIXEL_MAP_I_TO_A */
+      1134, /* GL_PIXEL_MAP_R_TO_R */
+      1122, /* GL_PIXEL_MAP_G_TO_G */
+      1120, /* GL_PIXEL_MAP_B_TO_B */
+      1118, /* GL_PIXEL_MAP_A_TO_A */
+      1131, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+      1137, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+      1133, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+      1129, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+      1127, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+      1125, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+      1135, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+      1123, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+      1121, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+      1119, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+      1802, /* GL_UNPACK_SWAP_BYTES */
+      1797, /* GL_UNPACK_LSB_FIRST */
+      1798, /* GL_UNPACK_ROW_LENGTH */
+      1801, /* GL_UNPACK_SKIP_ROWS */
+      1800, /* GL_UNPACK_SKIP_PIXELS */
+      1795, /* GL_UNPACK_ALIGNMENT */
+      1105, /* GL_PACK_SWAP_BYTES */
+      1100, /* GL_PACK_LSB_FIRST */
+      1101, /* GL_PACK_ROW_LENGTH */
+      1104, /* GL_PACK_SKIP_ROWS */
+      1103, /* GL_PACK_SKIP_PIXELS */
+      1097, /* GL_PACK_ALIGNMENT */
+       803, /* GL_MAP_COLOR */
+       808, /* GL_MAP_STENCIL */
        644, /* GL_INDEX_SHIFT */
        643, /* GL_INDEX_OFFSET */
-      1320, /* GL_RED_SCALE */
-      1318, /* GL_RED_BIAS */
-      1889, /* GL_ZOOM_X */
-      1890, /* GL_ZOOM_Y */
+      1326, /* GL_RED_SCALE */
+      1324, /* GL_RED_BIAS */
+      1904, /* GL_ZOOM_X */
+      1905, /* GL_ZOOM_Y */
        604, /* GL_GREEN_SCALE */
        602, /* GL_GREEN_BIAS */
         93, /* GL_BLUE_SCALE */
@@ -4056,87 +4086,87 @@ static const unsigned reduced_enums[1357] =
         40, /* GL_ALPHA_BIAS */
        372, /* GL_DEPTH_SCALE */
        352, /* GL_DEPTH_BIAS */
-       882, /* GL_MAX_EVAL_ORDER */
-       886, /* GL_MAX_LIGHTS */
-       864, /* GL_MAX_CLIP_PLANES */
-       934, /* GL_MAX_TEXTURE_SIZE */
-       892, /* GL_MAX_PIXEL_MAP_TABLE */
-       860, /* GL_MAX_ATTRIB_STACK_DEPTH */
-       889, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-       890, /* GL_MAX_NAME_STACK_DEPTH */
-       918, /* GL_MAX_PROJECTION_STACK_DEPTH */
-       935, /* GL_MAX_TEXTURE_STACK_DEPTH */
-       949, /* GL_MAX_VIEWPORT_DIMS */
-       861, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-      1553, /* GL_SUBPIXEL_BITS */
+       883, /* GL_MAX_EVAL_ORDER */
+       887, /* GL_MAX_LIGHTS */
+       865, /* GL_MAX_CLIP_PLANES */
+       935, /* GL_MAX_TEXTURE_SIZE */
+       893, /* GL_MAX_PIXEL_MAP_TABLE */
+       861, /* GL_MAX_ATTRIB_STACK_DEPTH */
+       890, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+       891, /* GL_MAX_NAME_STACK_DEPTH */
+       919, /* GL_MAX_PROJECTION_STACK_DEPTH */
+       936, /* GL_MAX_TEXTURE_STACK_DEPTH */
+       953, /* GL_MAX_VIEWPORT_DIMS */
+       862, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+      1560, /* GL_SUBPIXEL_BITS */
        639, /* GL_INDEX_BITS */
-      1319, /* GL_RED_BITS */
+      1325, /* GL_RED_BITS */
        603, /* GL_GREEN_BITS */
         92, /* GL_BLUE_BITS */
         41, /* GL_ALPHA_BITS */
        353, /* GL_DEPTH_BITS */
-      1521, /* GL_STENCIL_BITS */
+      1528, /* GL_STENCIL_BITS */
         14, /* GL_ACCUM_RED_BITS */
         13, /* GL_ACCUM_GREEN_BITS */
         10, /* GL_ACCUM_BLUE_BITS */
          9, /* GL_ACCUM_ALPHA_BITS */
-      1015, /* GL_NAME_STACK_DEPTH */
+      1019, /* GL_NAME_STACK_DEPTH */
         62, /* GL_AUTO_NORMAL */
-       748, /* GL_MAP1_COLOR_4 */
-       751, /* GL_MAP1_INDEX */
-       752, /* GL_MAP1_NORMAL */
-       753, /* GL_MAP1_TEXTURE_COORD_1 */
-       754, /* GL_MAP1_TEXTURE_COORD_2 */
-       755, /* GL_MAP1_TEXTURE_COORD_3 */
-       756, /* GL_MAP1_TEXTURE_COORD_4 */
-       757, /* GL_MAP1_VERTEX_3 */
-       758, /* GL_MAP1_VERTEX_4 */
-       775, /* GL_MAP2_COLOR_4 */
-       778, /* GL_MAP2_INDEX */
-       779, /* GL_MAP2_NORMAL */
-       780, /* GL_MAP2_TEXTURE_COORD_1 */
-       781, /* GL_MAP2_TEXTURE_COORD_2 */
-       782, /* GL_MAP2_TEXTURE_COORD_3 */
-       783, /* GL_MAP2_TEXTURE_COORD_4 */
-       784, /* GL_MAP2_VERTEX_3 */
-       785, /* GL_MAP2_VERTEX_4 */
-       749, /* GL_MAP1_GRID_DOMAIN */
-       750, /* GL_MAP1_GRID_SEGMENTS */
-       776, /* GL_MAP2_GRID_DOMAIN */
-       777, /* GL_MAP2_GRID_SEGMENTS */
-      1636, /* GL_TEXTURE_1D */
-      1638, /* GL_TEXTURE_2D */
+       749, /* GL_MAP1_COLOR_4 */
+       752, /* GL_MAP1_INDEX */
+       753, /* GL_MAP1_NORMAL */
+       754, /* GL_MAP1_TEXTURE_COORD_1 */
+       755, /* GL_MAP1_TEXTURE_COORD_2 */
+       756, /* GL_MAP1_TEXTURE_COORD_3 */
+       757, /* GL_MAP1_TEXTURE_COORD_4 */
+       758, /* GL_MAP1_VERTEX_3 */
+       759, /* GL_MAP1_VERTEX_4 */
+       776, /* GL_MAP2_COLOR_4 */
+       779, /* GL_MAP2_INDEX */
+       780, /* GL_MAP2_NORMAL */
+       781, /* GL_MAP2_TEXTURE_COORD_1 */
+       782, /* GL_MAP2_TEXTURE_COORD_2 */
+       783, /* GL_MAP2_TEXTURE_COORD_3 */
+       784, /* GL_MAP2_TEXTURE_COORD_4 */
+       785, /* GL_MAP2_VERTEX_3 */
+       786, /* GL_MAP2_VERTEX_4 */
+       750, /* GL_MAP1_GRID_DOMAIN */
+       751, /* GL_MAP1_GRID_SEGMENTS */
+       777, /* GL_MAP2_GRID_DOMAIN */
+       778, /* GL_MAP2_GRID_SEGMENTS */
+      1643, /* GL_TEXTURE_1D */
+      1645, /* GL_TEXTURE_2D */
        483, /* GL_FEEDBACK_BUFFER_POINTER */
        484, /* GL_FEEDBACK_BUFFER_SIZE */
        485, /* GL_FEEDBACK_BUFFER_TYPE */
-      1432, /* GL_SELECTION_BUFFER_POINTER */
-      1433, /* GL_SELECTION_BUFFER_SIZE */
-      1755, /* GL_TEXTURE_WIDTH */
-      1718, /* GL_TEXTURE_HEIGHT */
-      1673, /* GL_TEXTURE_COMPONENTS */
-      1657, /* GL_TEXTURE_BORDER_COLOR */
-      1656, /* GL_TEXTURE_BORDER */
+      1438, /* GL_SELECTION_BUFFER_POINTER */
+      1439, /* GL_SELECTION_BUFFER_SIZE */
+      1762, /* GL_TEXTURE_WIDTH */
+      1725, /* GL_TEXTURE_HEIGHT */
+      1680, /* GL_TEXTURE_COMPONENTS */
+      1664, /* GL_TEXTURE_BORDER_COLOR */
+      1663, /* GL_TEXTURE_BORDER */
        386, /* GL_DONT_CARE */
        481, /* GL_FASTEST */
-      1023, /* GL_NICEST */
+      1027, /* GL_NICEST */
         48, /* GL_AMBIENT */
        383, /* GL_DIFFUSE */
-      1481, /* GL_SPECULAR */
-      1187, /* GL_POSITION */
-      1484, /* GL_SPOT_DIRECTION */
-      1485, /* GL_SPOT_EXPONENT */
-      1483, /* GL_SPOT_CUTOFF */
+      1488, /* GL_SPECULAR */
+      1191, /* GL_POSITION */
+      1491, /* GL_SPOT_DIRECTION */
+      1492, /* GL_SPOT_EXPONENT */
+      1490, /* GL_SPOT_CUTOFF */
        276, /* GL_CONSTANT_ATTENUATION */
-       698, /* GL_LINEAR_ATTENUATION */
-      1287, /* GL_QUADRATIC_ATTENUATION */
+       699, /* GL_LINEAR_ATTENUATION */
+      1292, /* GL_QUADRATIC_ATTENUATION */
        245, /* GL_COMPILE */
        246, /* GL_COMPILE_AND_EXECUTE */
        121, /* GL_BYTE */
-      1789, /* GL_UNSIGNED_BYTE */
-      1446, /* GL_SHORT */
-      1801, /* GL_UNSIGNED_SHORT */
+      1804, /* GL_UNSIGNED_BYTE */
+      1453, /* GL_SHORT */
+      1816, /* GL_UNSIGNED_SHORT */
        647, /* GL_INT */
-      1792, /* GL_UNSIGNED_INT */
+      1807, /* GL_UNSIGNED_INT */
        490, /* GL_FLOAT */
          1, /* GL_2_BYTES */
          5, /* GL_3_BYTES */
@@ -4148,148 +4178,148 @@ static const unsigned reduced_enums[1357] =
         52, /* GL_AND_REVERSE */
        300, /* GL_COPY */
         51, /* GL_AND_INVERTED */
-      1025, /* GL_NOOP */
-      1885, /* GL_XOR */
-      1088, /* GL_OR */
-      1026, /* GL_NOR */
+      1029, /* GL_NOOP */
+      1900, /* GL_XOR */
+      1092, /* GL_OR */
+      1030, /* GL_NOR */
        471, /* GL_EQUIV */
-       674, /* GL_INVERT */
-      1091, /* GL_OR_REVERSE */
+       675, /* GL_INVERT */
+      1095, /* GL_OR_REVERSE */
        301, /* GL_COPY_INVERTED */
-      1090, /* GL_OR_INVERTED */
-      1016, /* GL_NAND */
-      1437, /* GL_SET */
+      1094, /* GL_OR_INVERTED */
+      1020, /* GL_NAND */
+      1444, /* GL_SET */
        468, /* GL_EMISSION */
-      1445, /* GL_SHININESS */
+      1452, /* GL_SHININESS */
         49, /* GL_AMBIENT_AND_DIFFUSE */
        191, /* GL_COLOR_INDEXES */
-       966, /* GL_MODELVIEW */
-      1263, /* GL_PROJECTION */
-      1571, /* GL_TEXTURE */
+       970, /* GL_MODELVIEW */
+      1268, /* GL_PROJECTION */
+      1578, /* GL_TEXTURE */
        148, /* GL_COLOR */
        347, /* GL_DEPTH */
-      1507, /* GL_STENCIL */
+      1514, /* GL_STENCIL */
        190, /* GL_COLOR_INDEX */
-      1526, /* GL_STENCIL_INDEX */
+      1533, /* GL_STENCIL_INDEX */
        360, /* GL_DEPTH_COMPONENT */
-      1315, /* GL_RED */
+      1321, /* GL_RED */
        601, /* GL_GREEN */
         90, /* GL_BLUE */
         31, /* GL_ALPHA */
-      1354, /* GL_RGB */
-      1373, /* GL_RGBA */
-       726, /* GL_LUMINANCE */
-       747, /* GL_LUMINANCE_ALPHA */
+      1360, /* GL_RGB */
+      1379, /* GL_RGBA */
+       727, /* GL_LUMINANCE */
+       748, /* GL_LUMINANCE_ALPHA */
         73, /* GL_BITMAP */
-      1143, /* GL_POINT */
-       696, /* GL_LINE */
+      1147, /* GL_POINT */
+       697, /* GL_LINE */
        486, /* GL_FILL */
-      1325, /* GL_RENDER */
+      1331, /* GL_RENDER */
        482, /* GL_FEEDBACK */
-      1431, /* GL_SELECT */
+      1437, /* GL_SELECT */
        489, /* GL_FLAT */
-      1456, /* GL_SMOOTH */
-       675, /* GL_KEEP */
-      1347, /* GL_REPLACE */
+      1463, /* GL_SMOOTH */
+       676, /* GL_KEEP */
+      1353, /* GL_REPLACE */
        629, /* GL_INCR */
        343, /* GL_DECR */
-      1816, /* GL_VENDOR */
-      1344, /* GL_RENDERER */
-      1817, /* GL_VERSION */
+      1831, /* GL_VENDOR */
+      1350, /* GL_RENDERER */
+      1832, /* GL_VERSION */
        475, /* GL_EXTENSIONS */
-      1396, /* GL_S */
-      1562, /* GL_T */
-      1303, /* GL_R */
-      1286, /* GL_Q */
-      1002, /* GL_MODULATE */
+      1402, /* GL_S */
+      1569, /* GL_T */
+      1308, /* GL_R */
+      1291, /* GL_Q */
+      1006, /* GL_MODULATE */
        342, /* GL_DECAL */
-      1708, /* GL_TEXTURE_ENV_MODE */
-      1707, /* GL_TEXTURE_ENV_COLOR */
-      1706, /* GL_TEXTURE_ENV */
+      1715, /* GL_TEXTURE_ENV_MODE */
+      1714, /* GL_TEXTURE_ENV_COLOR */
+      1713, /* GL_TEXTURE_ENV */
        476, /* GL_EYE_LINEAR */
-      1049, /* GL_OBJECT_LINEAR */
-      1482, /* GL_SPHERE_MAP */
-      1710, /* GL_TEXTURE_GEN_MODE */
-      1051, /* GL_OBJECT_PLANE */
+      1053, /* GL_OBJECT_LINEAR */
+      1489, /* GL_SPHERE_MAP */
+      1717, /* GL_TEXTURE_GEN_MODE */
+      1055, /* GL_OBJECT_PLANE */
        477, /* GL_EYE_PLANE */
-      1017, /* GL_NEAREST */
-       697, /* GL_LINEAR */
-      1021, /* GL_NEAREST_MIPMAP_NEAREST */
-       702, /* GL_LINEAR_MIPMAP_NEAREST */
-      1020, /* GL_NEAREST_MIPMAP_LINEAR */
-       701, /* GL_LINEAR_MIPMAP_LINEAR */
-      1731, /* GL_TEXTURE_MAG_FILTER */
-      1739, /* GL_TEXTURE_MIN_FILTER */
-      1757, /* GL_TEXTURE_WRAP_S */
-      1758, /* GL_TEXTURE_WRAP_T */
+      1021, /* GL_NEAREST */
+       698, /* GL_LINEAR */
+      1025, /* GL_NEAREST_MIPMAP_NEAREST */
+       703, /* GL_LINEAR_MIPMAP_NEAREST */
+      1024, /* GL_NEAREST_MIPMAP_LINEAR */
+       702, /* GL_LINEAR_MIPMAP_LINEAR */
+      1738, /* GL_TEXTURE_MAG_FILTER */
+      1746, /* GL_TEXTURE_MIN_FILTER */
+      1764, /* GL_TEXTURE_WRAP_S */
+      1765, /* GL_TEXTURE_WRAP_T */
        127, /* GL_CLAMP */
-      1346, /* GL_REPEAT */
-      1181, /* GL_POLYGON_OFFSET_UNITS */
-      1180, /* GL_POLYGON_OFFSET_POINT */
-      1179, /* GL_POLYGON_OFFSET_LINE */
-      1304, /* GL_R3_G3_B2 */
-      1813, /* GL_V2F */
-      1814, /* GL_V3F */
+      1352, /* GL_REPEAT */
+      1185, /* GL_POLYGON_OFFSET_UNITS */
+      1184, /* GL_POLYGON_OFFSET_POINT */
+      1183, /* GL_POLYGON_OFFSET_LINE */
+      1309, /* GL_R3_G3_B2 */
+      1828, /* GL_V2F */
+      1829, /* GL_V3F */
        124, /* GL_C4UB_V2F */
        125, /* GL_C4UB_V3F */
        122, /* GL_C3F_V3F */
-      1014, /* GL_N3F_V3F */
+      1018, /* GL_N3F_V3F */
        123, /* GL_C4F_N3F_V3F */
-      1567, /* GL_T2F_V3F */
-      1569, /* GL_T4F_V4F */
-      1565, /* GL_T2F_C4UB_V3F */
-      1563, /* GL_T2F_C3F_V3F */
-      1566, /* GL_T2F_N3F_V3F */
-      1564, /* GL_T2F_C4F_N3F_V3F */
-      1568, /* GL_T4F_C4F_N3F_V4F */
+      1574, /* GL_T2F_V3F */
+      1576, /* GL_T4F_V4F */
+      1572, /* GL_T2F_C4UB_V3F */
+      1570, /* GL_T2F_C3F_V3F */
+      1573, /* GL_T2F_N3F_V3F */
+      1571, /* GL_T2F_C4F_N3F_V3F */
+      1575, /* GL_T4F_C4F_N3F_V4F */
        140, /* GL_CLIP_PLANE0 */
        141, /* GL_CLIP_PLANE1 */
        142, /* GL_CLIP_PLANE2 */
        143, /* GL_CLIP_PLANE3 */
        144, /* GL_CLIP_PLANE4 */
        145, /* GL_CLIP_PLANE5 */
-       681, /* GL_LIGHT0 */
-       682, /* GL_LIGHT1 */
-       683, /* GL_LIGHT2 */
-       684, /* GL_LIGHT3 */
-       685, /* GL_LIGHT4 */
-       686, /* GL_LIGHT5 */
-       687, /* GL_LIGHT6 */
-       688, /* GL_LIGHT7 */
+       682, /* GL_LIGHT0 */
+       683, /* GL_LIGHT1 */
+       684, /* GL_LIGHT2 */
+       685, /* GL_LIGHT3 */
+       686, /* GL_LIGHT4 */
+       687, /* GL_LIGHT5 */
+       688, /* GL_LIGHT6 */
+       689, /* GL_LIGHT7 */
        606, /* GL_HINT_BIT */
        278, /* GL_CONSTANT_COLOR */
-      1062, /* GL_ONE_MINUS_CONSTANT_COLOR */
+      1066, /* GL_ONE_MINUS_CONSTANT_COLOR */
        273, /* GL_CONSTANT_ALPHA */
-      1060, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+      1064, /* GL_ONE_MINUS_CONSTANT_ALPHA */
         76, /* GL_BLEND_COLOR */
        589, /* GL_FUNC_ADD */
-       950, /* GL_MIN */
-       857, /* GL_MAX */
+       954, /* GL_MIN */
+       858, /* GL_MAX */
         81, /* GL_BLEND_EQUATION */
        593, /* GL_FUNC_SUBTRACT */
        591, /* GL_FUNC_REVERSE_SUBTRACT */
        281, /* GL_CONVOLUTION_1D */
        282, /* GL_CONVOLUTION_2D */
-      1434, /* GL_SEPARABLE_2D */
+      1440, /* GL_SEPARABLE_2D */
        285, /* GL_CONVOLUTION_BORDER_MODE */
        289, /* GL_CONVOLUTION_FILTER_SCALE */
        287, /* GL_CONVOLUTION_FILTER_BIAS */
-      1316, /* GL_REDUCE */
+      1322, /* GL_REDUCE */
        291, /* GL_CONVOLUTION_FORMAT */
        295, /* GL_CONVOLUTION_WIDTH */
        293, /* GL_CONVOLUTION_HEIGHT */
-       873, /* GL_MAX_CONVOLUTION_WIDTH */
-       871, /* GL_MAX_CONVOLUTION_HEIGHT */
-      1220, /* GL_POST_CONVOLUTION_RED_SCALE */
-      1216, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-      1211, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-      1207, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-      1218, /* GL_POST_CONVOLUTION_RED_BIAS */
-      1214, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-      1209, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-      1205, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+       874, /* GL_MAX_CONVOLUTION_WIDTH */
+       872, /* GL_MAX_CONVOLUTION_HEIGHT */
+      1224, /* GL_POST_CONVOLUTION_RED_SCALE */
+      1220, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+      1215, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+      1211, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+      1222, /* GL_POST_CONVOLUTION_RED_BIAS */
+      1218, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+      1213, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+      1209, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
        607, /* GL_HISTOGRAM */
-      1269, /* GL_PROXY_HISTOGRAM */
+      1274, /* GL_PROXY_HISTOGRAM */
        623, /* GL_HISTOGRAM_WIDTH */
        613, /* GL_HISTOGRAM_FORMAT */
        619, /* GL_HISTOGRAM_RED_SIZE */
@@ -4298,134 +4328,134 @@ static const unsigned reduced_enums[1357] =
        608, /* GL_HISTOGRAM_ALPHA_SIZE */
        617, /* GL_HISTOGRAM_LUMINANCE_SIZE */
        621, /* GL_HISTOGRAM_SINK */
-       951, /* GL_MINMAX */
-       953, /* GL_MINMAX_FORMAT */
-       955, /* GL_MINMAX_SINK */
-      1570, /* GL_TABLE_TOO_LARGE_EXT */
-      1791, /* GL_UNSIGNED_BYTE_3_3_2 */
-      1803, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-      1805, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-      1798, /* GL_UNSIGNED_INT_8_8_8_8 */
-      1793, /* GL_UNSIGNED_INT_10_10_10_2 */
-      1178, /* GL_POLYGON_OFFSET_FILL */
-      1177, /* GL_POLYGON_OFFSET_FACTOR */
-      1176, /* GL_POLYGON_OFFSET_BIAS */
-      1350, /* GL_RESCALE_NORMAL */
+       955, /* GL_MINMAX */
+       957, /* GL_MINMAX_FORMAT */
+       959, /* GL_MINMAX_SINK */
+      1577, /* GL_TABLE_TOO_LARGE_EXT */
+      1806, /* GL_UNSIGNED_BYTE_3_3_2 */
+      1818, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+      1820, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+      1813, /* GL_UNSIGNED_INT_8_8_8_8 */
+      1808, /* GL_UNSIGNED_INT_10_10_10_2 */
+      1182, /* GL_POLYGON_OFFSET_FILL */
+      1181, /* GL_POLYGON_OFFSET_FACTOR */
+      1180, /* GL_POLYGON_OFFSET_BIAS */
+      1356, /* GL_RESCALE_NORMAL */
         36, /* GL_ALPHA4 */
         38, /* GL_ALPHA8 */
         32, /* GL_ALPHA12 */
         34, /* GL_ALPHA16 */
-       737, /* GL_LUMINANCE4 */
-       743, /* GL_LUMINANCE8 */
-       727, /* GL_LUMINANCE12 */
-       733, /* GL_LUMINANCE16 */
-       738, /* GL_LUMINANCE4_ALPHA4 */
-       741, /* GL_LUMINANCE6_ALPHA2 */
-       744, /* GL_LUMINANCE8_ALPHA8 */
-       730, /* GL_LUMINANCE12_ALPHA4 */
-       728, /* GL_LUMINANCE12_ALPHA12 */
-       734, /* GL_LUMINANCE16_ALPHA16 */
+       738, /* GL_LUMINANCE4 */
+       744, /* GL_LUMINANCE8 */
+       728, /* GL_LUMINANCE12 */
+       734, /* GL_LUMINANCE16 */
+       739, /* GL_LUMINANCE4_ALPHA4 */
+       742, /* GL_LUMINANCE6_ALPHA2 */
+       745, /* GL_LUMINANCE8_ALPHA8 */
+       731, /* GL_LUMINANCE12_ALPHA4 */
+       729, /* GL_LUMINANCE12_ALPHA12 */
+       735, /* GL_LUMINANCE16_ALPHA16 */
        648, /* GL_INTENSITY */
        653, /* GL_INTENSITY4 */
        655, /* GL_INTENSITY8 */
        649, /* GL_INTENSITY12 */
        651, /* GL_INTENSITY16 */
-      1363, /* GL_RGB2_EXT */
-      1364, /* GL_RGB4 */
-      1367, /* GL_RGB5 */
-      1371, /* GL_RGB8 */
-      1355, /* GL_RGB10 */
-      1359, /* GL_RGB12 */
-      1361, /* GL_RGB16 */
-      1378, /* GL_RGBA2 */
-      1380, /* GL_RGBA4 */
-      1368, /* GL_RGB5_A1 */
-      1384, /* GL_RGBA8 */
-      1356, /* GL_RGB10_A2 */
-      1374, /* GL_RGBA12 */
-      1376, /* GL_RGBA16 */
-      1746, /* GL_TEXTURE_RED_SIZE */
-      1716, /* GL_TEXTURE_GREEN_SIZE */
-      1654, /* GL_TEXTURE_BLUE_SIZE */
-      1641, /* GL_TEXTURE_ALPHA_SIZE */
-      1729, /* GL_TEXTURE_LUMINANCE_SIZE */
-      1720, /* GL_TEXTURE_INTENSITY_SIZE */
-      1348, /* GL_REPLACE_EXT */
-      1273, /* GL_PROXY_TEXTURE_1D */
-      1276, /* GL_PROXY_TEXTURE_2D */
-      1753, /* GL_TEXTURE_TOO_LARGE_EXT */
-      1741, /* GL_TEXTURE_PRIORITY */
-      1748, /* GL_TEXTURE_RESIDENT */
-      1644, /* GL_TEXTURE_BINDING_1D */
-      1646, /* GL_TEXTURE_BINDING_2D */
-      1648, /* GL_TEXTURE_BINDING_3D */
-      1098, /* GL_PACK_SKIP_IMAGES */
-      1094, /* GL_PACK_IMAGE_HEIGHT */
-      1784, /* GL_UNPACK_SKIP_IMAGES */
-      1781, /* GL_UNPACK_IMAGE_HEIGHT */
-      1640, /* GL_TEXTURE_3D */
-      1279, /* GL_PROXY_TEXTURE_3D */
-      1703, /* GL_TEXTURE_DEPTH */
-      1756, /* GL_TEXTURE_WRAP_R */
-       858, /* GL_MAX_3D_TEXTURE_SIZE */
-      1818, /* GL_VERTEX_ARRAY */
-      1028, /* GL_NORMAL_ARRAY */
+      1369, /* GL_RGB2_EXT */
+      1370, /* GL_RGB4 */
+      1373, /* GL_RGB5 */
+      1377, /* GL_RGB8 */
+      1361, /* GL_RGB10 */
+      1365, /* GL_RGB12 */
+      1367, /* GL_RGB16 */
+      1384, /* GL_RGBA2 */
+      1386, /* GL_RGBA4 */
+      1374, /* GL_RGB5_A1 */
+      1390, /* GL_RGBA8 */
+      1362, /* GL_RGB10_A2 */
+      1380, /* GL_RGBA12 */
+      1382, /* GL_RGBA16 */
+      1753, /* GL_TEXTURE_RED_SIZE */
+      1723, /* GL_TEXTURE_GREEN_SIZE */
+      1661, /* GL_TEXTURE_BLUE_SIZE */
+      1648, /* GL_TEXTURE_ALPHA_SIZE */
+      1736, /* GL_TEXTURE_LUMINANCE_SIZE */
+      1727, /* GL_TEXTURE_INTENSITY_SIZE */
+      1354, /* GL_REPLACE_EXT */
+      1278, /* GL_PROXY_TEXTURE_1D */
+      1281, /* GL_PROXY_TEXTURE_2D */
+      1760, /* GL_TEXTURE_TOO_LARGE_EXT */
+      1748, /* GL_TEXTURE_PRIORITY */
+      1755, /* GL_TEXTURE_RESIDENT */
+      1651, /* GL_TEXTURE_BINDING_1D */
+      1653, /* GL_TEXTURE_BINDING_2D */
+      1655, /* GL_TEXTURE_BINDING_3D */
+      1102, /* GL_PACK_SKIP_IMAGES */
+      1098, /* GL_PACK_IMAGE_HEIGHT */
+      1799, /* GL_UNPACK_SKIP_IMAGES */
+      1796, /* GL_UNPACK_IMAGE_HEIGHT */
+      1647, /* GL_TEXTURE_3D */
+      1284, /* GL_PROXY_TEXTURE_3D */
+      1710, /* GL_TEXTURE_DEPTH */
+      1763, /* GL_TEXTURE_WRAP_R */
+       859, /* GL_MAX_3D_TEXTURE_SIZE */
+      1833, /* GL_VERTEX_ARRAY */
+      1032, /* GL_NORMAL_ARRAY */
        149, /* GL_COLOR_ARRAY */
        633, /* GL_INDEX_ARRAY */
-      1681, /* GL_TEXTURE_COORD_ARRAY */
+      1688, /* GL_TEXTURE_COORD_ARRAY */
        460, /* GL_EDGE_FLAG_ARRAY */
-      1824, /* GL_VERTEX_ARRAY_SIZE */
-      1826, /* GL_VERTEX_ARRAY_TYPE */
-      1825, /* GL_VERTEX_ARRAY_STRIDE */
-      1033, /* GL_NORMAL_ARRAY_TYPE */
-      1032, /* GL_NORMAL_ARRAY_STRIDE */
+      1839, /* GL_VERTEX_ARRAY_SIZE */
+      1841, /* GL_VERTEX_ARRAY_TYPE */
+      1840, /* GL_VERTEX_ARRAY_STRIDE */
+      1037, /* GL_NORMAL_ARRAY_TYPE */
+      1036, /* GL_NORMAL_ARRAY_STRIDE */
        153, /* GL_COLOR_ARRAY_SIZE */
        155, /* GL_COLOR_ARRAY_TYPE */
        154, /* GL_COLOR_ARRAY_STRIDE */
        638, /* GL_INDEX_ARRAY_TYPE */
        637, /* GL_INDEX_ARRAY_STRIDE */
-      1685, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-      1687, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-      1686, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+      1692, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+      1694, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+      1693, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
        464, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-      1823, /* GL_VERTEX_ARRAY_POINTER */
-      1031, /* GL_NORMAL_ARRAY_POINTER */
+      1838, /* GL_VERTEX_ARRAY_POINTER */
+      1035, /* GL_NORMAL_ARRAY_POINTER */
        152, /* GL_COLOR_ARRAY_POINTER */
        636, /* GL_INDEX_ARRAY_POINTER */
-      1684, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+      1691, /* GL_TEXTURE_COORD_ARRAY_POINTER */
        463, /* GL_EDGE_FLAG_ARRAY_POINTER */
-      1007, /* GL_MULTISAMPLE */
-      1408, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-      1410, /* GL_SAMPLE_ALPHA_TO_ONE */
-      1415, /* GL_SAMPLE_COVERAGE */
-      1412, /* GL_SAMPLE_BUFFERS */
-      1403, /* GL_SAMPLES */
-      1419, /* GL_SAMPLE_COVERAGE_VALUE */
-      1417, /* GL_SAMPLE_COVERAGE_INVERT */
+      1011, /* GL_MULTISAMPLE */
+      1414, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+      1416, /* GL_SAMPLE_ALPHA_TO_ONE */
+      1421, /* GL_SAMPLE_COVERAGE */
+      1418, /* GL_SAMPLE_BUFFERS */
+      1409, /* GL_SAMPLES */
+      1425, /* GL_SAMPLE_COVERAGE_VALUE */
+      1423, /* GL_SAMPLE_COVERAGE_INVERT */
        196, /* GL_COLOR_MATRIX */
        198, /* GL_COLOR_MATRIX_STACK_DEPTH */
-       867, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-      1203, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-      1199, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-      1194, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-      1190, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-      1201, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-      1197, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-      1192, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-      1188, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-      1664, /* GL_TEXTURE_COLOR_TABLE_SGI */
-      1280, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-      1666, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+       868, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+      1207, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+      1203, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+      1198, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+      1194, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+      1205, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+      1201, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+      1196, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+      1192, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+      1671, /* GL_TEXTURE_COLOR_TABLE_SGI */
+      1285, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+      1673, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
         80, /* GL_BLEND_DST_RGB */
         89, /* GL_BLEND_SRC_RGB */
         79, /* GL_BLEND_DST_ALPHA */
         88, /* GL_BLEND_SRC_ALPHA */
        202, /* GL_COLOR_TABLE */
-      1213, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-      1196, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-      1268, /* GL_PROXY_COLOR_TABLE */
-      1272, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-      1271, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+      1217, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+      1200, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+      1273, /* GL_PROXY_COLOR_TABLE */
+      1277, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+      1276, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
        226, /* GL_COLOR_TABLE_SCALE */
        206, /* GL_COLOR_TABLE_BIAS */
        211, /* GL_COLOR_TABLE_FORMAT */
@@ -4438,62 +4468,62 @@ static const unsigned reduced_enums[1357] =
        217, /* GL_COLOR_TABLE_INTENSITY_SIZE */
         71, /* GL_BGR */
         72, /* GL_BGRA */
-       881, /* GL_MAX_ELEMENTS_VERTICES */
-       880, /* GL_MAX_ELEMENTS_INDICES */
-      1719, /* GL_TEXTURE_INDEX_SIZE_EXT */
+       882, /* GL_MAX_ELEMENTS_VERTICES */
+       881, /* GL_MAX_ELEMENTS_INDICES */
+      1726, /* GL_TEXTURE_INDEX_SIZE_EXT */
        146, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
-      1160, /* GL_POINT_SIZE_MIN */
-      1156, /* GL_POINT_SIZE_MAX */
-      1150, /* GL_POINT_FADE_THRESHOLD_SIZE */
-      1146, /* GL_POINT_DISTANCE_ATTENUATION */
+      1164, /* GL_POINT_SIZE_MIN */
+      1160, /* GL_POINT_SIZE_MAX */
+      1154, /* GL_POINT_FADE_THRESHOLD_SIZE */
+      1150, /* GL_POINT_DISTANCE_ATTENUATION */
        128, /* GL_CLAMP_TO_BORDER */
        131, /* GL_CLAMP_TO_EDGE */
-      1740, /* GL_TEXTURE_MIN_LOD */
-      1738, /* GL_TEXTURE_MAX_LOD */
-      1643, /* GL_TEXTURE_BASE_LEVEL */
-      1737, /* GL_TEXTURE_MAX_LEVEL */
+      1747, /* GL_TEXTURE_MIN_LOD */
+      1745, /* GL_TEXTURE_MAX_LOD */
+      1650, /* GL_TEXTURE_BASE_LEVEL */
+      1744, /* GL_TEXTURE_MAX_LEVEL */
        626, /* GL_IGNORE_BORDER_HP */
        277, /* GL_CONSTANT_BORDER_HP */
-      1349, /* GL_REPLICATE_BORDER_HP */
+      1355, /* GL_REPLICATE_BORDER_HP */
        283, /* GL_CONVOLUTION_BORDER_COLOR */
-      1057, /* GL_OCCLUSION_TEST_HP */
-      1058, /* GL_OCCLUSION_TEST_RESULT_HP */
-       699, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-      1658, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-      1660, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-      1662, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-      1663, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-      1661, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-      1659, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-       862, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-       863, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-      1223, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-      1225, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-      1222, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-      1224, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-      1727, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-      1728, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-      1726, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+      1061, /* GL_OCCLUSION_TEST_HP */
+      1062, /* GL_OCCLUSION_TEST_RESULT_HP */
+       700, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+      1665, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+      1667, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+      1669, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+      1670, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+      1668, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+      1666, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+       863, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+       864, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+      1227, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+      1229, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+      1226, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+      1228, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+      1734, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+      1735, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+      1733, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
        595, /* GL_GENERATE_MIPMAP */
        596, /* GL_GENERATE_MIPMAP_HINT */
        533, /* GL_FOG_OFFSET_SGIX */
        534, /* GL_FOG_OFFSET_VALUE_SGIX */
-      1672, /* GL_TEXTURE_COMPARE_SGIX */
-      1671, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-      1723, /* GL_TEXTURE_LEQUAL_R_SGIX */
-      1715, /* GL_TEXTURE_GEQUAL_R_SGIX */
+      1679, /* GL_TEXTURE_COMPARE_SGIX */
+      1678, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+      1730, /* GL_TEXTURE_LEQUAL_R_SGIX */
+      1722, /* GL_TEXTURE_GEQUAL_R_SGIX */
        361, /* GL_DEPTH_COMPONENT16 */
        364, /* GL_DEPTH_COMPONENT24 */
        367, /* GL_DEPTH_COMPONENT32 */
        307, /* GL_CULL_VERTEX_EXT */
        309, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
        308, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
-      1882, /* GL_WRAP_BORDER_SUN */
-      1665, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-       692, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-      1449, /* GL_SINGLE_COLOR */
-      1435, /* GL_SEPARATE_SPECULAR_COLOR */
-      1444, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+      1897, /* GL_WRAP_BORDER_SUN */
+      1672, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+       693, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+      1456, /* GL_SINGLE_COLOR */
+      1442, /* GL_SEPARATE_SPECULAR_COLOR */
+      1451, /* GL_SHARED_TEXTURE_PALETTE_EXT */
        544, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
        545, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
        552, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
@@ -4506,30 +4536,30 @@ static const unsigned reduced_enums[1357] =
        581, /* GL_FRAMEBUFFER_UNDEFINED */
        374, /* GL_DEPTH_STENCIL_ATTACHMENT */
        632, /* GL_INDEX */
-      1790, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-      1806, /* GL_UNSIGNED_SHORT_5_6_5 */
-      1807, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-      1804, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-      1802, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-      1799, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-      1797, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-      1735, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-      1736, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-      1734, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-       958, /* GL_MIRRORED_REPEAT */
-      1391, /* GL_RGB_S3TC */
-      1366, /* GL_RGB4_S3TC */
-      1389, /* GL_RGBA_S3TC */
-      1383, /* GL_RGBA4_S3TC */
-      1387, /* GL_RGBA_DXT5_S3TC */
-      1381, /* GL_RGBA4_DXT5_S3TC */
+      1805, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+      1821, /* GL_UNSIGNED_SHORT_5_6_5 */
+      1822, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+      1819, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+      1817, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+      1814, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+      1812, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+      1742, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+      1743, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+      1741, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+       962, /* GL_MIRRORED_REPEAT */
+      1397, /* GL_RGB_S3TC */
+      1372, /* GL_RGB4_S3TC */
+      1395, /* GL_RGBA_S3TC */
+      1389, /* GL_RGBA4_S3TC */
+      1393, /* GL_RGBA_DXT5_S3TC */
+      1387, /* GL_RGBA4_DXT5_S3TC */
        265, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
        260, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
        261, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
        262, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
-      1019, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-      1018, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-       700, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+      1023, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+      1022, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+       701, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
        520, /* GL_FOG_COORDINATE_SOURCE */
        512, /* GL_FOG_COORD */
        536, /* GL_FRAGMENT_DEPTH */
@@ -4540,279 +4570,279 @@ static const unsigned reduced_enums[1357] =
        514, /* GL_FOG_COORDINATE_ARRAY */
        200, /* GL_COLOR_SUM */
        333, /* GL_CURRENT_SECONDARY_COLOR */
-      1428, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-      1430, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-      1429, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-      1427, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-      1424, /* GL_SECONDARY_COLOR_ARRAY */
+      1434, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+      1436, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+      1435, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+      1433, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+      1430, /* GL_SECONDARY_COLOR_ARRAY */
        331, /* GL_CURRENT_RASTER_SECONDARY_COLOR */
         28, /* GL_ALIASED_POINT_SIZE_RANGE */
         27, /* GL_ALIASED_LINE_WIDTH_RANGE */
-      1572, /* GL_TEXTURE0 */
-      1574, /* GL_TEXTURE1 */
-      1596, /* GL_TEXTURE2 */
-      1618, /* GL_TEXTURE3 */
-      1624, /* GL_TEXTURE4 */
-      1626, /* GL_TEXTURE5 */
-      1628, /* GL_TEXTURE6 */
-      1630, /* GL_TEXTURE7 */
-      1632, /* GL_TEXTURE8 */
-      1634, /* GL_TEXTURE9 */
-      1575, /* GL_TEXTURE10 */
-      1577, /* GL_TEXTURE11 */
-      1579, /* GL_TEXTURE12 */
-      1581, /* GL_TEXTURE13 */
-      1583, /* GL_TEXTURE14 */
-      1585, /* GL_TEXTURE15 */
-      1587, /* GL_TEXTURE16 */
-      1589, /* GL_TEXTURE17 */
-      1591, /* GL_TEXTURE18 */
-      1593, /* GL_TEXTURE19 */
-      1597, /* GL_TEXTURE20 */
-      1599, /* GL_TEXTURE21 */
-      1601, /* GL_TEXTURE22 */
-      1603, /* GL_TEXTURE23 */
-      1605, /* GL_TEXTURE24 */
-      1607, /* GL_TEXTURE25 */
-      1609, /* GL_TEXTURE26 */
-      1611, /* GL_TEXTURE27 */
-      1613, /* GL_TEXTURE28 */
-      1615, /* GL_TEXTURE29 */
-      1619, /* GL_TEXTURE30 */
-      1621, /* GL_TEXTURE31 */
+      1579, /* GL_TEXTURE0 */
+      1581, /* GL_TEXTURE1 */
+      1603, /* GL_TEXTURE2 */
+      1625, /* GL_TEXTURE3 */
+      1631, /* GL_TEXTURE4 */
+      1633, /* GL_TEXTURE5 */
+      1635, /* GL_TEXTURE6 */
+      1637, /* GL_TEXTURE7 */
+      1639, /* GL_TEXTURE8 */
+      1641, /* GL_TEXTURE9 */
+      1582, /* GL_TEXTURE10 */
+      1584, /* GL_TEXTURE11 */
+      1586, /* GL_TEXTURE12 */
+      1588, /* GL_TEXTURE13 */
+      1590, /* GL_TEXTURE14 */
+      1592, /* GL_TEXTURE15 */
+      1594, /* GL_TEXTURE16 */
+      1596, /* GL_TEXTURE17 */
+      1598, /* GL_TEXTURE18 */
+      1600, /* GL_TEXTURE19 */
+      1604, /* GL_TEXTURE20 */
+      1606, /* GL_TEXTURE21 */
+      1608, /* GL_TEXTURE22 */
+      1610, /* GL_TEXTURE23 */
+      1612, /* GL_TEXTURE24 */
+      1614, /* GL_TEXTURE25 */
+      1616, /* GL_TEXTURE26 */
+      1618, /* GL_TEXTURE27 */
+      1620, /* GL_TEXTURE28 */
+      1622, /* GL_TEXTURE29 */
+      1626, /* GL_TEXTURE30 */
+      1628, /* GL_TEXTURE31 */
         18, /* GL_ACTIVE_TEXTURE */
        134, /* GL_CLIENT_ACTIVE_TEXTURE */
-       936, /* GL_MAX_TEXTURE_UNITS */
-      1767, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-      1770, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-      1772, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-      1764, /* GL_TRANSPOSE_COLOR_MATRIX */
-      1554, /* GL_SUBTRACT */
-       921, /* GL_MAX_RENDERBUFFER_SIZE */
+       937, /* GL_MAX_TEXTURE_UNITS */
+      1782, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+      1785, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+      1787, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+      1779, /* GL_TRANSPOSE_COLOR_MATRIX */
+      1561, /* GL_SUBTRACT */
+       922, /* GL_MAX_RENDERBUFFER_SIZE */
        248, /* GL_COMPRESSED_ALPHA */
        252, /* GL_COMPRESSED_LUMINANCE */
        253, /* GL_COMPRESSED_LUMINANCE_ALPHA */
        250, /* GL_COMPRESSED_INTENSITY */
        256, /* GL_COMPRESSED_RGB */
        257, /* GL_COMPRESSED_RGBA */
-      1679, /* GL_TEXTURE_COMPRESSION_HINT */
-      1744, /* GL_TEXTURE_RECTANGLE_ARB */
-      1651, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-      1283, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-       919, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+      1686, /* GL_TEXTURE_COMPRESSION_HINT */
+      1751, /* GL_TEXTURE_RECTANGLE_ARB */
+      1658, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+      1288, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+       920, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
        373, /* GL_DEPTH_STENCIL */
-      1794, /* GL_UNSIGNED_INT_24_8 */
-       932, /* GL_MAX_TEXTURE_LOD_BIAS */
-      1733, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-       933, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-      1709, /* GL_TEXTURE_FILTER_CONTROL */
-      1724, /* GL_TEXTURE_LOD_BIAS */
+      1809, /* GL_UNSIGNED_INT_24_8 */
+       933, /* GL_MAX_TEXTURE_LOD_BIAS */
+      1740, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+       934, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+      1716, /* GL_TEXTURE_FILTER_CONTROL */
+      1731, /* GL_TEXTURE_LOD_BIAS */
        233, /* GL_COMBINE4 */
-       926, /* GL_MAX_SHININESS_NV */
-       927, /* GL_MAX_SPOT_EXPONENT_NV */
+       927, /* GL_MAX_SHININESS_NV */
+       928, /* GL_MAX_SPOT_EXPONENT_NV */
        630, /* GL_INCR_WRAP */
        344, /* GL_DECR_WRAP */
-       978, /* GL_MODELVIEW1_ARB */
-      1034, /* GL_NORMAL_MAP */
-      1321, /* GL_REFLECTION_MAP */
-      1688, /* GL_TEXTURE_CUBE_MAP */
-      1649, /* GL_TEXTURE_BINDING_CUBE_MAP */
-      1696, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-      1690, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-      1698, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-      1692, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-      1700, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-      1694, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-      1281, /* GL_PROXY_TEXTURE_CUBE_MAP */
-       875, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-      1013, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+       982, /* GL_MODELVIEW1_ARB */
+      1038, /* GL_NORMAL_MAP */
+      1327, /* GL_REFLECTION_MAP */
+      1695, /* GL_TEXTURE_CUBE_MAP */
+      1656, /* GL_TEXTURE_BINDING_CUBE_MAP */
+      1703, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+      1697, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+      1705, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+      1699, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+      1707, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+      1701, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+      1286, /* GL_PROXY_TEXTURE_CUBE_MAP */
+       876, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+      1017, /* GL_MULTISAMPLE_FILTER_HINT_NV */
        528, /* GL_FOG_DISTANCE_MODE_NV */
        479, /* GL_EYE_RADIAL_NV */
        478, /* GL_EYE_PLANE_ABSOLUTE_NV */
        232, /* GL_COMBINE */
        239, /* GL_COMBINE_RGB */
        234, /* GL_COMBINE_ALPHA */
-      1392, /* GL_RGB_SCALE */
+      1398, /* GL_RGB_SCALE */
         24, /* GL_ADD_SIGNED */
-       658, /* GL_INTERPOLATE */
+       659, /* GL_INTERPOLATE */
        272, /* GL_CONSTANT */
-      1229, /* GL_PRIMARY_COLOR */
-      1226, /* GL_PREVIOUS */
-      1464, /* GL_SOURCE0_RGB */
-      1470, /* GL_SOURCE1_RGB */
-      1476, /* GL_SOURCE2_RGB */
-      1480, /* GL_SOURCE3_RGB_NV */
-      1461, /* GL_SOURCE0_ALPHA */
-      1467, /* GL_SOURCE1_ALPHA */
-      1473, /* GL_SOURCE2_ALPHA */
-      1479, /* GL_SOURCE3_ALPHA_NV */
-      1071, /* GL_OPERAND0_RGB */
-      1077, /* GL_OPERAND1_RGB */
-      1083, /* GL_OPERAND2_RGB */
-      1087, /* GL_OPERAND3_RGB_NV */
-      1068, /* GL_OPERAND0_ALPHA */
-      1074, /* GL_OPERAND1_ALPHA */
-      1080, /* GL_OPERAND2_ALPHA */
-      1086, /* GL_OPERAND3_ALPHA_NV */
+      1233, /* GL_PRIMARY_COLOR */
+      1230, /* GL_PREVIOUS */
+      1471, /* GL_SOURCE0_RGB */
+      1477, /* GL_SOURCE1_RGB */
+      1483, /* GL_SOURCE2_RGB */
+      1487, /* GL_SOURCE3_RGB_NV */
+      1468, /* GL_SOURCE0_ALPHA */
+      1474, /* GL_SOURCE1_ALPHA */
+      1480, /* GL_SOURCE2_ALPHA */
+      1486, /* GL_SOURCE3_ALPHA_NV */
+      1075, /* GL_OPERAND0_RGB */
+      1081, /* GL_OPERAND1_RGB */
+      1087, /* GL_OPERAND2_RGB */
+      1091, /* GL_OPERAND3_RGB_NV */
+      1072, /* GL_OPERAND0_ALPHA */
+      1078, /* GL_OPERAND1_ALPHA */
+      1084, /* GL_OPERAND2_ALPHA */
+      1090, /* GL_OPERAND3_ALPHA_NV */
        109, /* GL_BUFFER_OBJECT_APPLE */
-      1819, /* GL_VERTEX_ARRAY_BINDING */
-      1742, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
-      1743, /* GL_TEXTURE_RANGE_POINTER_APPLE */
-      1886, /* GL_YCBCR_422_APPLE */
-      1808, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-      1810, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-      1752, /* GL_TEXTURE_STORAGE_HINT_APPLE */
-      1545, /* GL_STORAGE_PRIVATE_APPLE */
-      1544, /* GL_STORAGE_CACHED_APPLE */
-      1546, /* GL_STORAGE_SHARED_APPLE */
-      1451, /* GL_SLICE_ACCUM_SUN */
-      1291, /* GL_QUAD_MESH_SUN */
-      1776, /* GL_TRIANGLE_MESH_SUN */
-      1858, /* GL_VERTEX_PROGRAM_ARB */
-      1869, /* GL_VERTEX_STATE_PROGRAM_NV */
-      1845, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-      1851, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-      1853, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-      1855, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+      1834, /* GL_VERTEX_ARRAY_BINDING */
+      1749, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+      1750, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+      1901, /* GL_YCBCR_422_APPLE */
+      1823, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+      1825, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+      1759, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+      1552, /* GL_STORAGE_PRIVATE_APPLE */
+      1551, /* GL_STORAGE_CACHED_APPLE */
+      1553, /* GL_STORAGE_SHARED_APPLE */
+      1458, /* GL_SLICE_ACCUM_SUN */
+      1296, /* GL_QUAD_MESH_SUN */
+      1791, /* GL_TRIANGLE_MESH_SUN */
+      1873, /* GL_VERTEX_PROGRAM_ARB */
+      1884, /* GL_VERTEX_STATE_PROGRAM_NV */
+      1860, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+      1866, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+      1868, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+      1870, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
        335, /* GL_CURRENT_VERTEX_ATTRIB */
-      1242, /* GL_PROGRAM_LENGTH_ARB */
-      1256, /* GL_PROGRAM_STRING_ARB */
-      1000, /* GL_MODELVIEW_PROJECTION_NV */
+      1247, /* GL_PROGRAM_LENGTH_ARB */
+      1261, /* GL_PROGRAM_STRING_ARB */
+      1004, /* GL_MODELVIEW_PROJECTION_NV */
        625, /* GL_IDENTITY_NV */
-       672, /* GL_INVERSE_NV */
-      1769, /* GL_TRANSPOSE_NV */
-       673, /* GL_INVERSE_TRANSPOSE_NV */
-       905, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-       904, /* GL_MAX_PROGRAM_MATRICES_ARB */
-       811, /* GL_MATRIX0_NV */
-       823, /* GL_MATRIX1_NV */
-       835, /* GL_MATRIX2_NV */
-       839, /* GL_MATRIX3_NV */
-       841, /* GL_MATRIX4_NV */
-       843, /* GL_MATRIX5_NV */
-       845, /* GL_MATRIX6_NV */
-       847, /* GL_MATRIX7_NV */
+       673, /* GL_INVERSE_NV */
+      1784, /* GL_TRANSPOSE_NV */
+       674, /* GL_INVERSE_TRANSPOSE_NV */
+       906, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+       905, /* GL_MAX_PROGRAM_MATRICES_ARB */
+       812, /* GL_MATRIX0_NV */
+       824, /* GL_MATRIX1_NV */
+       836, /* GL_MATRIX2_NV */
+       840, /* GL_MATRIX3_NV */
+       842, /* GL_MATRIX4_NV */
+       844, /* GL_MATRIX5_NV */
+       846, /* GL_MATRIX6_NV */
+       848, /* GL_MATRIX7_NV */
        319, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
        316, /* GL_CURRENT_MATRIX_ARB */
-      1861, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-      1864, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-      1254, /* GL_PROGRAM_PARAMETER_NV */
-      1849, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-      1258, /* GL_PROGRAM_TARGET_NV */
-      1255, /* GL_PROGRAM_RESIDENT_NV */
-      1761, /* GL_TRACK_MATRIX_NV */
-      1762, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-      1859, /* GL_VERTEX_PROGRAM_BINDING_NV */
-      1236, /* GL_PROGRAM_ERROR_POSITION_ARB */
+      1876, /* GL_VERTEX_PROGRAM_POINT_SIZE */
+      1879, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+      1259, /* GL_PROGRAM_PARAMETER_NV */
+      1864, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+      1263, /* GL_PROGRAM_TARGET_NV */
+      1260, /* GL_PROGRAM_RESIDENT_NV */
+      1768, /* GL_TRACK_MATRIX_NV */
+      1769, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+      1874, /* GL_VERTEX_PROGRAM_BINDING_NV */
+      1241, /* GL_PROGRAM_ERROR_POSITION_ARB */
        357, /* GL_DEPTH_CLAMP */
-      1827, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-      1834, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-      1835, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-      1836, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-      1837, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-      1838, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-      1839, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-      1840, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-      1841, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-      1842, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-      1828, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-      1829, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-      1830, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-      1831, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-      1832, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-      1833, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-       759, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-       766, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-       767, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-       768, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-       769, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-       770, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-       771, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-       772, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-       773, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-       774, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-       760, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-       761, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-       762, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-       763, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-       764, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-       765, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-       786, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-       793, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-       794, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-       795, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-       796, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-       797, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-       798, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-      1235, /* GL_PROGRAM_BINDING_ARB */
-       800, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-       801, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-       787, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-       788, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-       789, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-       790, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-       791, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-       792, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-      1677, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-      1674, /* GL_TEXTURE_COMPRESSED */
-      1039, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+      1842, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+      1849, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+      1850, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+      1851, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+      1852, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+      1853, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+      1854, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+      1855, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+      1856, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+      1857, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+      1843, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+      1844, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+      1845, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+      1846, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+      1847, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+      1848, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+       760, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+       767, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+       768, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+       769, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+       770, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+       771, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+       772, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+       773, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+       774, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+       775, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+       761, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+       762, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+       763, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+       764, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+       765, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+       766, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+       787, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+       794, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+       795, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+       796, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+       797, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+       798, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+       799, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+      1240, /* GL_PROGRAM_BINDING_ARB */
+       801, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+       802, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+       788, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+       789, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+       790, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+       791, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+       792, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+       793, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+      1684, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+      1681, /* GL_TEXTURE_COMPRESSED */
+      1043, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
        270, /* GL_COMPRESSED_TEXTURE_FORMATS */
-       948, /* GL_MAX_VERTEX_UNITS_ARB */
+       952, /* GL_MAX_VERTEX_UNITS_ARB */
         22, /* GL_ACTIVE_VERTEX_UNITS_ARB */
-      1881, /* GL_WEIGHT_SUM_UNITY_ARB */
-      1857, /* GL_VERTEX_BLEND_ARB */
+      1896, /* GL_WEIGHT_SUM_UNITY_ARB */
+      1872, /* GL_VERTEX_BLEND_ARB */
        337, /* GL_CURRENT_WEIGHT_ARB */
-      1880, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-      1879, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-      1878, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-      1877, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-      1874, /* GL_WEIGHT_ARRAY_ARB */
+      1895, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+      1894, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+      1893, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+      1892, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+      1889, /* GL_WEIGHT_ARRAY_ARB */
        387, /* GL_DOT3_RGB */
        388, /* GL_DOT3_RGBA */
        264, /* GL_COMPRESSED_RGB_FXT1_3DFX */
        259, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
-      1008, /* GL_MULTISAMPLE_3DFX */
-      1413, /* GL_SAMPLE_BUFFERS_3DFX */
-      1404, /* GL_SAMPLES_3DFX */
-       989, /* GL_MODELVIEW2_ARB */
-       992, /* GL_MODELVIEW3_ARB */
-       993, /* GL_MODELVIEW4_ARB */
-       994, /* GL_MODELVIEW5_ARB */
-       995, /* GL_MODELVIEW6_ARB */
-       996, /* GL_MODELVIEW7_ARB */
-       997, /* GL_MODELVIEW8_ARB */
-       998, /* GL_MODELVIEW9_ARB */
-       968, /* GL_MODELVIEW10_ARB */
-       969, /* GL_MODELVIEW11_ARB */
-       970, /* GL_MODELVIEW12_ARB */
-       971, /* GL_MODELVIEW13_ARB */
-       972, /* GL_MODELVIEW14_ARB */
-       973, /* GL_MODELVIEW15_ARB */
-       974, /* GL_MODELVIEW16_ARB */
-       975, /* GL_MODELVIEW17_ARB */
-       976, /* GL_MODELVIEW18_ARB */
-       977, /* GL_MODELVIEW19_ARB */
-       979, /* GL_MODELVIEW20_ARB */
-       980, /* GL_MODELVIEW21_ARB */
-       981, /* GL_MODELVIEW22_ARB */
-       982, /* GL_MODELVIEW23_ARB */
-       983, /* GL_MODELVIEW24_ARB */
-       984, /* GL_MODELVIEW25_ARB */
-       985, /* GL_MODELVIEW26_ARB */
-       986, /* GL_MODELVIEW27_ARB */
-       987, /* GL_MODELVIEW28_ARB */
-       988, /* GL_MODELVIEW29_ARB */
-       990, /* GL_MODELVIEW30_ARB */
-       991, /* GL_MODELVIEW31_ARB */
+      1012, /* GL_MULTISAMPLE_3DFX */
+      1419, /* GL_SAMPLE_BUFFERS_3DFX */
+      1410, /* GL_SAMPLES_3DFX */
+       993, /* GL_MODELVIEW2_ARB */
+       996, /* GL_MODELVIEW3_ARB */
+       997, /* GL_MODELVIEW4_ARB */
+       998, /* GL_MODELVIEW5_ARB */
+       999, /* GL_MODELVIEW6_ARB */
+      1000, /* GL_MODELVIEW7_ARB */
+      1001, /* GL_MODELVIEW8_ARB */
+      1002, /* GL_MODELVIEW9_ARB */
+       972, /* GL_MODELVIEW10_ARB */
+       973, /* GL_MODELVIEW11_ARB */
+       974, /* GL_MODELVIEW12_ARB */
+       975, /* GL_MODELVIEW13_ARB */
+       976, /* GL_MODELVIEW14_ARB */
+       977, /* GL_MODELVIEW15_ARB */
+       978, /* GL_MODELVIEW16_ARB */
+       979, /* GL_MODELVIEW17_ARB */
+       980, /* GL_MODELVIEW18_ARB */
+       981, /* GL_MODELVIEW19_ARB */
+       983, /* GL_MODELVIEW20_ARB */
+       984, /* GL_MODELVIEW21_ARB */
+       985, /* GL_MODELVIEW22_ARB */
+       986, /* GL_MODELVIEW23_ARB */
+       987, /* GL_MODELVIEW24_ARB */
+       988, /* GL_MODELVIEW25_ARB */
+       989, /* GL_MODELVIEW26_ARB */
+       990, /* GL_MODELVIEW27_ARB */
+       991, /* GL_MODELVIEW28_ARB */
+       992, /* GL_MODELVIEW29_ARB */
+       994, /* GL_MODELVIEW30_ARB */
+       995, /* GL_MODELVIEW31_ARB */
        392, /* GL_DOT3_RGB_EXT */
        390, /* GL_DOT3_RGBA_EXT */
-       962, /* GL_MIRROR_CLAMP_EXT */
-       965, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-      1003, /* GL_MODULATE_ADD_ATI */
-      1004, /* GL_MODULATE_SIGNED_ADD_ATI */
-      1005, /* GL_MODULATE_SUBTRACT_ATI */
-      1887, /* GL_YCBCR_MESA */
-      1095, /* GL_PACK_INVERT_MESA */
+       966, /* GL_MIRROR_CLAMP_EXT */
+       969, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+      1007, /* GL_MODULATE_ADD_ATI */
+      1008, /* GL_MODULATE_SIGNED_ADD_ATI */
+      1009, /* GL_MODULATE_SUBTRACT_ATI */
+      1902, /* GL_YCBCR_MESA */
+      1099, /* GL_PACK_INVERT_MESA */
        340, /* GL_DEBUG_OBJECT_MESA */
        341, /* GL_DEBUG_PRINT_MESA */
        339, /* GL_DEBUG_ASSERT_MESA */
@@ -4826,24 +4856,24 @@ static const unsigned reduced_enums[1357] =
        451, /* GL_DU8DV8_ATI */
        115, /* GL_BUMP_ENVMAP_ATI */
        119, /* GL_BUMP_TARGET_ATI */
-      1512, /* GL_STENCIL_BACK_FUNC */
-      1510, /* GL_STENCIL_BACK_FAIL */
-      1514, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-      1516, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+      1519, /* GL_STENCIL_BACK_FUNC */
+      1517, /* GL_STENCIL_BACK_FAIL */
+      1521, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+      1523, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
        537, /* GL_FRAGMENT_PROGRAM_ARB */
-      1233, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-      1261, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-      1260, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-      1245, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-      1251, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-      1250, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-       894, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-       917, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-       916, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-       907, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-       913, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-       912, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-       877, /* GL_MAX_DRAW_BUFFERS */
+      1238, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+      1266, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+      1265, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+      1250, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+      1256, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+      1255, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+       895, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+       918, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+       917, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+       908, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+       914, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+       913, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+       878, /* GL_MAX_DRAW_BUFFERS */
        396, /* GL_DRAW_BUFFER0 */
        399, /* GL_DRAW_BUFFER1 */
        420, /* GL_DRAW_BUFFER2 */
@@ -4861,166 +4891,166 @@ static const unsigned reduced_enums[1357] =
        412, /* GL_DRAW_BUFFER14 */
        415, /* GL_DRAW_BUFFER15 */
         82, /* GL_BLEND_EQUATION_ALPHA */
-       856, /* GL_MATRIX_PALETTE_ARB */
-       888, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-       891, /* GL_MAX_PALETTE_MATRICES_ARB */
+       857, /* GL_MATRIX_PALETTE_ARB */
+       889, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+       892, /* GL_MAX_PALETTE_MATRICES_ARB */
        322, /* GL_CURRENT_PALETTE_MATRIX_ARB */
-       850, /* GL_MATRIX_INDEX_ARRAY_ARB */
+       851, /* GL_MATRIX_INDEX_ARRAY_ARB */
        317, /* GL_CURRENT_MATRIX_INDEX_ARB */
-       852, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-       854, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-       853, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-       851, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-      1704, /* GL_TEXTURE_DEPTH_SIZE */
+       853, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+       855, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+       854, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+       852, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+      1711, /* GL_TEXTURE_DEPTH_SIZE */
        380, /* GL_DEPTH_TEXTURE_MODE */
-      1669, /* GL_TEXTURE_COMPARE_MODE */
-      1667, /* GL_TEXTURE_COMPARE_FUNC */
+      1676, /* GL_TEXTURE_COMPARE_MODE */
+      1674, /* GL_TEXTURE_COMPARE_FUNC */
        243, /* GL_COMPARE_R_TO_TEXTURE */
-      1167, /* GL_POINT_SPRITE */
+      1171, /* GL_POINT_SPRITE */
        297, /* GL_COORD_REPLACE */
-      1171, /* GL_POINT_SPRITE_R_MODE_NV */
-      1295, /* GL_QUERY_COUNTER_BITS */
+      1175, /* GL_POINT_SPRITE_R_MODE_NV */
+      1300, /* GL_QUERY_COUNTER_BITS */
        324, /* GL_CURRENT_QUERY */
-      1298, /* GL_QUERY_RESULT */
-      1300, /* GL_QUERY_RESULT_AVAILABLE */
-       942, /* GL_MAX_VERTEX_ATTRIBS */
-      1847, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+      1303, /* GL_QUERY_RESULT */
+      1305, /* GL_QUERY_RESULT_AVAILABLE */
+       946, /* GL_MAX_VERTEX_ATTRIBS */
+      1862, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
        378, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
        377, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
-       928, /* GL_MAX_TEXTURE_COORDS */
-       930, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-      1238, /* GL_PROGRAM_ERROR_STRING_ARB */
-      1240, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-      1239, /* GL_PROGRAM_FORMAT_ARB */
-      1754, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+       929, /* GL_MAX_TEXTURE_COORDS */
+       931, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+      1243, /* GL_PROGRAM_ERROR_STRING_ARB */
+      1245, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+      1244, /* GL_PROGRAM_FORMAT_ARB */
+      1761, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
        355, /* GL_DEPTH_BOUNDS_TEST_EXT */
        354, /* GL_DEPTH_BOUNDS_EXT */
         53, /* GL_ARRAY_BUFFER */
        465, /* GL_ELEMENT_ARRAY_BUFFER */
         54, /* GL_ARRAY_BUFFER_BINDING */
        466, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-      1821, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-      1029, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+      1836, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+      1033, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
        150, /* GL_COLOR_ARRAY_BUFFER_BINDING */
        634, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-      1682, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+      1689, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
        461, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-      1425, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+      1431, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
        515, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-      1875, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-      1843, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-      1241, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-       900, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-      1247, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-       909, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-      1259, /* GL_PROGRAM_TEMPORARIES_ARB */
-       915, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-      1249, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-       911, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-      1253, /* GL_PROGRAM_PARAMETERS_ARB */
-       914, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-      1248, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-       910, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-      1234, /* GL_PROGRAM_ATTRIBS_ARB */
-       895, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-      1246, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-       908, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-      1232, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-       893, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-      1244, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-       906, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-       901, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-       897, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-      1262, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-      1766, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-      1311, /* GL_READ_ONLY */
-      1883, /* GL_WRITE_ONLY */
-      1313, /* GL_READ_WRITE */
+      1890, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+      1858, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+      1246, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+       901, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+      1252, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+       910, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+      1264, /* GL_PROGRAM_TEMPORARIES_ARB */
+       916, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+      1254, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+       912, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+      1258, /* GL_PROGRAM_PARAMETERS_ARB */
+       915, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+      1253, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+       911, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+      1239, /* GL_PROGRAM_ATTRIBS_ARB */
+       896, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+      1251, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+       909, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+      1237, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+       894, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+      1249, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+       907, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+       902, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+       898, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+      1267, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+      1781, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+      1317, /* GL_READ_ONLY */
+      1898, /* GL_WRITE_ONLY */
+      1319, /* GL_READ_WRITE */
        102, /* GL_BUFFER_ACCESS */
        105, /* GL_BUFFER_MAPPED */
        107, /* GL_BUFFER_MAP_POINTER */
-      1760, /* GL_TIME_ELAPSED_EXT */
-       810, /* GL_MATRIX0_ARB */
-       822, /* GL_MATRIX1_ARB */
-       834, /* GL_MATRIX2_ARB */
-       838, /* GL_MATRIX3_ARB */
-       840, /* GL_MATRIX4_ARB */
-       842, /* GL_MATRIX5_ARB */
-       844, /* GL_MATRIX6_ARB */
-       846, /* GL_MATRIX7_ARB */
-       848, /* GL_MATRIX8_ARB */
-       849, /* GL_MATRIX9_ARB */
-       812, /* GL_MATRIX10_ARB */
-       813, /* GL_MATRIX11_ARB */
-       814, /* GL_MATRIX12_ARB */
-       815, /* GL_MATRIX13_ARB */
-       816, /* GL_MATRIX14_ARB */
-       817, /* GL_MATRIX15_ARB */
-       818, /* GL_MATRIX16_ARB */
-       819, /* GL_MATRIX17_ARB */
-       820, /* GL_MATRIX18_ARB */
-       821, /* GL_MATRIX19_ARB */
-       824, /* GL_MATRIX20_ARB */
-       825, /* GL_MATRIX21_ARB */
-       826, /* GL_MATRIX22_ARB */
-       827, /* GL_MATRIX23_ARB */
-       828, /* GL_MATRIX24_ARB */
-       829, /* GL_MATRIX25_ARB */
-       830, /* GL_MATRIX26_ARB */
-       831, /* GL_MATRIX27_ARB */
-       832, /* GL_MATRIX28_ARB */
-       833, /* GL_MATRIX29_ARB */
-       836, /* GL_MATRIX30_ARB */
-       837, /* GL_MATRIX31_ARB */
-      1549, /* GL_STREAM_DRAW */
-      1551, /* GL_STREAM_READ */
-      1547, /* GL_STREAM_COPY */
-      1503, /* GL_STATIC_DRAW */
-      1505, /* GL_STATIC_READ */
-      1501, /* GL_STATIC_COPY */
+      1767, /* GL_TIME_ELAPSED_EXT */
+       811, /* GL_MATRIX0_ARB */
+       823, /* GL_MATRIX1_ARB */
+       835, /* GL_MATRIX2_ARB */
+       839, /* GL_MATRIX3_ARB */
+       841, /* GL_MATRIX4_ARB */
+       843, /* GL_MATRIX5_ARB */
+       845, /* GL_MATRIX6_ARB */
+       847, /* GL_MATRIX7_ARB */
+       849, /* GL_MATRIX8_ARB */
+       850, /* GL_MATRIX9_ARB */
+       813, /* GL_MATRIX10_ARB */
+       814, /* GL_MATRIX11_ARB */
+       815, /* GL_MATRIX12_ARB */
+       816, /* GL_MATRIX13_ARB */
+       817, /* GL_MATRIX14_ARB */
+       818, /* GL_MATRIX15_ARB */
+       819, /* GL_MATRIX16_ARB */
+       820, /* GL_MATRIX17_ARB */
+       821, /* GL_MATRIX18_ARB */
+       822, /* GL_MATRIX19_ARB */
+       825, /* GL_MATRIX20_ARB */
+       826, /* GL_MATRIX21_ARB */
+       827, /* GL_MATRIX22_ARB */
+       828, /* GL_MATRIX23_ARB */
+       829, /* GL_MATRIX24_ARB */
+       830, /* GL_MATRIX25_ARB */
+       831, /* GL_MATRIX26_ARB */
+       832, /* GL_MATRIX27_ARB */
+       833, /* GL_MATRIX28_ARB */
+       834, /* GL_MATRIX29_ARB */
+       837, /* GL_MATRIX30_ARB */
+       838, /* GL_MATRIX31_ARB */
+      1556, /* GL_STREAM_DRAW */
+      1558, /* GL_STREAM_READ */
+      1554, /* GL_STREAM_COPY */
+      1510, /* GL_STATIC_DRAW */
+      1512, /* GL_STATIC_READ */
+      1508, /* GL_STATIC_COPY */
        455, /* GL_DYNAMIC_DRAW */
        457, /* GL_DYNAMIC_READ */
        453, /* GL_DYNAMIC_COPY */
-      1135, /* GL_PIXEL_PACK_BUFFER */
-      1139, /* GL_PIXEL_UNPACK_BUFFER */
-      1136, /* GL_PIXEL_PACK_BUFFER_BINDING */
-      1140, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+      1139, /* GL_PIXEL_PACK_BUFFER */
+      1143, /* GL_PIXEL_UNPACK_BUFFER */
+      1140, /* GL_PIXEL_PACK_BUFFER_BINDING */
+      1144, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
        348, /* GL_DEPTH24_STENCIL8 */
-      1750, /* GL_TEXTURE_STENCIL_SIZE */
-      1702, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
-       896, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-       899, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-       903, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-       902, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-       859, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-      1540, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+      1757, /* GL_TEXTURE_STENCIL_SIZE */
+      1709, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+       897, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+       900, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+       904, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+       903, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+       860, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
+      1547, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
         17, /* GL_ACTIVE_STENCIL_FACE_EXT */
-       963, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-      1406, /* GL_SAMPLES_PASSED */
+       967, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+      1412, /* GL_SAMPLES_PASSED */
        110, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */
        104, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */
-      1324, /* GL_RELEASED_APPLE */
-      1872, /* GL_VOLATILE_APPLE */
-      1352, /* GL_RETAINED_APPLE */
-      1779, /* GL_UNDEFINED_APPLE */
-      1285, /* GL_PURGEABLE_APPLE */
+      1330, /* GL_RELEASED_APPLE */
+      1887, /* GL_VOLATILE_APPLE */
+      1358, /* GL_RETAINED_APPLE */
+      1794, /* GL_UNDEFINED_APPLE */
+      1290, /* GL_PURGEABLE_APPLE */
        538, /* GL_FRAGMENT_SHADER */
-      1867, /* GL_VERTEX_SHADER */
-      1252, /* GL_PROGRAM_OBJECT_ARB */
-      1438, /* GL_SHADER_OBJECT_ARB */
-       884, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-       946, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-       940, /* GL_MAX_VARYING_FLOATS */
-       944, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-       869, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-      1055, /* GL_OBJECT_TYPE_ARB */
-      1440, /* GL_SHADER_TYPE */
+      1882, /* GL_VERTEX_SHADER */
+      1257, /* GL_PROGRAM_OBJECT_ARB */
+      1445, /* GL_SHADER_OBJECT_ARB */
+       885, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+       950, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+       944, /* GL_MAX_VARYING_FLOATS */
+       948, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+       870, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+      1059, /* GL_OBJECT_TYPE_ARB */
+      1447, /* GL_SHADER_TYPE */
        503, /* GL_FLOAT_VEC2 */
        505, /* GL_FLOAT_VEC3 */
        507, /* GL_FLOAT_VEC4 */
-       661, /* GL_INT_VEC2 */
-       663, /* GL_INT_VEC3 */
-       665, /* GL_INT_VEC4 */
+       662, /* GL_INT_VEC2 */
+       664, /* GL_INT_VEC3 */
+       666, /* GL_INT_VEC4 */
         94, /* GL_BOOL */
         96, /* GL_BOOL_VEC2 */
         98, /* GL_BOOL_VEC3 */
@@ -5028,12 +5058,12 @@ static const unsigned reduced_enums[1357] =
        491, /* GL_FLOAT_MAT2 */
        495, /* GL_FLOAT_MAT3 */
        499, /* GL_FLOAT_MAT4 */
-      1397, /* GL_SAMPLER_1D */
-      1399, /* GL_SAMPLER_2D */
-      1401, /* GL_SAMPLER_3D */
-      1402, /* GL_SAMPLER_CUBE */
-      1398, /* GL_SAMPLER_1D_SHADOW */
-      1400, /* GL_SAMPLER_2D_SHADOW */
+      1403, /* GL_SAMPLER_1D */
+      1405, /* GL_SAMPLER_2D */
+      1407, /* GL_SAMPLER_3D */
+      1408, /* GL_SAMPLER_CUBE */
+      1404, /* GL_SAMPLER_1D_SHADOW */
+      1406, /* GL_SAMPLER_2D_SHADOW */
        493, /* GL_FLOAT_MAT2x3 */
        494, /* GL_FLOAT_MAT2x4 */
        497, /* GL_FLOAT_MAT3x2 */
@@ -5042,61 +5072,76 @@ static const unsigned reduced_enums[1357] =
        502, /* GL_FLOAT_MAT4x3 */
        346, /* GL_DELETE_STATUS */
        247, /* GL_COMPILE_STATUS */
-       717, /* GL_LINK_STATUS */
-      1815, /* GL_VALIDATE_STATUS */
+       718, /* GL_LINK_STATUS */
+      1830, /* GL_VALIDATE_STATUS */
        646, /* GL_INFO_LOG_LENGTH */
         56, /* GL_ATTACHED_SHADERS */
         20, /* GL_ACTIVE_UNIFORMS */
         21, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
-      1439, /* GL_SHADER_SOURCE_LENGTH */
+      1446, /* GL_SHADER_SOURCE_LENGTH */
         15, /* GL_ACTIVE_ATTRIBUTES */
         16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */
        540, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
-      1442, /* GL_SHADING_LANGUAGE_VERSION */
+      1449, /* GL_SHADING_LANGUAGE_VERSION */
        323, /* GL_CURRENT_PROGRAM */
-      1104, /* GL_PALETTE4_RGB8_OES */
-      1106, /* GL_PALETTE4_RGBA8_OES */
-      1102, /* GL_PALETTE4_R5_G6_B5_OES */
-      1105, /* GL_PALETTE4_RGBA4_OES */
-      1103, /* GL_PALETTE4_RGB5_A1_OES */
-      1109, /* GL_PALETTE8_RGB8_OES */
-      1111, /* GL_PALETTE8_RGBA8_OES */
-      1107, /* GL_PALETTE8_R5_G6_B5_OES */
-      1110, /* GL_PALETTE8_RGBA4_OES */
-      1108, /* GL_PALETTE8_RGB5_A1_OES */
+      1108, /* GL_PALETTE4_RGB8_OES */
+      1110, /* GL_PALETTE4_RGBA8_OES */
+      1106, /* GL_PALETTE4_R5_G6_B5_OES */
+      1109, /* GL_PALETTE4_RGBA4_OES */
+      1107, /* GL_PALETTE4_RGB5_A1_OES */
+      1113, /* GL_PALETTE8_RGB8_OES */
+      1115, /* GL_PALETTE8_RGBA8_OES */
+      1111, /* GL_PALETTE8_R5_G6_B5_OES */
+      1114, /* GL_PALETTE8_RGBA4_OES */
+      1112, /* GL_PALETTE8_RGB5_A1_OES */
        628, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
        627, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-      1800, /* GL_UNSIGNED_NORMALIZED */
-      1637, /* GL_TEXTURE_1D_ARRAY_EXT */
-      1274, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-      1639, /* GL_TEXTURE_2D_ARRAY_EXT */
-      1277, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-      1645, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-      1647, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-      1495, /* GL_SRGB */
-      1496, /* GL_SRGB8 */
-      1498, /* GL_SRGB_ALPHA */
-      1497, /* GL_SRGB8_ALPHA8 */
-      1455, /* GL_SLUMINANCE_ALPHA */
-      1454, /* GL_SLUMINANCE8_ALPHA8 */
-      1452, /* GL_SLUMINANCE */
-      1453, /* GL_SLUMINANCE8 */
+      1815, /* GL_UNSIGNED_NORMALIZED */
+      1644, /* GL_TEXTURE_1D_ARRAY_EXT */
+      1279, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
+      1646, /* GL_TEXTURE_2D_ARRAY_EXT */
+      1282, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
+      1652, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
+      1654, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
+      1502, /* GL_SRGB */
+      1503, /* GL_SRGB8 */
+      1505, /* GL_SRGB_ALPHA */
+      1504, /* GL_SRGB8_ALPHA8 */
+      1462, /* GL_SLUMINANCE_ALPHA */
+      1461, /* GL_SLUMINANCE8_ALPHA8 */
+      1459, /* GL_SLUMINANCE */
+      1460, /* GL_SLUMINANCE8 */
        268, /* GL_COMPRESSED_SRGB */
        269, /* GL_COMPRESSED_SRGB_ALPHA */
        266, /* GL_COMPRESSED_SLUMINANCE */
        267, /* GL_COMPRESSED_SLUMINANCE_ALPHA */
-      1169, /* GL_POINT_SPRITE_COORD_ORIGIN */
-       725, /* GL_LOWER_LEFT */
-      1812, /* GL_UPPER_LEFT */
-      1518, /* GL_STENCIL_BACK_REF */
-      1519, /* GL_STENCIL_BACK_VALUE_MASK */
-      1520, /* GL_STENCIL_BACK_WRITEMASK */
+      1778, /* GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT */
+      1773, /* GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT */
+       943, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT */
+      1777, /* GL_TRANSFORM_FEEDBACK_VARYINGS_EXT */
+      1775, /* GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT */
+      1774, /* GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT */
+      1236, /* GL_PRIMITIVES_GENERATED_EXT */
+      1776, /* GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT */
+      1310, /* GL_RASTERIZER_DISCARD_EXT */
+       941, /* GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT */
+       942, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT */
+       658, /* GL_INTERLEAVED_ATTRIBS_EXT */
+      1441, /* GL_SEPARATE_ATTRIBS_EXT */
+      1772, /* GL_TRANSFORM_FEEDBACK_BUFFER_EXT */
+      1771, /* GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT */
+      1173, /* GL_POINT_SPRITE_COORD_ORIGIN */
+       726, /* GL_LOWER_LEFT */
+      1827, /* GL_UPPER_LEFT */
+      1525, /* GL_STENCIL_BACK_REF */
+      1526, /* GL_STENCIL_BACK_VALUE_MASK */
+      1527, /* GL_STENCIL_BACK_WRITEMASK */
        445, /* GL_DRAW_FRAMEBUFFER_BINDING */
-      1328, /* GL_RENDERBUFFER_BINDING */
-      1307, /* GL_READ_FRAMEBUFFER */
+      1334, /* GL_RENDERBUFFER_BINDING */
+      1313, /* GL_READ_FRAMEBUFFER */
        444, /* GL_DRAW_FRAMEBUFFER */
-      1308, /* GL_READ_FRAMEBUFFER_BINDING */
-      1339, /* GL_RENDERBUFFER_SAMPLES */
+      1314, /* GL_READ_FRAMEBUFFER_BINDING */
+      1345, /* GL_RENDERBUFFER_SAMPLES */
        550, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
        548, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
        559, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
@@ -5112,7 +5157,7 @@ static const unsigned reduced_enums[1357] =
        578, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER */
        582, /* GL_FRAMEBUFFER_UNSUPPORTED */
        580, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
-       865, /* GL_MAX_COLOR_ATTACHMENTS */
+       866, /* GL_MAX_COLOR_ATTACHMENTS */
        156, /* GL_COLOR_ATTACHMENT0 */
        158, /* GL_COLOR_ATTACHMENT1 */
        172, /* GL_COLOR_ATTACHMENT2 */
@@ -5130,58 +5175,58 @@ static const unsigned reduced_enums[1357] =
        167, /* GL_COLOR_ATTACHMENT14 */
        169, /* GL_COLOR_ATTACHMENT15 */
        350, /* GL_DEPTH_ATTACHMENT */
-      1508, /* GL_STENCIL_ATTACHMENT */
+      1515, /* GL_STENCIL_ATTACHMENT */
        541, /* GL_FRAMEBUFFER */
-      1326, /* GL_RENDERBUFFER */
-      1342, /* GL_RENDERBUFFER_WIDTH */
-      1334, /* GL_RENDERBUFFER_HEIGHT */
-      1336, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
-      1535, /* GL_STENCIL_INDEX_EXT */
-      1527, /* GL_STENCIL_INDEX1 */
-      1531, /* GL_STENCIL_INDEX4 */
-      1533, /* GL_STENCIL_INDEX8 */
-      1528, /* GL_STENCIL_INDEX16 */
-      1338, /* GL_RENDERBUFFER_RED_SIZE */
-      1333, /* GL_RENDERBUFFER_GREEN_SIZE */
-      1330, /* GL_RENDERBUFFER_BLUE_SIZE */
-      1327, /* GL_RENDERBUFFER_ALPHA_SIZE */
-      1331, /* GL_RENDERBUFFER_DEPTH_SIZE */
-      1341, /* GL_RENDERBUFFER_STENCIL_SIZE */
+      1332, /* GL_RENDERBUFFER */
+      1348, /* GL_RENDERBUFFER_WIDTH */
+      1340, /* GL_RENDERBUFFER_HEIGHT */
+      1342, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+      1542, /* GL_STENCIL_INDEX_EXT */
+      1534, /* GL_STENCIL_INDEX1 */
+      1538, /* GL_STENCIL_INDEX4 */
+      1540, /* GL_STENCIL_INDEX8 */
+      1535, /* GL_STENCIL_INDEX16 */
+      1344, /* GL_RENDERBUFFER_RED_SIZE */
+      1339, /* GL_RENDERBUFFER_GREEN_SIZE */
+      1336, /* GL_RENDERBUFFER_BLUE_SIZE */
+      1333, /* GL_RENDERBUFFER_ALPHA_SIZE */
+      1337, /* GL_RENDERBUFFER_DEPTH_SIZE */
+      1347, /* GL_RENDERBUFFER_STENCIL_SIZE */
        576, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
-       923, /* GL_MAX_SAMPLES */
-      1302, /* GL_QUERY_WAIT_NV */
-      1297, /* GL_QUERY_NO_WAIT_NV */
-      1294, /* GL_QUERY_BY_REGION_WAIT_NV */
-      1293, /* GL_QUERY_BY_REGION_NO_WAIT_NV */
-      1289, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */
+       924, /* GL_MAX_SAMPLES */
+      1307, /* GL_QUERY_WAIT_NV */
+      1302, /* GL_QUERY_NO_WAIT_NV */
+      1299, /* GL_QUERY_BY_REGION_WAIT_NV */
+      1298, /* GL_QUERY_BY_REGION_NO_WAIT_NV */
+      1294, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */
        487, /* GL_FIRST_VERTEX_CONVENTION */
-       676, /* GL_LAST_VERTEX_CONVENTION */
-      1266, /* GL_PROVOKING_VERTEX */
+       677, /* GL_LAST_VERTEX_CONVENTION */
+      1271, /* GL_PROVOKING_VERTEX */
        303, /* GL_COPY_READ_BUFFER */
        304, /* GL_COPY_WRITE_BUFFER */
-      1390, /* GL_RGBA_SNORM */
-      1386, /* GL_RGBA8_SNORM */
-      1448, /* GL_SIGNED_NORMALIZED */
-       925, /* GL_MAX_SERVER_WAIT_TIMEOUT */
-      1054, /* GL_OBJECT_TYPE */
-      1556, /* GL_SYNC_CONDITION */
-      1561, /* GL_SYNC_STATUS */
-      1558, /* GL_SYNC_FLAGS */
-      1557, /* GL_SYNC_FENCE */
-      1560, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
-      1788, /* GL_UNSIGNALED */
-      1447, /* GL_SIGNALED */
+      1396, /* GL_RGBA_SNORM */
+      1392, /* GL_RGBA8_SNORM */
+      1455, /* GL_SIGNED_NORMALIZED */
+       926, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+      1058, /* GL_OBJECT_TYPE */
+      1563, /* GL_SYNC_CONDITION */
+      1568, /* GL_SYNC_STATUS */
+      1565, /* GL_SYNC_FLAGS */
+      1564, /* GL_SYNC_FENCE */
+      1567, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+      1803, /* GL_UNSIGNALED */
+      1454, /* GL_SIGNALED */
         46, /* GL_ALREADY_SIGNALED */
-      1759, /* GL_TIMEOUT_EXPIRED */
+      1766, /* GL_TIMEOUT_EXPIRED */
        271, /* GL_CONDITION_SATISFIED */
-      1873, /* GL_WAIT_FAILED */
+      1888, /* GL_WAIT_FAILED */
        472, /* GL_EVAL_BIT */
-      1305, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-       719, /* GL_LIST_BIT */
-      1653, /* GL_TEXTURE_BIT */
-      1421, /* GL_SCISSOR_BIT */
+      1311, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+       720, /* GL_LIST_BIT */
+      1660, /* GL_TEXTURE_BIT */
+      1427, /* GL_SCISSOR_BIT */
         29, /* GL_ALL_ATTRIB_BITS */
-      1010, /* GL_MULTISAMPLE_BIT */
+      1014, /* GL_MULTISAMPLE_BIT */
         30, /* GL_ALL_CLIENT_ATTRIB_BITS */
 };
 
diff --git a/src/mesa/main/extensions.c b/src/mesa/main/extensions.c
index f7b0e5abf59..208069c1db5 100644
--- a/src/mesa/main/extensions.c
+++ b/src/mesa/main/extensions.c
@@ -50,6 +50,7 @@ static const struct {
    { OFF, "GL_ARB_depth_clamp",                F(ARB_depth_clamp) },
    { ON,  "GL_ARB_draw_buffers",               F(ARB_draw_buffers) },
    { OFF, "GL_ARB_draw_elements_base_vertex",  F(ARB_draw_elements_base_vertex) },
+   { OFF, "GL_ARB_draw_instanced",             F(ARB_draw_instanced) },
    { OFF, "GL_ARB_fragment_coord_conventions", F(ARB_fragment_coord_conventions) },
    { OFF, "GL_ARB_fragment_program",           F(ARB_fragment_program) },
    { OFF, "GL_ARB_fragment_program_shadow",    F(ARB_fragment_program_shadow) },
@@ -106,6 +107,7 @@ static const struct {
    { ON,  "GL_EXT_copy_texture",               F(EXT_copy_texture) },
    { OFF, "GL_EXT_depth_bounds_test",          F(EXT_depth_bounds_test) },
    { OFF, "GL_EXT_draw_buffers2",              F(EXT_draw_buffers2) },
+   { OFF, "GL_EXT_draw_instanced",             F(ARB_draw_instanced) },
    { ON,  "GL_EXT_draw_range_elements",        F(EXT_draw_range_elements) },
    { OFF, "GL_EXT_framebuffer_blit",           F(EXT_framebuffer_blit) },
    { OFF, "GL_EXT_framebuffer_multisample",    F(EXT_framebuffer_multisample) },
@@ -195,6 +197,9 @@ static const struct {
    { ON,  "GL_SGIS_texture_lod",               F(SGIS_texture_lod) },
    { ON,  "GL_SUN_multi_draw_arrays",          F(EXT_multi_draw_arrays) },
    { OFF, "GL_S3_s3tc",                        F(S3_s3tc) },
+#if FEATURE_OES_EGL_image
+   { OFF, "GL_OES_EGL_image",                  F(OES_EGL_image) },
+#endif
 #if FEATURE_OES_draw_texture
    { OFF, "GL_OES_draw_texture",               F(OES_draw_texture) },
 #endif /* FEATURE_OES_draw_texture */
@@ -321,7 +326,7 @@ _mesa_enable_sw_extensions(GLcontext *ctx)
 #endif
    ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
 #if FEATURE_EXT_transform_feedback
-   ctx->Extensions.EXT_transform_feedback = GL_TRUE;
+   /*ctx->Extensions.EXT_transform_feedback = GL_TRUE;*/
 #endif
    ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
    /*ctx->Extensions.IBM_multimode_draw_arrays = GL_TRUE;*/
diff --git a/src/mesa/main/fbobject.c b/src/mesa/main/fbobject.c
index e3e006bb948..8d442466187 100644
--- a/src/mesa/main/fbobject.c
+++ b/src/mesa/main/fbobject.c
@@ -1020,6 +1020,12 @@ _mesa_EGLImageTargetRenderbufferStorageOES (GLenum target, GLeglImageOES image)
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
+   if (!ctx->Extensions.OES_EGL_image) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glEGLImageTargetRenderbufferStorageOES(unsupported)");
+      return;
+   }
+
    if (target != GL_RENDERBUFFER) {
       _mesa_error(ctx, GL_INVALID_ENUM, "EGLImageTargetRenderbufferStorageOES");
       return;
diff --git a/src/mesa/main/ffvertex_prog.c b/src/mesa/main/ffvertex_prog.c
index ba94a38770b..70ac47f36d7 100644
--- a/src/mesa/main/ffvertex_prog.c
+++ b/src/mesa/main/ffvertex_prog.c
@@ -75,6 +75,7 @@ struct state_key {
       unsigned light_attenuated:1;
       unsigned texunit_really_enabled:1;
       unsigned texmat_enabled:1;
+      unsigned coord_replace:1;
       unsigned texgen_enabled:4;
       unsigned texgen_mode0:4;
       unsigned texgen_mode1:4;
@@ -225,6 +226,10 @@ static void make_state_key( GLcontext *ctx, struct state_key *key )
       if (texUnit->_ReallyEnabled)
 	 key->unit[i].texunit_really_enabled = 1;
 
+      if (ctx->Point.PointSprite)
+	 if (ctx->Point.CoordReplace[i])
+	    key->unit[i].coord_replace = 1;
+
       if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i))
 	 key->unit[i].texmat_enabled = 1;
 
@@ -1385,6 +1390,9 @@ static void build_texture_transform( struct tnl_program *p )
       if (!(p->state->fragprog_inputs_read & FRAG_BIT_TEX(i)))
 	 continue;
 
+      if (p->state->unit[i].coord_replace)
+  	 continue;
+
       if (p->state->unit[i].texgen_enabled ||
 	  p->state->unit[i].texmat_enabled) {
 
diff --git a/src/mesa/main/get.c b/src/mesa/main/get.c
index eaa6d7f7307..6f38658cc10 100644
--- a/src/mesa/main/get.c
+++ b/src/mesa/main/get.c
@@ -1791,10 +1791,14 @@ _mesa_GetBooleanv( GLenum pname, GLboolean *params )
          break;
       case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
          CHECK_EXT1(OES_read_format, "GetBooleanv");
+         if (ctx->NewState & _NEW_BUFFERS)
+            _mesa_update_state(ctx);
          params[0] = INT_TO_BOOLEAN(_mesa_get_color_read_type(ctx));
          break;
       case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
          CHECK_EXT1(OES_read_format, "GetBooleanv");
+         if (ctx->NewState & _NEW_BUFFERS)
+            _mesa_update_state(ctx);
          params[0] = INT_TO_BOOLEAN(_mesa_get_color_read_format(ctx));
          break;
       case GL_NUM_FRAGMENT_REGISTERS_ATI:
@@ -3682,10 +3686,14 @@ _mesa_GetFloatv( GLenum pname, GLfloat *params )
          break;
       case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
          CHECK_EXT1(OES_read_format, "GetFloatv");
+         if (ctx->NewState & _NEW_BUFFERS)
+            _mesa_update_state(ctx);
          params[0] = (GLfloat)(_mesa_get_color_read_type(ctx));
          break;
       case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
          CHECK_EXT1(OES_read_format, "GetFloatv");
+         if (ctx->NewState & _NEW_BUFFERS)
+            _mesa_update_state(ctx);
          params[0] = (GLfloat)(_mesa_get_color_read_format(ctx));
          break;
       case GL_NUM_FRAGMENT_REGISTERS_ATI:
@@ -5573,10 +5581,14 @@ _mesa_GetIntegerv( GLenum pname, GLint *params )
          break;
       case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
          CHECK_EXT1(OES_read_format, "GetIntegerv");
+         if (ctx->NewState & _NEW_BUFFERS)
+            _mesa_update_state(ctx);
          params[0] = _mesa_get_color_read_type(ctx);
          break;
       case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
          CHECK_EXT1(OES_read_format, "GetIntegerv");
+         if (ctx->NewState & _NEW_BUFFERS)
+            _mesa_update_state(ctx);
          params[0] = _mesa_get_color_read_format(ctx);
          break;
       case GL_NUM_FRAGMENT_REGISTERS_ATI:
@@ -7465,10 +7477,14 @@ _mesa_GetInteger64v( GLenum pname, GLint64 *params )
          break;
       case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
          CHECK_EXT1(OES_read_format, "GetInteger64v");
+         if (ctx->NewState & _NEW_BUFFERS)
+            _mesa_update_state(ctx);
          params[0] = (GLint64)(_mesa_get_color_read_type(ctx));
          break;
       case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
          CHECK_EXT1(OES_read_format, "GetInteger64v");
+         if (ctx->NewState & _NEW_BUFFERS)
+            _mesa_update_state(ctx);
          params[0] = (GLint64)(_mesa_get_color_read_format(ctx));
          break;
       case GL_NUM_FRAGMENT_REGISTERS_ATI:
diff --git a/src/mesa/main/get_gen.py b/src/mesa/main/get_gen.py
index bfaca1536d1..d6a6d0b18fa 100644
--- a/src/mesa/main/get_gen.py
+++ b/src/mesa/main/get_gen.py
@@ -1015,9 +1015,9 @@ StateVars = [
 
 	# GL_OES_read_format
 	( "GL_IMPLEMENTATION_COLOR_READ_TYPE_OES", GLint,
-	  ["_mesa_get_color_read_type(ctx)"], "", NoState, ["OES_read_format"] ),
+	  ["_mesa_get_color_read_type(ctx)"], "", "_NEW_BUFFERS", ["OES_read_format"] ),
 	( "GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES", GLint,
-	  ["_mesa_get_color_read_format(ctx)"], "", NoState, ["OES_read_format"] ),
+	  ["_mesa_get_color_read_format(ctx)"], "", "_NEW_BUFFERS", ["OES_read_format"] ),
 
 	# GL_ATI_fragment_shader
 	( "GL_NUM_FRAGMENT_REGISTERS_ATI", GLint, ["6"],
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 7657efb0773..688172a2c01 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -2443,6 +2443,7 @@ struct gl_extensions
    GLboolean ARB_depth_clamp;
    GLboolean ARB_draw_buffers;
    GLboolean ARB_draw_elements_base_vertex;
+   GLboolean ARB_draw_instanced;
    GLboolean ARB_fragment_coord_conventions;
    GLboolean ARB_fragment_program;
    GLboolean ARB_fragment_program_shadow;
@@ -2572,6 +2573,9 @@ struct gl_extensions
    GLboolean SGIS_texture_lod;
    GLboolean TDFX_texture_compression_FXT1;
    GLboolean S3_s3tc;
+#if FEATURE_OES_EGL_image
+   GLboolean OES_EGL_image;
+#endif
 #if FEATURE_OES_draw_texture
    GLboolean OES_draw_texture;
 #endif /* FEATURE_OES_draw_texture */
diff --git a/src/mesa/main/remap.c b/src/mesa/main/remap.c
index 8d9df6b8309..bfceb43c974 100644
--- a/src/mesa/main/remap.c
+++ b/src/mesa/main/remap.c
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 
diff --git a/src/mesa/main/remap.h b/src/mesa/main/remap.h
index 7fb56e36005..d080188d89f 100644
--- a/src/mesa/main/remap.h
+++ b/src/mesa/main/remap.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  */
 
 
diff --git a/src/mesa/main/remap_helper.h b/src/mesa/main/remap_helper.h
index ee898efa5f9..52edf67b545 100644
--- a/src/mesa/main/remap_helper.h
+++ b/src/mesa/main/remap_helper.h
@@ -1242,3137 +1242,3183 @@ static const char _mesa_function_pool[] =
    "iip\0"
    "glGetTexGendv\0"
    "\0"
-   /* _mesa_function_pool[8307]: ColorMaskIndexedEXT (will be remapped) */
-   "iiiii\0"
-   "glColorMaskIndexedEXT\0"
+   /* _mesa_function_pool[8307]: GetVertexAttribfvNV (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribfvNV\0"
+   "\0"
+   /* _mesa_function_pool[8334]: BeginTransformFeedbackEXT (will be remapped) */
+   "i\0"
+   "glBeginTransformFeedbackEXT\0"
+   "glBeginTransformFeedback\0"
    "\0"
-   /* _mesa_function_pool[8336]: LoadProgramNV (will be remapped) */
+   /* _mesa_function_pool[8390]: LoadProgramNV (will be remapped) */
    "iiip\0"
    "glLoadProgramNV\0"
    "\0"
-   /* _mesa_function_pool[8358]: WaitSync (will be remapped) */
+   /* _mesa_function_pool[8412]: WaitSync (will be remapped) */
    "iii\0"
    "glWaitSync\0"
    "\0"
-   /* _mesa_function_pool[8374]: EndList (offset 1) */
+   /* _mesa_function_pool[8428]: EndList (offset 1) */
    "\0"
    "glEndList\0"
    "\0"
-   /* _mesa_function_pool[8386]: VertexAttrib4fvNV (will be remapped) */
+   /* _mesa_function_pool[8440]: VertexAttrib4fvNV (will be remapped) */
    "ip\0"
    "glVertexAttrib4fvNV\0"
    "\0"
-   /* _mesa_function_pool[8410]: GetAttachedObjectsARB (will be remapped) */
+   /* _mesa_function_pool[8464]: GetAttachedObjectsARB (will be remapped) */
    "iipp\0"
    "glGetAttachedObjectsARB\0"
    "\0"
-   /* _mesa_function_pool[8440]: Uniform3fvARB (will be remapped) */
+   /* _mesa_function_pool[8494]: Uniform3fvARB (will be remapped) */
    "iip\0"
    "glUniform3fv\0"
    "glUniform3fvARB\0"
    "\0"
-   /* _mesa_function_pool[8474]: EvalCoord1fv (offset 231) */
+   /* _mesa_function_pool[8528]: EvalCoord1fv (offset 231) */
    "p\0"
    "glEvalCoord1fv\0"
    "\0"
-   /* _mesa_function_pool[8492]: DrawRangeElements (offset 338) */
+   /* _mesa_function_pool[8546]: DrawRangeElements (offset 338) */
    "iiiiip\0"
    "glDrawRangeElements\0"
    "glDrawRangeElementsEXT\0"
    "\0"
-   /* _mesa_function_pool[8543]: EvalMesh2 (offset 238) */
+   /* _mesa_function_pool[8597]: EvalMesh2 (offset 238) */
    "iiiii\0"
    "glEvalMesh2\0"
    "\0"
-   /* _mesa_function_pool[8562]: Vertex4fv (offset 145) */
+   /* _mesa_function_pool[8616]: Vertex4fv (offset 145) */
    "p\0"
    "glVertex4fv\0"
    "\0"
-   /* _mesa_function_pool[8577]: SpriteParameterfvSGIX (dynamic) */
+   /* _mesa_function_pool[8631]: SpriteParameterfvSGIX (dynamic) */
    "ip\0"
    "glSpriteParameterfvSGIX\0"
    "\0"
-   /* _mesa_function_pool[8605]: CheckFramebufferStatusEXT (will be remapped) */
+   /* _mesa_function_pool[8659]: CheckFramebufferStatusEXT (will be remapped) */
    "i\0"
    "glCheckFramebufferStatus\0"
    "glCheckFramebufferStatusEXT\0"
    "\0"
-   /* _mesa_function_pool[8661]: GlobalAlphaFactoruiSUN (dynamic) */
+   /* _mesa_function_pool[8715]: GlobalAlphaFactoruiSUN (dynamic) */
    "i\0"
    "glGlobalAlphaFactoruiSUN\0"
    "\0"
-   /* _mesa_function_pool[8689]: GetHandleARB (will be remapped) */
+   /* _mesa_function_pool[8743]: GetHandleARB (will be remapped) */
    "i\0"
    "glGetHandleARB\0"
    "\0"
-   /* _mesa_function_pool[8707]: GetVertexAttribivARB (will be remapped) */
+   /* _mesa_function_pool[8761]: GetVertexAttribivARB (will be remapped) */
    "iip\0"
    "glGetVertexAttribiv\0"
    "glGetVertexAttribivARB\0"
    "\0"
-   /* _mesa_function_pool[8755]: GetCombinerInputParameterfvNV (will be remapped) */
+   /* _mesa_function_pool[8809]: GetCombinerInputParameterfvNV (will be remapped) */
    "iiiip\0"
    "glGetCombinerInputParameterfvNV\0"
    "\0"
-   /* _mesa_function_pool[8794]: CreateProgram (will be remapped) */
+   /* _mesa_function_pool[8848]: CreateProgram (will be remapped) */
    "\0"
    "glCreateProgram\0"
    "\0"
-   /* _mesa_function_pool[8812]: LoadTransposeMatrixdARB (will be remapped) */
+   /* _mesa_function_pool[8866]: LoadTransposeMatrixdARB (will be remapped) */
    "p\0"
    "glLoadTransposeMatrixd\0"
    "glLoadTransposeMatrixdARB\0"
    "\0"
-   /* _mesa_function_pool[8864]: GetMinmax (offset 364) */
+   /* _mesa_function_pool[8918]: GetMinmax (offset 364) */
    "iiiip\0"
    "glGetMinmax\0"
    "glGetMinmaxEXT\0"
    "\0"
-   /* _mesa_function_pool[8898]: StencilFuncSeparate (will be remapped) */
+   /* _mesa_function_pool[8952]: StencilFuncSeparate (will be remapped) */
    "iiii\0"
    "glStencilFuncSeparate\0"
    "\0"
-   /* _mesa_function_pool[8926]: SecondaryColor3sEXT (will be remapped) */
+   /* _mesa_function_pool[8980]: SecondaryColor3sEXT (will be remapped) */
    "iii\0"
    "glSecondaryColor3s\0"
    "glSecondaryColor3sEXT\0"
    "\0"
-   /* _mesa_function_pool[8972]: Color3fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[9026]: Color3fVertex3fvSUN (dynamic) */
    "pp\0"
    "glColor3fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[8998]: Normal3fv (offset 57) */
+   /* _mesa_function_pool[9052]: Normal3fv (offset 57) */
    "p\0"
    "glNormal3fv\0"
    "\0"
-   /* _mesa_function_pool[9013]: GlobalAlphaFactorbSUN (dynamic) */
+   /* _mesa_function_pool[9067]: GlobalAlphaFactorbSUN (dynamic) */
    "i\0"
    "glGlobalAlphaFactorbSUN\0"
    "\0"
-   /* _mesa_function_pool[9040]: Color3us (offset 23) */
+   /* _mesa_function_pool[9094]: Color3us (offset 23) */
    "iii\0"
    "glColor3us\0"
    "\0"
-   /* _mesa_function_pool[9056]: ImageTransformParameterfvHP (dynamic) */
+   /* _mesa_function_pool[9110]: ImageTransformParameterfvHP (dynamic) */
    "iip\0"
    "glImageTransformParameterfvHP\0"
    "\0"
-   /* _mesa_function_pool[9091]: VertexAttrib4ivARB (will be remapped) */
+   /* _mesa_function_pool[9145]: VertexAttrib4ivARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4iv\0"
    "glVertexAttrib4ivARB\0"
    "\0"
-   /* _mesa_function_pool[9134]: End (offset 43) */
+   /* _mesa_function_pool[9188]: End (offset 43) */
    "\0"
    "glEnd\0"
    "\0"
-   /* _mesa_function_pool[9142]: VertexAttrib3fNV (will be remapped) */
+   /* _mesa_function_pool[9196]: VertexAttrib3fNV (will be remapped) */
    "ifff\0"
    "glVertexAttrib3fNV\0"
    "\0"
-   /* _mesa_function_pool[9167]: VertexAttribs2dvNV (will be remapped) */
+   /* _mesa_function_pool[9221]: VertexAttribs2dvNV (will be remapped) */
    "iip\0"
    "glVertexAttribs2dvNV\0"
    "\0"
-   /* _mesa_function_pool[9193]: GetQueryObjectui64vEXT (will be remapped) */
+   /* _mesa_function_pool[9247]: GetQueryObjectui64vEXT (will be remapped) */
    "iip\0"
    "glGetQueryObjectui64vEXT\0"
    "\0"
-   /* _mesa_function_pool[9223]: MultiTexCoord3fvARB (offset 395) */
+   /* _mesa_function_pool[9277]: MultiTexCoord3fvARB (offset 395) */
    "ip\0"
    "glMultiTexCoord3fv\0"
    "glMultiTexCoord3fvARB\0"
    "\0"
-   /* _mesa_function_pool[9268]: SecondaryColor3dEXT (will be remapped) */
+   /* _mesa_function_pool[9322]: SecondaryColor3dEXT (will be remapped) */
    "ddd\0"
    "glSecondaryColor3d\0"
    "glSecondaryColor3dEXT\0"
    "\0"
-   /* _mesa_function_pool[9314]: Color3ub (offset 19) */
+   /* _mesa_function_pool[9368]: Color3ub (offset 19) */
    "iii\0"
    "glColor3ub\0"
    "\0"
-   /* _mesa_function_pool[9330]: GetProgramParameterfvNV (will be remapped) */
+   /* _mesa_function_pool[9384]: GetProgramParameterfvNV (will be remapped) */
    "iiip\0"
    "glGetProgramParameterfvNV\0"
    "\0"
-   /* _mesa_function_pool[9362]: TangentPointerEXT (dynamic) */
+   /* _mesa_function_pool[9416]: TangentPointerEXT (dynamic) */
    "iip\0"
    "glTangentPointerEXT\0"
    "\0"
-   /* _mesa_function_pool[9387]: Color4fNormal3fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[9441]: Color4fNormal3fVertex3fvSUN (dynamic) */
    "ppp\0"
    "glColor4fNormal3fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[9422]: GetInstrumentsSGIX (dynamic) */
+   /* _mesa_function_pool[9476]: GetInstrumentsSGIX (dynamic) */
    "\0"
    "glGetInstrumentsSGIX\0"
    "\0"
-   /* _mesa_function_pool[9445]: Color3ui (offset 21) */
+   /* _mesa_function_pool[9499]: Color3ui (offset 21) */
    "iii\0"
    "glColor3ui\0"
    "\0"
-   /* _mesa_function_pool[9461]: EvalMapsNV (dynamic) */
+   /* _mesa_function_pool[9515]: EvalMapsNV (dynamic) */
    "ii\0"
    "glEvalMapsNV\0"
    "\0"
-   /* _mesa_function_pool[9478]: TexSubImage2D (offset 333) */
+   /* _mesa_function_pool[9532]: TexSubImage2D (offset 333) */
    "iiiiiiiip\0"
    "glTexSubImage2D\0"
    "glTexSubImage2DEXT\0"
    "\0"
-   /* _mesa_function_pool[9524]: FragmentLightivSGIX (dynamic) */
+   /* _mesa_function_pool[9578]: FragmentLightivSGIX (dynamic) */
    "iip\0"
    "glFragmentLightivSGIX\0"
    "\0"
-   /* _mesa_function_pool[9551]: GetTexParameterPointervAPPLE (will be remapped) */
+   /* _mesa_function_pool[9605]: GetTexParameterPointervAPPLE (will be remapped) */
    "iip\0"
    "glGetTexParameterPointervAPPLE\0"
    "\0"
-   /* _mesa_function_pool[9587]: TexGenfv (offset 191) */
+   /* _mesa_function_pool[9641]: TexGenfv (offset 191) */
    "iip\0"
    "glTexGenfv\0"
    "\0"
-   /* _mesa_function_pool[9603]: PixelTransformParameterfvEXT (dynamic) */
-   "iip\0"
-   "glPixelTransformParameterfvEXT\0"
+   /* _mesa_function_pool[9657]: GetTransformFeedbackVaryingEXT (will be remapped) */
+   "iiipppp\0"
+   "glGetTransformFeedbackVaryingEXT\0"
+   "glGetTransformFeedbackVarying\0"
    "\0"
-   /* _mesa_function_pool[9639]: VertexAttrib4bvARB (will be remapped) */
+   /* _mesa_function_pool[9729]: VertexAttrib4bvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4bv\0"
    "glVertexAttrib4bvARB\0"
    "\0"
-   /* _mesa_function_pool[9682]: AlphaFragmentOp2ATI (will be remapped) */
+   /* _mesa_function_pool[9772]: AlphaFragmentOp2ATI (will be remapped) */
    "iiiiiiiii\0"
    "glAlphaFragmentOp2ATI\0"
    "\0"
-   /* _mesa_function_pool[9715]: GetIntegerIndexedvEXT (will be remapped) */
+   /* _mesa_function_pool[9805]: GetIntegerIndexedvEXT (will be remapped) */
    "iip\0"
    "glGetIntegerIndexedvEXT\0"
    "\0"
-   /* _mesa_function_pool[9744]: MultiTexCoord4sARB (offset 406) */
+   /* _mesa_function_pool[9834]: MultiTexCoord4sARB (offset 406) */
    "iiiii\0"
    "glMultiTexCoord4s\0"
    "glMultiTexCoord4sARB\0"
    "\0"
-   /* _mesa_function_pool[9790]: GetFragmentMaterialivSGIX (dynamic) */
+   /* _mesa_function_pool[9880]: GetFragmentMaterialivSGIX (dynamic) */
    "iip\0"
    "glGetFragmentMaterialivSGIX\0"
    "\0"
-   /* _mesa_function_pool[9823]: WindowPos4dMESA (will be remapped) */
+   /* _mesa_function_pool[9913]: WindowPos4dMESA (will be remapped) */
    "dddd\0"
    "glWindowPos4dMESA\0"
    "\0"
-   /* _mesa_function_pool[9847]: WeightPointerARB (dynamic) */
+   /* _mesa_function_pool[9937]: WeightPointerARB (dynamic) */
    "iiip\0"
    "glWeightPointerARB\0"
    "\0"
-   /* _mesa_function_pool[9872]: WindowPos2dMESA (will be remapped) */
+   /* _mesa_function_pool[9962]: WindowPos2dMESA (will be remapped) */
    "dd\0"
    "glWindowPos2d\0"
    "glWindowPos2dARB\0"
    "glWindowPos2dMESA\0"
    "\0"
-   /* _mesa_function_pool[9925]: FramebufferTexture3DEXT (will be remapped) */
+   /* _mesa_function_pool[10015]: FramebufferTexture3DEXT (will be remapped) */
    "iiiiii\0"
    "glFramebufferTexture3D\0"
    "glFramebufferTexture3DEXT\0"
    "\0"
-   /* _mesa_function_pool[9982]: BlendEquation (offset 337) */
+   /* _mesa_function_pool[10072]: BlendEquation (offset 337) */
    "i\0"
    "glBlendEquation\0"
    "glBlendEquationEXT\0"
    "\0"
-   /* _mesa_function_pool[10020]: VertexAttrib3dNV (will be remapped) */
+   /* _mesa_function_pool[10110]: VertexAttrib3dNV (will be remapped) */
    "iddd\0"
    "glVertexAttrib3dNV\0"
    "\0"
-   /* _mesa_function_pool[10045]: VertexAttrib3dARB (will be remapped) */
+   /* _mesa_function_pool[10135]: VertexAttrib3dARB (will be remapped) */
    "iddd\0"
    "glVertexAttrib3d\0"
    "glVertexAttrib3dARB\0"
    "\0"
-   /* _mesa_function_pool[10088]: ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[10178]: ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (dynamic) */
    "ppppp\0"
    "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[10152]: VertexAttrib4fARB (will be remapped) */
+   /* _mesa_function_pool[10242]: VertexAttrib4fARB (will be remapped) */
    "iffff\0"
    "glVertexAttrib4f\0"
    "glVertexAttrib4fARB\0"
    "\0"
-   /* _mesa_function_pool[10196]: GetError (offset 261) */
+   /* _mesa_function_pool[10286]: GetError (offset 261) */
    "\0"
    "glGetError\0"
    "\0"
-   /* _mesa_function_pool[10209]: IndexFuncEXT (dynamic) */
+   /* _mesa_function_pool[10299]: IndexFuncEXT (dynamic) */
    "if\0"
    "glIndexFuncEXT\0"
    "\0"
-   /* _mesa_function_pool[10228]: TexCoord3dv (offset 111) */
+   /* _mesa_function_pool[10318]: TexCoord3dv (offset 111) */
    "p\0"
    "glTexCoord3dv\0"
    "\0"
-   /* _mesa_function_pool[10245]: Indexdv (offset 45) */
+   /* _mesa_function_pool[10335]: Indexdv (offset 45) */
    "p\0"
    "glIndexdv\0"
    "\0"
-   /* _mesa_function_pool[10258]: FramebufferTexture2DEXT (will be remapped) */
+   /* _mesa_function_pool[10348]: FramebufferTexture2DEXT (will be remapped) */
    "iiiii\0"
    "glFramebufferTexture2D\0"
    "glFramebufferTexture2DEXT\0"
    "\0"
-   /* _mesa_function_pool[10314]: Normal3s (offset 60) */
+   /* _mesa_function_pool[10404]: Normal3s (offset 60) */
    "iii\0"
    "glNormal3s\0"
    "\0"
-   /* _mesa_function_pool[10330]: GetObjectParameterivAPPLE (will be remapped) */
+   /* _mesa_function_pool[10420]: GetObjectParameterivAPPLE (will be remapped) */
    "iiip\0"
    "glGetObjectParameterivAPPLE\0"
    "\0"
-   /* _mesa_function_pool[10364]: PushName (offset 201) */
+   /* _mesa_function_pool[10454]: PushName (offset 201) */
    "i\0"
    "glPushName\0"
    "\0"
-   /* _mesa_function_pool[10378]: MultiTexCoord2dvARB (offset 385) */
+   /* _mesa_function_pool[10468]: MultiTexCoord2dvARB (offset 385) */
    "ip\0"
    "glMultiTexCoord2dv\0"
    "glMultiTexCoord2dvARB\0"
    "\0"
-   /* _mesa_function_pool[10423]: CullParameterfvEXT (will be remapped) */
+   /* _mesa_function_pool[10513]: CullParameterfvEXT (will be remapped) */
    "ip\0"
    "glCullParameterfvEXT\0"
    "\0"
-   /* _mesa_function_pool[10448]: Normal3i (offset 58) */
+   /* _mesa_function_pool[10538]: Normal3i (offset 58) */
    "iii\0"
    "glNormal3i\0"
    "\0"
-   /* _mesa_function_pool[10464]: ProgramNamedParameter4fvNV (will be remapped) */
+   /* _mesa_function_pool[10554]: ProgramNamedParameter4fvNV (will be remapped) */
    "iipp\0"
    "glProgramNamedParameter4fvNV\0"
    "\0"
-   /* _mesa_function_pool[10499]: SecondaryColorPointerEXT (will be remapped) */
+   /* _mesa_function_pool[10589]: SecondaryColorPointerEXT (will be remapped) */
    "iiip\0"
    "glSecondaryColorPointer\0"
    "glSecondaryColorPointerEXT\0"
    "\0"
-   /* _mesa_function_pool[10556]: VertexAttrib4fvARB (will be remapped) */
+   /* _mesa_function_pool[10646]: VertexAttrib4fvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4fv\0"
    "glVertexAttrib4fvARB\0"
    "\0"
-   /* _mesa_function_pool[10599]: ColorPointerListIBM (dynamic) */
+   /* _mesa_function_pool[10689]: ColorPointerListIBM (dynamic) */
    "iiipi\0"
    "glColorPointerListIBM\0"
    "\0"
-   /* _mesa_function_pool[10628]: GetActiveUniformARB (will be remapped) */
+   /* _mesa_function_pool[10718]: GetActiveUniformARB (will be remapped) */
    "iiipppp\0"
    "glGetActiveUniform\0"
    "glGetActiveUniformARB\0"
    "\0"
-   /* _mesa_function_pool[10678]: ImageTransformParameteriHP (dynamic) */
+   /* _mesa_function_pool[10768]: ImageTransformParameteriHP (dynamic) */
    "iii\0"
    "glImageTransformParameteriHP\0"
    "\0"
-   /* _mesa_function_pool[10712]: Normal3b (offset 52) */
+   /* _mesa_function_pool[10802]: Normal3b (offset 52) */
    "iii\0"
    "glNormal3b\0"
    "\0"
-   /* _mesa_function_pool[10728]: Normal3d (offset 54) */
+   /* _mesa_function_pool[10818]: Normal3d (offset 54) */
    "ddd\0"
    "glNormal3d\0"
    "\0"
-   /* _mesa_function_pool[10744]: Normal3f (offset 56) */
+   /* _mesa_function_pool[10834]: Normal3f (offset 56) */
    "fff\0"
    "glNormal3f\0"
    "\0"
-   /* _mesa_function_pool[10760]: MultiTexCoord1svARB (offset 383) */
+   /* _mesa_function_pool[10850]: MultiTexCoord1svARB (offset 383) */
    "ip\0"
    "glMultiTexCoord1sv\0"
    "glMultiTexCoord1svARB\0"
    "\0"
-   /* _mesa_function_pool[10805]: Indexi (offset 48) */
+   /* _mesa_function_pool[10895]: Indexi (offset 48) */
    "i\0"
    "glIndexi\0"
    "\0"
-   /* _mesa_function_pool[10817]: EGLImageTargetTexture2DOES (will be remapped) */
+   /* _mesa_function_pool[10907]: EGLImageTargetTexture2DOES (will be remapped) */
    "ip\0"
    "glEGLImageTargetTexture2DOES\0"
    "\0"
-   /* _mesa_function_pool[10850]: EndQueryARB (will be remapped) */
+   /* _mesa_function_pool[10940]: EndQueryARB (will be remapped) */
    "i\0"
    "glEndQuery\0"
    "glEndQueryARB\0"
    "\0"
-   /* _mesa_function_pool[10878]: DeleteFencesNV (will be remapped) */
+   /* _mesa_function_pool[10968]: DeleteFencesNV (will be remapped) */
    "ip\0"
    "glDeleteFencesNV\0"
    "\0"
-   /* _mesa_function_pool[10899]: DepthMask (offset 211) */
+   /* _mesa_function_pool[10989]: DeformationMap3dSGIX (dynamic) */
+   "iddiiddiiddiip\0"
+   "glDeformationMap3dSGIX\0"
+   "\0"
+   /* _mesa_function_pool[11028]: BindBufferRangeEXT (will be remapped) */
+   "iiiii\0"
+   "glBindBufferRangeEXT\0"
+   "glBindBufferRange\0"
+   "\0"
+   /* _mesa_function_pool[11074]: DepthMask (offset 211) */
    "i\0"
    "glDepthMask\0"
    "\0"
-   /* _mesa_function_pool[10914]: IsShader (will be remapped) */
+   /* _mesa_function_pool[11089]: IsShader (will be remapped) */
    "i\0"
    "glIsShader\0"
    "\0"
-   /* _mesa_function_pool[10928]: Indexf (offset 46) */
+   /* _mesa_function_pool[11103]: Indexf (offset 46) */
    "f\0"
    "glIndexf\0"
    "\0"
-   /* _mesa_function_pool[10940]: GetImageTransformParameterivHP (dynamic) */
+   /* _mesa_function_pool[11115]: GetImageTransformParameterivHP (dynamic) */
    "iip\0"
    "glGetImageTransformParameterivHP\0"
    "\0"
-   /* _mesa_function_pool[10978]: Indexd (offset 44) */
+   /* _mesa_function_pool[11153]: Indexd (offset 44) */
    "d\0"
    "glIndexd\0"
    "\0"
-   /* _mesa_function_pool[10990]: GetMaterialiv (offset 270) */
+   /* _mesa_function_pool[11165]: GetMaterialiv (offset 270) */
    "iip\0"
    "glGetMaterialiv\0"
    "\0"
-   /* _mesa_function_pool[11011]: StencilOp (offset 244) */
+   /* _mesa_function_pool[11186]: StencilOp (offset 244) */
    "iii\0"
    "glStencilOp\0"
    "\0"
-   /* _mesa_function_pool[11028]: WindowPos4ivMESA (will be remapped) */
+   /* _mesa_function_pool[11203]: WindowPos4ivMESA (will be remapped) */
    "p\0"
    "glWindowPos4ivMESA\0"
    "\0"
-   /* _mesa_function_pool[11050]: MultiTexCoord3svARB (offset 399) */
+   /* _mesa_function_pool[11225]: MultiTexCoord3svARB (offset 399) */
    "ip\0"
    "glMultiTexCoord3sv\0"
    "glMultiTexCoord3svARB\0"
    "\0"
-   /* _mesa_function_pool[11095]: TexEnvfv (offset 185) */
+   /* _mesa_function_pool[11270]: TexEnvfv (offset 185) */
    "iip\0"
    "glTexEnvfv\0"
    "\0"
-   /* _mesa_function_pool[11111]: MultiTexCoord4iARB (offset 404) */
+   /* _mesa_function_pool[11286]: MultiTexCoord4iARB (offset 404) */
    "iiiii\0"
    "glMultiTexCoord4i\0"
    "glMultiTexCoord4iARB\0"
    "\0"
-   /* _mesa_function_pool[11157]: Indexs (offset 50) */
+   /* _mesa_function_pool[11332]: Indexs (offset 50) */
    "i\0"
    "glIndexs\0"
    "\0"
-   /* _mesa_function_pool[11169]: Binormal3ivEXT (dynamic) */
+   /* _mesa_function_pool[11344]: Binormal3ivEXT (dynamic) */
    "p\0"
    "glBinormal3ivEXT\0"
    "\0"
-   /* _mesa_function_pool[11189]: ResizeBuffersMESA (will be remapped) */
+   /* _mesa_function_pool[11364]: ResizeBuffersMESA (will be remapped) */
    "\0"
    "glResizeBuffersMESA\0"
    "\0"
-   /* _mesa_function_pool[11211]: GetUniformivARB (will be remapped) */
+   /* _mesa_function_pool[11386]: GetUniformivARB (will be remapped) */
    "iip\0"
    "glGetUniformiv\0"
    "glGetUniformivARB\0"
    "\0"
-   /* _mesa_function_pool[11249]: PixelTexGenParameteriSGIS (will be remapped) */
+   /* _mesa_function_pool[11424]: PixelTexGenParameteriSGIS (will be remapped) */
    "ii\0"
    "glPixelTexGenParameteriSGIS\0"
    "\0"
-   /* _mesa_function_pool[11281]: VertexPointervINTEL (dynamic) */
+   /* _mesa_function_pool[11456]: VertexPointervINTEL (dynamic) */
    "iip\0"
    "glVertexPointervINTEL\0"
    "\0"
-   /* _mesa_function_pool[11308]: Vertex2i (offset 130) */
+   /* _mesa_function_pool[11483]: Vertex2i (offset 130) */
    "ii\0"
    "glVertex2i\0"
    "\0"
-   /* _mesa_function_pool[11323]: LoadMatrixf (offset 291) */
+   /* _mesa_function_pool[11498]: LoadMatrixf (offset 291) */
    "p\0"
    "glLoadMatrixf\0"
    "\0"
-   /* _mesa_function_pool[11340]: Vertex2f (offset 128) */
+   /* _mesa_function_pool[11515]: Vertex2f (offset 128) */
    "ff\0"
    "glVertex2f\0"
    "\0"
-   /* _mesa_function_pool[11355]: ReplacementCodeuiColor4fNormal3fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[11530]: ReplacementCodeuiColor4fNormal3fVertex3fvSUN (dynamic) */
    "pppp\0"
    "glReplacementCodeuiColor4fNormal3fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[11408]: Color4bv (offset 26) */
+   /* _mesa_function_pool[11583]: Color4bv (offset 26) */
    "p\0"
    "glColor4bv\0"
    "\0"
-   /* _mesa_function_pool[11422]: VertexPointer (offset 321) */
+   /* _mesa_function_pool[11597]: VertexPointer (offset 321) */
    "iiip\0"
    "glVertexPointer\0"
    "\0"
-   /* _mesa_function_pool[11444]: SecondaryColor3uiEXT (will be remapped) */
+   /* _mesa_function_pool[11619]: SecondaryColor3uiEXT (will be remapped) */
    "iii\0"
    "glSecondaryColor3ui\0"
    "glSecondaryColor3uiEXT\0"
    "\0"
-   /* _mesa_function_pool[11492]: StartInstrumentsSGIX (dynamic) */
+   /* _mesa_function_pool[11667]: StartInstrumentsSGIX (dynamic) */
    "\0"
    "glStartInstrumentsSGIX\0"
    "\0"
-   /* _mesa_function_pool[11517]: SecondaryColor3usvEXT (will be remapped) */
+   /* _mesa_function_pool[11692]: SecondaryColor3usvEXT (will be remapped) */
    "p\0"
    "glSecondaryColor3usv\0"
    "glSecondaryColor3usvEXT\0"
    "\0"
-   /* _mesa_function_pool[11565]: VertexAttrib2fvNV (will be remapped) */
+   /* _mesa_function_pool[11740]: VertexAttrib2fvNV (will be remapped) */
    "ip\0"
    "glVertexAttrib2fvNV\0"
    "\0"
-   /* _mesa_function_pool[11589]: ProgramLocalParameter4dvARB (will be remapped) */
+   /* _mesa_function_pool[11764]: ProgramLocalParameter4dvARB (will be remapped) */
    "iip\0"
    "glProgramLocalParameter4dvARB\0"
    "\0"
-   /* _mesa_function_pool[11624]: DeleteLists (offset 4) */
+   /* _mesa_function_pool[11799]: DeleteLists (offset 4) */
    "ii\0"
    "glDeleteLists\0"
    "\0"
-   /* _mesa_function_pool[11642]: LogicOp (offset 242) */
+   /* _mesa_function_pool[11817]: LogicOp (offset 242) */
    "i\0"
    "glLogicOp\0"
    "\0"
-   /* _mesa_function_pool[11655]: MatrixIndexuivARB (dynamic) */
+   /* _mesa_function_pool[11830]: MatrixIndexuivARB (dynamic) */
    "ip\0"
    "glMatrixIndexuivARB\0"
    "\0"
-   /* _mesa_function_pool[11679]: Vertex2s (offset 132) */
+   /* _mesa_function_pool[11854]: Vertex2s (offset 132) */
    "ii\0"
    "glVertex2s\0"
    "\0"
-   /* _mesa_function_pool[11694]: RenderbufferStorageMultisample (will be remapped) */
+   /* _mesa_function_pool[11869]: RenderbufferStorageMultisample (will be remapped) */
    "iiiii\0"
    "glRenderbufferStorageMultisample\0"
    "glRenderbufferStorageMultisampleEXT\0"
    "\0"
-   /* _mesa_function_pool[11770]: TexCoord4fv (offset 121) */
+   /* _mesa_function_pool[11945]: TexCoord4fv (offset 121) */
    "p\0"
    "glTexCoord4fv\0"
    "\0"
-   /* _mesa_function_pool[11787]: Tangent3sEXT (dynamic) */
+   /* _mesa_function_pool[11962]: Tangent3sEXT (dynamic) */
    "iii\0"
    "glTangent3sEXT\0"
    "\0"
-   /* _mesa_function_pool[11807]: GlobalAlphaFactorfSUN (dynamic) */
+   /* _mesa_function_pool[11982]: GlobalAlphaFactorfSUN (dynamic) */
    "f\0"
    "glGlobalAlphaFactorfSUN\0"
    "\0"
-   /* _mesa_function_pool[11834]: MultiTexCoord3iARB (offset 396) */
+   /* _mesa_function_pool[12009]: MultiTexCoord3iARB (offset 396) */
    "iiii\0"
    "glMultiTexCoord3i\0"
    "glMultiTexCoord3iARB\0"
    "\0"
-   /* _mesa_function_pool[11879]: IsProgram (will be remapped) */
+   /* _mesa_function_pool[12054]: IsProgram (will be remapped) */
    "i\0"
    "glIsProgram\0"
    "\0"
-   /* _mesa_function_pool[11894]: TexCoordPointerListIBM (dynamic) */
+   /* _mesa_function_pool[12069]: TexCoordPointerListIBM (dynamic) */
    "iiipi\0"
    "glTexCoordPointerListIBM\0"
    "\0"
-   /* _mesa_function_pool[11926]: GlobalAlphaFactorusSUN (dynamic) */
+   /* _mesa_function_pool[12101]: GlobalAlphaFactorusSUN (dynamic) */
    "i\0"
    "glGlobalAlphaFactorusSUN\0"
    "\0"
-   /* _mesa_function_pool[11954]: VertexAttrib2dvNV (will be remapped) */
+   /* _mesa_function_pool[12129]: VertexAttrib2dvNV (will be remapped) */
    "ip\0"
    "glVertexAttrib2dvNV\0"
    "\0"
-   /* _mesa_function_pool[11978]: FramebufferRenderbufferEXT (will be remapped) */
+   /* _mesa_function_pool[12153]: FramebufferRenderbufferEXT (will be remapped) */
    "iiii\0"
    "glFramebufferRenderbuffer\0"
    "glFramebufferRenderbufferEXT\0"
    "\0"
-   /* _mesa_function_pool[12039]: VertexAttrib1dvNV (will be remapped) */
+   /* _mesa_function_pool[12214]: VertexAttrib1dvNV (will be remapped) */
    "ip\0"
    "glVertexAttrib1dvNV\0"
    "\0"
-   /* _mesa_function_pool[12063]: GenTextures (offset 328) */
+   /* _mesa_function_pool[12238]: GenTextures (offset 328) */
    "ip\0"
    "glGenTextures\0"
    "glGenTexturesEXT\0"
    "\0"
-   /* _mesa_function_pool[12098]: SetFenceNV (will be remapped) */
+   /* _mesa_function_pool[12273]: SetFenceNV (will be remapped) */
    "ii\0"
    "glSetFenceNV\0"
    "\0"
-   /* _mesa_function_pool[12115]: FramebufferTexture1DEXT (will be remapped) */
+   /* _mesa_function_pool[12290]: FramebufferTexture1DEXT (will be remapped) */
    "iiiii\0"
    "glFramebufferTexture1D\0"
    "glFramebufferTexture1DEXT\0"
    "\0"
-   /* _mesa_function_pool[12171]: GetCombinerOutputParameterivNV (will be remapped) */
+   /* _mesa_function_pool[12346]: GetCombinerOutputParameterivNV (will be remapped) */
    "iiip\0"
    "glGetCombinerOutputParameterivNV\0"
    "\0"
-   /* _mesa_function_pool[12210]: MultiModeDrawArraysIBM (will be remapped) */
-   "pppii\0"
-   "glMultiModeDrawArraysIBM\0"
-   "\0"
-   /* _mesa_function_pool[12242]: PixelTexGenParameterivSGIS (will be remapped) */
+   /* _mesa_function_pool[12385]: PixelTexGenParameterivSGIS (will be remapped) */
    "ip\0"
    "glPixelTexGenParameterivSGIS\0"
    "\0"
-   /* _mesa_function_pool[12275]: TextureNormalEXT (dynamic) */
+   /* _mesa_function_pool[12418]: TextureNormalEXT (dynamic) */
    "i\0"
    "glTextureNormalEXT\0"
    "\0"
-   /* _mesa_function_pool[12297]: IndexPointerListIBM (dynamic) */
+   /* _mesa_function_pool[12440]: IndexPointerListIBM (dynamic) */
    "iipi\0"
    "glIndexPointerListIBM\0"
    "\0"
-   /* _mesa_function_pool[12325]: WeightfvARB (dynamic) */
+   /* _mesa_function_pool[12468]: WeightfvARB (dynamic) */
    "ip\0"
    "glWeightfvARB\0"
    "\0"
-   /* _mesa_function_pool[12343]: RasterPos2sv (offset 69) */
+   /* _mesa_function_pool[12486]: RasterPos2sv (offset 69) */
    "p\0"
    "glRasterPos2sv\0"
    "\0"
-   /* _mesa_function_pool[12361]: Color4ubv (offset 36) */
+   /* _mesa_function_pool[12504]: Color4ubv (offset 36) */
    "p\0"
    "glColor4ubv\0"
    "\0"
-   /* _mesa_function_pool[12376]: DrawBuffer (offset 202) */
+   /* _mesa_function_pool[12519]: DrawBuffer (offset 202) */
    "i\0"
    "glDrawBuffer\0"
    "\0"
-   /* _mesa_function_pool[12392]: TexCoord2fv (offset 105) */
+   /* _mesa_function_pool[12535]: TexCoord2fv (offset 105) */
    "p\0"
    "glTexCoord2fv\0"
    "\0"
-   /* _mesa_function_pool[12409]: WindowPos4fMESA (will be remapped) */
+   /* _mesa_function_pool[12552]: WindowPos4fMESA (will be remapped) */
    "ffff\0"
    "glWindowPos4fMESA\0"
    "\0"
-   /* _mesa_function_pool[12433]: TexCoord1sv (offset 101) */
+   /* _mesa_function_pool[12576]: TexCoord1sv (offset 101) */
    "p\0"
    "glTexCoord1sv\0"
    "\0"
-   /* _mesa_function_pool[12450]: WindowPos3dvMESA (will be remapped) */
+   /* _mesa_function_pool[12593]: WindowPos3dvMESA (will be remapped) */
    "p\0"
    "glWindowPos3dv\0"
    "glWindowPos3dvARB\0"
    "glWindowPos3dvMESA\0"
    "\0"
-   /* _mesa_function_pool[12505]: DepthFunc (offset 245) */
+   /* _mesa_function_pool[12648]: DepthFunc (offset 245) */
    "i\0"
    "glDepthFunc\0"
    "\0"
-   /* _mesa_function_pool[12520]: PixelMapusv (offset 253) */
+   /* _mesa_function_pool[12663]: PixelMapusv (offset 253) */
    "iip\0"
    "glPixelMapusv\0"
    "\0"
-   /* _mesa_function_pool[12539]: GetQueryObjecti64vEXT (will be remapped) */
+   /* _mesa_function_pool[12682]: GetQueryObjecti64vEXT (will be remapped) */
    "iip\0"
    "glGetQueryObjecti64vEXT\0"
    "\0"
-   /* _mesa_function_pool[12568]: MultiTexCoord1dARB (offset 376) */
+   /* _mesa_function_pool[12711]: MultiTexCoord1dARB (offset 376) */
    "id\0"
    "glMultiTexCoord1d\0"
    "glMultiTexCoord1dARB\0"
    "\0"
-   /* _mesa_function_pool[12611]: PointParameterivNV (will be remapped) */
+   /* _mesa_function_pool[12754]: PointParameterivNV (will be remapped) */
    "ip\0"
    "glPointParameteriv\0"
    "glPointParameterivNV\0"
    "\0"
-   /* _mesa_function_pool[12655]: BlendFunc (offset 241) */
+   /* _mesa_function_pool[12798]: BlendFunc (offset 241) */
    "ii\0"
    "glBlendFunc\0"
    "\0"
-   /* _mesa_function_pool[12671]: Uniform2fvARB (will be remapped) */
+   /* _mesa_function_pool[12814]: EndTransformFeedbackEXT (will be remapped) */
+   "\0"
+   "glEndTransformFeedbackEXT\0"
+   "glEndTransformFeedback\0"
+   "\0"
+   /* _mesa_function_pool[12865]: Uniform2fvARB (will be remapped) */
    "iip\0"
    "glUniform2fv\0"
    "glUniform2fvARB\0"
    "\0"
-   /* _mesa_function_pool[12705]: BufferParameteriAPPLE (will be remapped) */
+   /* _mesa_function_pool[12899]: BufferParameteriAPPLE (will be remapped) */
    "iii\0"
    "glBufferParameteriAPPLE\0"
    "\0"
-   /* _mesa_function_pool[12734]: MultiTexCoord3dvARB (offset 393) */
+   /* _mesa_function_pool[12928]: MultiTexCoord3dvARB (offset 393) */
    "ip\0"
    "glMultiTexCoord3dv\0"
    "glMultiTexCoord3dvARB\0"
    "\0"
-   /* _mesa_function_pool[12779]: ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[12973]: ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (dynamic) */
    "pppp\0"
    "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[12835]: DeleteObjectARB (will be remapped) */
+   /* _mesa_function_pool[13029]: DeleteObjectARB (will be remapped) */
    "i\0"
    "glDeleteObjectARB\0"
    "\0"
-   /* _mesa_function_pool[12856]: MatrixIndexPointerARB (dynamic) */
+   /* _mesa_function_pool[13050]: MatrixIndexPointerARB (dynamic) */
    "iiip\0"
    "glMatrixIndexPointerARB\0"
    "\0"
-   /* _mesa_function_pool[12886]: ProgramNamedParameter4dvNV (will be remapped) */
+   /* _mesa_function_pool[13080]: ProgramNamedParameter4dvNV (will be remapped) */
    "iipp\0"
    "glProgramNamedParameter4dvNV\0"
    "\0"
-   /* _mesa_function_pool[12921]: Tangent3fvEXT (dynamic) */
+   /* _mesa_function_pool[13115]: Tangent3fvEXT (dynamic) */
    "p\0"
    "glTangent3fvEXT\0"
    "\0"
-   /* _mesa_function_pool[12940]: Flush (offset 217) */
+   /* _mesa_function_pool[13134]: Flush (offset 217) */
    "\0"
    "glFlush\0"
    "\0"
-   /* _mesa_function_pool[12950]: Color4uiv (offset 38) */
+   /* _mesa_function_pool[13144]: Color4uiv (offset 38) */
    "p\0"
    "glColor4uiv\0"
    "\0"
-   /* _mesa_function_pool[12965]: GenVertexArrays (will be remapped) */
+   /* _mesa_function_pool[13159]: GenVertexArrays (will be remapped) */
    "ip\0"
    "glGenVertexArrays\0"
    "\0"
-   /* _mesa_function_pool[12987]: RasterPos3sv (offset 77) */
+   /* _mesa_function_pool[13181]: RasterPos3sv (offset 77) */
    "p\0"
    "glRasterPos3sv\0"
    "\0"
-   /* _mesa_function_pool[13005]: BindFramebufferEXT (will be remapped) */
+   /* _mesa_function_pool[13199]: BindFramebufferEXT (will be remapped) */
    "ii\0"
    "glBindFramebuffer\0"
    "glBindFramebufferEXT\0"
    "\0"
-   /* _mesa_function_pool[13048]: ReferencePlaneSGIX (dynamic) */
+   /* _mesa_function_pool[13242]: ReferencePlaneSGIX (dynamic) */
    "p\0"
    "glReferencePlaneSGIX\0"
    "\0"
-   /* _mesa_function_pool[13072]: PushAttrib (offset 219) */
+   /* _mesa_function_pool[13266]: PushAttrib (offset 219) */
    "i\0"
    "glPushAttrib\0"
    "\0"
-   /* _mesa_function_pool[13088]: RasterPos2i (offset 66) */
+   /* _mesa_function_pool[13282]: RasterPos2i (offset 66) */
    "ii\0"
    "glRasterPos2i\0"
    "\0"
-   /* _mesa_function_pool[13106]: ValidateProgramARB (will be remapped) */
+   /* _mesa_function_pool[13300]: ValidateProgramARB (will be remapped) */
    "i\0"
    "glValidateProgram\0"
    "glValidateProgramARB\0"
    "\0"
-   /* _mesa_function_pool[13148]: TexParameteriv (offset 181) */
+   /* _mesa_function_pool[13342]: TexParameteriv (offset 181) */
    "iip\0"
    "glTexParameteriv\0"
    "\0"
-   /* _mesa_function_pool[13170]: UnlockArraysEXT (will be remapped) */
+   /* _mesa_function_pool[13364]: UnlockArraysEXT (will be remapped) */
    "\0"
    "glUnlockArraysEXT\0"
    "\0"
-   /* _mesa_function_pool[13190]: TexCoord2fColor3fVertex3fSUN (dynamic) */
+   /* _mesa_function_pool[13384]: TexCoord2fColor3fVertex3fSUN (dynamic) */
    "ffffffff\0"
    "glTexCoord2fColor3fVertex3fSUN\0"
    "\0"
-   /* _mesa_function_pool[13231]: WindowPos3fvMESA (will be remapped) */
+   /* _mesa_function_pool[13425]: WindowPos3fvMESA (will be remapped) */
    "p\0"
    "glWindowPos3fv\0"
    "glWindowPos3fvARB\0"
    "glWindowPos3fvMESA\0"
    "\0"
-   /* _mesa_function_pool[13286]: RasterPos2f (offset 64) */
+   /* _mesa_function_pool[13480]: RasterPos2f (offset 64) */
    "ff\0"
    "glRasterPos2f\0"
    "\0"
-   /* _mesa_function_pool[13304]: VertexAttrib1svNV (will be remapped) */
+   /* _mesa_function_pool[13498]: VertexAttrib1svNV (will be remapped) */
    "ip\0"
    "glVertexAttrib1svNV\0"
    "\0"
-   /* _mesa_function_pool[13328]: RasterPos2d (offset 62) */
+   /* _mesa_function_pool[13522]: RasterPos2d (offset 62) */
    "dd\0"
    "glRasterPos2d\0"
    "\0"
-   /* _mesa_function_pool[13346]: RasterPos3fv (offset 73) */
+   /* _mesa_function_pool[13540]: RasterPos3fv (offset 73) */
    "p\0"
    "glRasterPos3fv\0"
    "\0"
-   /* _mesa_function_pool[13364]: CopyTexSubImage3D (offset 373) */
+   /* _mesa_function_pool[13558]: CopyTexSubImage3D (offset 373) */
    "iiiiiiiii\0"
    "glCopyTexSubImage3D\0"
    "glCopyTexSubImage3DEXT\0"
    "\0"
-   /* _mesa_function_pool[13418]: VertexAttrib2dARB (will be remapped) */
+   /* _mesa_function_pool[13612]: VertexAttrib2dARB (will be remapped) */
    "idd\0"
    "glVertexAttrib2d\0"
    "glVertexAttrib2dARB\0"
    "\0"
-   /* _mesa_function_pool[13460]: Color4ub (offset 35) */
+   /* _mesa_function_pool[13654]: Color4ub (offset 35) */
    "iiii\0"
    "glColor4ub\0"
    "\0"
-   /* _mesa_function_pool[13477]: GetInteger64v (will be remapped) */
+   /* _mesa_function_pool[13671]: GetInteger64v (will be remapped) */
    "ip\0"
    "glGetInteger64v\0"
    "\0"
-   /* _mesa_function_pool[13497]: TextureColorMaskSGIS (dynamic) */
+   /* _mesa_function_pool[13691]: TextureColorMaskSGIS (dynamic) */
    "iiii\0"
    "glTextureColorMaskSGIS\0"
    "\0"
-   /* _mesa_function_pool[13526]: RasterPos2s (offset 68) */
+   /* _mesa_function_pool[13720]: RasterPos2s (offset 68) */
    "ii\0"
    "glRasterPos2s\0"
    "\0"
-   /* _mesa_function_pool[13544]: GetColorTable (offset 343) */
+   /* _mesa_function_pool[13738]: GetColorTable (offset 343) */
    "iiip\0"
    "glGetColorTable\0"
    "glGetColorTableSGI\0"
    "glGetColorTableEXT\0"
    "\0"
-   /* _mesa_function_pool[13604]: SelectBuffer (offset 195) */
+   /* _mesa_function_pool[13798]: SelectBuffer (offset 195) */
    "ip\0"
    "glSelectBuffer\0"
    "\0"
-   /* _mesa_function_pool[13623]: Indexiv (offset 49) */
+   /* _mesa_function_pool[13817]: Indexiv (offset 49) */
    "p\0"
    "glIndexiv\0"
    "\0"
-   /* _mesa_function_pool[13636]: TexCoord3i (offset 114) */
+   /* _mesa_function_pool[13830]: TexCoord3i (offset 114) */
    "iii\0"
    "glTexCoord3i\0"
    "\0"
-   /* _mesa_function_pool[13654]: CopyColorTable (offset 342) */
+   /* _mesa_function_pool[13848]: CopyColorTable (offset 342) */
    "iiiii\0"
    "glCopyColorTable\0"
    "glCopyColorTableSGI\0"
    "\0"
-   /* _mesa_function_pool[13698]: GetHistogramParameterfv (offset 362) */
+   /* _mesa_function_pool[13892]: GetHistogramParameterfv (offset 362) */
    "iip\0"
    "glGetHistogramParameterfv\0"
    "glGetHistogramParameterfvEXT\0"
    "\0"
-   /* _mesa_function_pool[13758]: Frustum (offset 289) */
+   /* _mesa_function_pool[13952]: Frustum (offset 289) */
    "dddddd\0"
    "glFrustum\0"
    "\0"
-   /* _mesa_function_pool[13776]: GetString (offset 275) */
+   /* _mesa_function_pool[13970]: GetString (offset 275) */
    "i\0"
    "glGetString\0"
    "\0"
-   /* _mesa_function_pool[13791]: ColorPointervINTEL (dynamic) */
+   /* _mesa_function_pool[13985]: ColorPointervINTEL (dynamic) */
    "iip\0"
    "glColorPointervINTEL\0"
    "\0"
-   /* _mesa_function_pool[13817]: TexEnvf (offset 184) */
+   /* _mesa_function_pool[14011]: TexEnvf (offset 184) */
    "iif\0"
    "glTexEnvf\0"
    "\0"
-   /* _mesa_function_pool[13832]: TexCoord3d (offset 110) */
+   /* _mesa_function_pool[14026]: TexCoord3d (offset 110) */
    "ddd\0"
    "glTexCoord3d\0"
    "\0"
-   /* _mesa_function_pool[13850]: AlphaFragmentOp1ATI (will be remapped) */
+   /* _mesa_function_pool[14044]: AlphaFragmentOp1ATI (will be remapped) */
    "iiiiii\0"
    "glAlphaFragmentOp1ATI\0"
    "\0"
-   /* _mesa_function_pool[13880]: TexCoord3f (offset 112) */
+   /* _mesa_function_pool[14074]: TexCoord3f (offset 112) */
    "fff\0"
    "glTexCoord3f\0"
    "\0"
-   /* _mesa_function_pool[13898]: MultiTexCoord3ivARB (offset 397) */
+   /* _mesa_function_pool[14092]: MultiTexCoord3ivARB (offset 397) */
    "ip\0"
    "glMultiTexCoord3iv\0"
    "glMultiTexCoord3ivARB\0"
    "\0"
-   /* _mesa_function_pool[13943]: MultiTexCoord2sARB (offset 390) */
+   /* _mesa_function_pool[14137]: MultiTexCoord2sARB (offset 390) */
    "iii\0"
    "glMultiTexCoord2s\0"
    "glMultiTexCoord2sARB\0"
    "\0"
-   /* _mesa_function_pool[13987]: VertexAttrib1dvARB (will be remapped) */
+   /* _mesa_function_pool[14181]: VertexAttrib1dvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib1dv\0"
    "glVertexAttrib1dvARB\0"
    "\0"
-   /* _mesa_function_pool[14030]: DeleteTextures (offset 327) */
+   /* _mesa_function_pool[14224]: DeleteTextures (offset 327) */
    "ip\0"
    "glDeleteTextures\0"
    "glDeleteTexturesEXT\0"
    "\0"
-   /* _mesa_function_pool[14071]: TexCoordPointerEXT (will be remapped) */
+   /* _mesa_function_pool[14265]: TexCoordPointerEXT (will be remapped) */
    "iiiip\0"
    "glTexCoordPointerEXT\0"
    "\0"
-   /* _mesa_function_pool[14099]: TexSubImage4DSGIS (dynamic) */
+   /* _mesa_function_pool[14293]: TexSubImage4DSGIS (dynamic) */
    "iiiiiiiiiiiip\0"
    "glTexSubImage4DSGIS\0"
    "\0"
-   /* _mesa_function_pool[14134]: TexCoord3s (offset 116) */
+   /* _mesa_function_pool[14328]: TexCoord3s (offset 116) */
    "iii\0"
    "glTexCoord3s\0"
    "\0"
-   /* _mesa_function_pool[14152]: GetTexLevelParameteriv (offset 285) */
+   /* _mesa_function_pool[14346]: GetTexLevelParameteriv (offset 285) */
    "iiip\0"
    "glGetTexLevelParameteriv\0"
    "\0"
-   /* _mesa_function_pool[14183]: CombinerStageParameterfvNV (dynamic) */
+   /* _mesa_function_pool[14377]: DrawArraysInstanced (will be remapped) */
+   "iiii\0"
+   "glDrawArraysInstanced\0"
+   "glDrawArraysInstancedARB\0"
+   "glDrawArraysInstancedEXT\0"
+   "\0"
+   /* _mesa_function_pool[14455]: CombinerStageParameterfvNV (dynamic) */
    "iip\0"
    "glCombinerStageParameterfvNV\0"
    "\0"
-   /* _mesa_function_pool[14217]: StopInstrumentsSGIX (dynamic) */
+   /* _mesa_function_pool[14489]: StopInstrumentsSGIX (dynamic) */
    "i\0"
    "glStopInstrumentsSGIX\0"
    "\0"
-   /* _mesa_function_pool[14242]: TexCoord4fColor4fNormal3fVertex4fSUN (dynamic) */
+   /* _mesa_function_pool[14514]: TexCoord4fColor4fNormal3fVertex4fSUN (dynamic) */
    "fffffffffffffff\0"
    "glTexCoord4fColor4fNormal3fVertex4fSUN\0"
    "\0"
-   /* _mesa_function_pool[14298]: ClearAccum (offset 204) */
+   /* _mesa_function_pool[14570]: ClearAccum (offset 204) */
    "ffff\0"
    "glClearAccum\0"
    "\0"
-   /* _mesa_function_pool[14317]: DeformSGIX (dynamic) */
+   /* _mesa_function_pool[14589]: DeformSGIX (dynamic) */
    "i\0"
    "glDeformSGIX\0"
    "\0"
-   /* _mesa_function_pool[14333]: GetVertexAttribfvARB (will be remapped) */
+   /* _mesa_function_pool[14605]: GetVertexAttribfvARB (will be remapped) */
    "iip\0"
    "glGetVertexAttribfv\0"
    "glGetVertexAttribfvARB\0"
    "\0"
-   /* _mesa_function_pool[14381]: SecondaryColor3ivEXT (will be remapped) */
+   /* _mesa_function_pool[14653]: SecondaryColor3ivEXT (will be remapped) */
    "p\0"
    "glSecondaryColor3iv\0"
    "glSecondaryColor3ivEXT\0"
    "\0"
-   /* _mesa_function_pool[14427]: TexCoord4iv (offset 123) */
+   /* _mesa_function_pool[14699]: TexCoord4iv (offset 123) */
    "p\0"
    "glTexCoord4iv\0"
    "\0"
-   /* _mesa_function_pool[14444]: UniformMatrix4x2fv (will be remapped) */
+   /* _mesa_function_pool[14716]: UniformMatrix4x2fv (will be remapped) */
    "iiip\0"
    "glUniformMatrix4x2fv\0"
    "\0"
-   /* _mesa_function_pool[14471]: GetDetailTexFuncSGIS (dynamic) */
+   /* _mesa_function_pool[14743]: GetDetailTexFuncSGIS (dynamic) */
    "ip\0"
    "glGetDetailTexFuncSGIS\0"
    "\0"
-   /* _mesa_function_pool[14498]: GetCombinerStageParameterfvNV (dynamic) */
+   /* _mesa_function_pool[14770]: GetCombinerStageParameterfvNV (dynamic) */
    "iip\0"
    "glGetCombinerStageParameterfvNV\0"
    "\0"
-   /* _mesa_function_pool[14535]: PolygonOffset (offset 319) */
+   /* _mesa_function_pool[14807]: PolygonOffset (offset 319) */
    "ff\0"
    "glPolygonOffset\0"
    "\0"
-   /* _mesa_function_pool[14555]: BindVertexArray (will be remapped) */
+   /* _mesa_function_pool[14827]: BindVertexArray (will be remapped) */
    "i\0"
    "glBindVertexArray\0"
    "\0"
-   /* _mesa_function_pool[14576]: Color4ubVertex2fvSUN (dynamic) */
+   /* _mesa_function_pool[14848]: Color4ubVertex2fvSUN (dynamic) */
    "pp\0"
    "glColor4ubVertex2fvSUN\0"
    "\0"
-   /* _mesa_function_pool[14603]: Rectd (offset 86) */
+   /* _mesa_function_pool[14875]: Rectd (offset 86) */
    "dddd\0"
    "glRectd\0"
    "\0"
-   /* _mesa_function_pool[14617]: TexFilterFuncSGIS (dynamic) */
+   /* _mesa_function_pool[14889]: TexFilterFuncSGIS (dynamic) */
    "iiip\0"
    "glTexFilterFuncSGIS\0"
    "\0"
-   /* _mesa_function_pool[14643]: SampleMaskSGIS (will be remapped) */
+   /* _mesa_function_pool[14915]: SampleMaskSGIS (will be remapped) */
    "fi\0"
    "glSampleMaskSGIS\0"
    "glSampleMaskEXT\0"
    "\0"
-   /* _mesa_function_pool[14680]: GetAttribLocationARB (will be remapped) */
+   /* _mesa_function_pool[14952]: GetAttribLocationARB (will be remapped) */
    "ip\0"
    "glGetAttribLocation\0"
    "glGetAttribLocationARB\0"
    "\0"
-   /* _mesa_function_pool[14727]: RasterPos3i (offset 74) */
+   /* _mesa_function_pool[14999]: RasterPos3i (offset 74) */
    "iii\0"
    "glRasterPos3i\0"
    "\0"
-   /* _mesa_function_pool[14746]: VertexAttrib4ubvARB (will be remapped) */
+   /* _mesa_function_pool[15018]: VertexAttrib4ubvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4ubv\0"
    "glVertexAttrib4ubvARB\0"
    "\0"
-   /* _mesa_function_pool[14791]: DetailTexFuncSGIS (dynamic) */
+   /* _mesa_function_pool[15063]: DetailTexFuncSGIS (dynamic) */
    "iip\0"
    "glDetailTexFuncSGIS\0"
    "\0"
-   /* _mesa_function_pool[14816]: Normal3fVertex3fSUN (dynamic) */
+   /* _mesa_function_pool[15088]: Normal3fVertex3fSUN (dynamic) */
    "ffffff\0"
    "glNormal3fVertex3fSUN\0"
    "\0"
-   /* _mesa_function_pool[14846]: CopyTexImage2D (offset 324) */
+   /* _mesa_function_pool[15118]: CopyTexImage2D (offset 324) */
    "iiiiiiii\0"
    "glCopyTexImage2D\0"
    "glCopyTexImage2DEXT\0"
    "\0"
-   /* _mesa_function_pool[14893]: GetBufferPointervARB (will be remapped) */
+   /* _mesa_function_pool[15165]: GetBufferPointervARB (will be remapped) */
    "iip\0"
    "glGetBufferPointerv\0"
    "glGetBufferPointervARB\0"
    "\0"
-   /* _mesa_function_pool[14941]: ProgramEnvParameter4fARB (will be remapped) */
+   /* _mesa_function_pool[15213]: ProgramEnvParameter4fARB (will be remapped) */
    "iiffff\0"
    "glProgramEnvParameter4fARB\0"
    "glProgramParameter4fNV\0"
    "\0"
-   /* _mesa_function_pool[14999]: Uniform3ivARB (will be remapped) */
+   /* _mesa_function_pool[15271]: Uniform3ivARB (will be remapped) */
    "iip\0"
    "glUniform3iv\0"
    "glUniform3ivARB\0"
    "\0"
-   /* _mesa_function_pool[15033]: Lightfv (offset 160) */
+   /* _mesa_function_pool[15305]: Lightfv (offset 160) */
    "iip\0"
    "glLightfv\0"
    "\0"
-   /* _mesa_function_pool[15048]: ClearDepth (offset 208) */
+   /* _mesa_function_pool[15320]: ClearDepth (offset 208) */
    "d\0"
    "glClearDepth\0"
    "\0"
-   /* _mesa_function_pool[15064]: GetFenceivNV (will be remapped) */
+   /* _mesa_function_pool[15336]: GetFenceivNV (will be remapped) */
    "iip\0"
    "glGetFenceivNV\0"
    "\0"
-   /* _mesa_function_pool[15084]: WindowPos4dvMESA (will be remapped) */
+   /* _mesa_function_pool[15356]: WindowPos4dvMESA (will be remapped) */
    "p\0"
    "glWindowPos4dvMESA\0"
    "\0"
-   /* _mesa_function_pool[15106]: ColorSubTable (offset 346) */
+   /* _mesa_function_pool[15378]: ColorSubTable (offset 346) */
    "iiiiip\0"
    "glColorSubTable\0"
    "glColorSubTableEXT\0"
    "\0"
-   /* _mesa_function_pool[15149]: Color4fv (offset 30) */
+   /* _mesa_function_pool[15421]: Color4fv (offset 30) */
    "p\0"
    "glColor4fv\0"
    "\0"
-   /* _mesa_function_pool[15163]: MultiTexCoord4ivARB (offset 405) */
+   /* _mesa_function_pool[15435]: MultiTexCoord4ivARB (offset 405) */
    "ip\0"
    "glMultiTexCoord4iv\0"
    "glMultiTexCoord4ivARB\0"
    "\0"
-   /* _mesa_function_pool[15208]: ProgramLocalParameters4fvEXT (will be remapped) */
-   "iiip\0"
-   "glProgramLocalParameters4fvEXT\0"
+   /* _mesa_function_pool[15480]: DrawElementsInstanced (will be remapped) */
+   "iiipi\0"
+   "glDrawElementsInstanced\0"
+   "glDrawElementsInstancedARB\0"
+   "glDrawElementsInstancedEXT\0"
    "\0"
-   /* _mesa_function_pool[15245]: ColorPointer (offset 308) */
+   /* _mesa_function_pool[15565]: ColorPointer (offset 308) */
    "iiip\0"
    "glColorPointer\0"
    "\0"
-   /* _mesa_function_pool[15266]: Rects (offset 92) */
+   /* _mesa_function_pool[15586]: Rects (offset 92) */
    "iiii\0"
    "glRects\0"
    "\0"
-   /* _mesa_function_pool[15280]: GetMapAttribParameterfvNV (dynamic) */
+   /* _mesa_function_pool[15600]: GetMapAttribParameterfvNV (dynamic) */
    "iiip\0"
    "glGetMapAttribParameterfvNV\0"
    "\0"
-   /* _mesa_function_pool[15314]: Lightiv (offset 162) */
+   /* _mesa_function_pool[15634]: Lightiv (offset 162) */
    "iip\0"
    "glLightiv\0"
    "\0"
-   /* _mesa_function_pool[15329]: VertexAttrib4sARB (will be remapped) */
+   /* _mesa_function_pool[15649]: VertexAttrib4sARB (will be remapped) */
    "iiiii\0"
    "glVertexAttrib4s\0"
    "glVertexAttrib4sARB\0"
    "\0"
-   /* _mesa_function_pool[15373]: GetQueryObjectuivARB (will be remapped) */
+   /* _mesa_function_pool[15693]: GetQueryObjectuivARB (will be remapped) */
    "iip\0"
    "glGetQueryObjectuiv\0"
    "glGetQueryObjectuivARB\0"
    "\0"
-   /* _mesa_function_pool[15421]: GetTexParameteriv (offset 283) */
+   /* _mesa_function_pool[15741]: GetTexParameteriv (offset 283) */
    "iip\0"
    "glGetTexParameteriv\0"
    "\0"
-   /* _mesa_function_pool[15446]: MapParameterivNV (dynamic) */
+   /* _mesa_function_pool[15766]: MapParameterivNV (dynamic) */
    "iip\0"
    "glMapParameterivNV\0"
    "\0"
-   /* _mesa_function_pool[15470]: GenRenderbuffersEXT (will be remapped) */
+   /* _mesa_function_pool[15790]: GenRenderbuffersEXT (will be remapped) */
    "ip\0"
    "glGenRenderbuffers\0"
    "glGenRenderbuffersEXT\0"
    "\0"
-   /* _mesa_function_pool[15515]: VertexAttrib2dvARB (will be remapped) */
+   /* _mesa_function_pool[15835]: VertexAttrib2dvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib2dv\0"
    "glVertexAttrib2dvARB\0"
    "\0"
-   /* _mesa_function_pool[15558]: EdgeFlagPointerEXT (will be remapped) */
+   /* _mesa_function_pool[15878]: EdgeFlagPointerEXT (will be remapped) */
    "iip\0"
    "glEdgeFlagPointerEXT\0"
    "\0"
-   /* _mesa_function_pool[15584]: VertexAttribs2svNV (will be remapped) */
+   /* _mesa_function_pool[15904]: VertexAttribs2svNV (will be remapped) */
    "iip\0"
    "glVertexAttribs2svNV\0"
    "\0"
-   /* _mesa_function_pool[15610]: WeightbvARB (dynamic) */
+   /* _mesa_function_pool[15930]: WeightbvARB (dynamic) */
    "ip\0"
    "glWeightbvARB\0"
    "\0"
-   /* _mesa_function_pool[15628]: VertexAttrib2fvARB (will be remapped) */
+   /* _mesa_function_pool[15948]: VertexAttrib2fvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib2fv\0"
    "glVertexAttrib2fvARB\0"
    "\0"
-   /* _mesa_function_pool[15671]: GetBufferParameterivARB (will be remapped) */
+   /* _mesa_function_pool[15991]: GetBufferParameterivARB (will be remapped) */
    "iip\0"
    "glGetBufferParameteriv\0"
    "glGetBufferParameterivARB\0"
    "\0"
-   /* _mesa_function_pool[15725]: Rectdv (offset 87) */
+   /* _mesa_function_pool[16045]: Rectdv (offset 87) */
    "pp\0"
    "glRectdv\0"
    "\0"
-   /* _mesa_function_pool[15738]: ListParameteriSGIX (dynamic) */
+   /* _mesa_function_pool[16058]: ListParameteriSGIX (dynamic) */
    "iii\0"
    "glListParameteriSGIX\0"
    "\0"
-   /* _mesa_function_pool[15764]: ReplacementCodeuiColor4fNormal3fVertex3fSUN (dynamic) */
+   /* _mesa_function_pool[16084]: ReplacementCodeuiColor4fNormal3fVertex3fSUN (dynamic) */
    "iffffffffff\0"
    "glReplacementCodeuiColor4fNormal3fVertex3fSUN\0"
    "\0"
-   /* _mesa_function_pool[15823]: InstrumentsBufferSGIX (dynamic) */
+   /* _mesa_function_pool[16143]: InstrumentsBufferSGIX (dynamic) */
    "ip\0"
    "glInstrumentsBufferSGIX\0"
    "\0"
-   /* _mesa_function_pool[15851]: VertexAttrib4NivARB (will be remapped) */
+   /* _mesa_function_pool[16171]: VertexAttrib4NivARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4Niv\0"
    "glVertexAttrib4NivARB\0"
    "\0"
-   /* _mesa_function_pool[15896]: GetAttachedShaders (will be remapped) */
+   /* _mesa_function_pool[16216]: GetAttachedShaders (will be remapped) */
    "iipp\0"
    "glGetAttachedShaders\0"
    "\0"
-   /* _mesa_function_pool[15923]: GenVertexArraysAPPLE (will be remapped) */
+   /* _mesa_function_pool[16243]: GenVertexArraysAPPLE (will be remapped) */
    "ip\0"
    "glGenVertexArraysAPPLE\0"
    "\0"
-   /* _mesa_function_pool[15950]: Materialiv (offset 172) */
+   /* _mesa_function_pool[16270]: Materialiv (offset 172) */
    "iip\0"
    "glMaterialiv\0"
    "\0"
-   /* _mesa_function_pool[15968]: PushClientAttrib (offset 335) */
+   /* _mesa_function_pool[16288]: PushClientAttrib (offset 335) */
    "i\0"
    "glPushClientAttrib\0"
    "\0"
-   /* _mesa_function_pool[15990]: ProgramEnvParameters4fvEXT (will be remapped) */
+   /* _mesa_function_pool[16310]: ProgramEnvParameters4fvEXT (will be remapped) */
    "iiip\0"
    "glProgramEnvParameters4fvEXT\0"
    "\0"
-   /* _mesa_function_pool[16025]: TexCoord2fColor4fNormal3fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[16345]: TexCoord2fColor4fNormal3fVertex3fvSUN (dynamic) */
    "pppp\0"
    "glTexCoord2fColor4fNormal3fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[16071]: WindowPos2iMESA (will be remapped) */
+   /* _mesa_function_pool[16391]: WindowPos2iMESA (will be remapped) */
    "ii\0"
    "glWindowPos2i\0"
    "glWindowPos2iARB\0"
    "glWindowPos2iMESA\0"
    "\0"
-   /* _mesa_function_pool[16124]: SecondaryColor3fvEXT (will be remapped) */
+   /* _mesa_function_pool[16444]: SecondaryColor3fvEXT (will be remapped) */
    "p\0"
    "glSecondaryColor3fv\0"
    "glSecondaryColor3fvEXT\0"
    "\0"
-   /* _mesa_function_pool[16170]: PolygonMode (offset 174) */
+   /* _mesa_function_pool[16490]: PolygonMode (offset 174) */
    "ii\0"
    "glPolygonMode\0"
    "\0"
-   /* _mesa_function_pool[16188]: CompressedTexSubImage1DARB (will be remapped) */
+   /* _mesa_function_pool[16508]: CompressedTexSubImage1DARB (will be remapped) */
    "iiiiiip\0"
    "glCompressedTexSubImage1D\0"
    "glCompressedTexSubImage1DARB\0"
    "\0"
-   /* _mesa_function_pool[16252]: GetVertexAttribivNV (will be remapped) */
+   /* _mesa_function_pool[16572]: GetVertexAttribivNV (will be remapped) */
    "iip\0"
    "glGetVertexAttribivNV\0"
    "\0"
-   /* _mesa_function_pool[16279]: GetProgramStringARB (will be remapped) */
+   /* _mesa_function_pool[16599]: GetProgramStringARB (will be remapped) */
    "iip\0"
    "glGetProgramStringARB\0"
    "\0"
-   /* _mesa_function_pool[16306]: TexBumpParameterfvATI (will be remapped) */
+   /* _mesa_function_pool[16626]: TexBumpParameterfvATI (will be remapped) */
    "ip\0"
    "glTexBumpParameterfvATI\0"
    "\0"
-   /* _mesa_function_pool[16334]: CompileShaderARB (will be remapped) */
+   /* _mesa_function_pool[16654]: CompileShaderARB (will be remapped) */
    "i\0"
    "glCompileShader\0"
    "glCompileShaderARB\0"
    "\0"
-   /* _mesa_function_pool[16372]: DeleteShader (will be remapped) */
+   /* _mesa_function_pool[16692]: DeleteShader (will be remapped) */
    "i\0"
    "glDeleteShader\0"
    "\0"
-   /* _mesa_function_pool[16390]: DisableClientState (offset 309) */
+   /* _mesa_function_pool[16710]: DisableClientState (offset 309) */
    "i\0"
    "glDisableClientState\0"
    "\0"
-   /* _mesa_function_pool[16414]: TexGeni (offset 192) */
+   /* _mesa_function_pool[16734]: TexGeni (offset 192) */
    "iii\0"
    "glTexGeni\0"
    "\0"
-   /* _mesa_function_pool[16429]: TexGenf (offset 190) */
+   /* _mesa_function_pool[16749]: TexGenf (offset 190) */
    "iif\0"
    "glTexGenf\0"
    "\0"
-   /* _mesa_function_pool[16444]: Uniform3fARB (will be remapped) */
+   /* _mesa_function_pool[16764]: Uniform3fARB (will be remapped) */
    "ifff\0"
    "glUniform3f\0"
    "glUniform3fARB\0"
    "\0"
-   /* _mesa_function_pool[16477]: TexGend (offset 188) */
+   /* _mesa_function_pool[16797]: TexGend (offset 188) */
    "iid\0"
    "glTexGend\0"
    "\0"
-   /* _mesa_function_pool[16492]: ListParameterfvSGIX (dynamic) */
+   /* _mesa_function_pool[16812]: ListParameterfvSGIX (dynamic) */
    "iip\0"
    "glListParameterfvSGIX\0"
    "\0"
-   /* _mesa_function_pool[16519]: GetPolygonStipple (offset 274) */
+   /* _mesa_function_pool[16839]: GetPolygonStipple (offset 274) */
    "p\0"
    "glGetPolygonStipple\0"
    "\0"
-   /* _mesa_function_pool[16542]: Tangent3dvEXT (dynamic) */
+   /* _mesa_function_pool[16862]: Tangent3dvEXT (dynamic) */
    "p\0"
    "glTangent3dvEXT\0"
    "\0"
-   /* _mesa_function_pool[16561]: GetVertexAttribfvNV (will be remapped) */
-   "iip\0"
-   "glGetVertexAttribfvNV\0"
+   /* _mesa_function_pool[16881]: BindBufferOffsetEXT (will be remapped) */
+   "iiii\0"
+   "glBindBufferOffsetEXT\0"
    "\0"
-   /* _mesa_function_pool[16588]: WindowPos3sMESA (will be remapped) */
+   /* _mesa_function_pool[16909]: WindowPos3sMESA (will be remapped) */
    "iii\0"
    "glWindowPos3s\0"
    "glWindowPos3sARB\0"
    "glWindowPos3sMESA\0"
    "\0"
-   /* _mesa_function_pool[16642]: VertexAttrib2svNV (will be remapped) */
+   /* _mesa_function_pool[16963]: VertexAttrib2svNV (will be remapped) */
    "ip\0"
    "glVertexAttrib2svNV\0"
    "\0"
-   /* _mesa_function_pool[16666]: VertexAttribs1fvNV (will be remapped) */
-   "iip\0"
-   "glVertexAttribs1fvNV\0"
+   /* _mesa_function_pool[16987]: DisableIndexedEXT (will be remapped) */
+   "ii\0"
+   "glDisableIndexedEXT\0"
    "\0"
-   /* _mesa_function_pool[16692]: TexCoord2fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[17011]: BindBufferBaseEXT (will be remapped) */
+   "iii\0"
+   "glBindBufferBaseEXT\0"
+   "glBindBufferBase\0"
+   "\0"
+   /* _mesa_function_pool[17053]: TexCoord2fVertex3fvSUN (dynamic) */
    "pp\0"
    "glTexCoord2fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[16721]: WindowPos4sMESA (will be remapped) */
+   /* _mesa_function_pool[17082]: WindowPos4sMESA (will be remapped) */
    "iiii\0"
    "glWindowPos4sMESA\0"
    "\0"
-   /* _mesa_function_pool[16745]: VertexAttrib4NuivARB (will be remapped) */
+   /* _mesa_function_pool[17106]: VertexAttrib4NuivARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4Nuiv\0"
    "glVertexAttrib4NuivARB\0"
    "\0"
-   /* _mesa_function_pool[16792]: ClientActiveTextureARB (offset 375) */
+   /* _mesa_function_pool[17153]: ClientActiveTextureARB (offset 375) */
    "i\0"
    "glClientActiveTexture\0"
    "glClientActiveTextureARB\0"
    "\0"
-   /* _mesa_function_pool[16842]: PixelTexGenSGIX (will be remapped) */
+   /* _mesa_function_pool[17203]: PixelTexGenSGIX (will be remapped) */
    "i\0"
    "glPixelTexGenSGIX\0"
    "\0"
-   /* _mesa_function_pool[16863]: ReplacementCodeusvSUN (dynamic) */
+   /* _mesa_function_pool[17224]: ReplacementCodeusvSUN (dynamic) */
    "p\0"
    "glReplacementCodeusvSUN\0"
    "\0"
-   /* _mesa_function_pool[16890]: Uniform4fARB (will be remapped) */
+   /* _mesa_function_pool[17251]: Uniform4fARB (will be remapped) */
    "iffff\0"
    "glUniform4f\0"
    "glUniform4fARB\0"
    "\0"
-   /* _mesa_function_pool[16924]: Color4sv (offset 34) */
+   /* _mesa_function_pool[17285]: Color4sv (offset 34) */
    "p\0"
    "glColor4sv\0"
    "\0"
-   /* _mesa_function_pool[16938]: FlushMappedBufferRange (will be remapped) */
+   /* _mesa_function_pool[17299]: FlushMappedBufferRange (will be remapped) */
    "iii\0"
    "glFlushMappedBufferRange\0"
    "\0"
-   /* _mesa_function_pool[16968]: IsProgramNV (will be remapped) */
+   /* _mesa_function_pool[17329]: IsProgramNV (will be remapped) */
    "i\0"
    "glIsProgramARB\0"
    "glIsProgramNV\0"
    "\0"
-   /* _mesa_function_pool[17000]: FlushMappedBufferRangeAPPLE (will be remapped) */
+   /* _mesa_function_pool[17361]: FlushMappedBufferRangeAPPLE (will be remapped) */
    "iii\0"
    "glFlushMappedBufferRangeAPPLE\0"
    "\0"
-   /* _mesa_function_pool[17035]: PixelZoom (offset 246) */
+   /* _mesa_function_pool[17396]: PixelZoom (offset 246) */
    "ff\0"
    "glPixelZoom\0"
    "\0"
-   /* _mesa_function_pool[17051]: ReplacementCodePointerSUN (dynamic) */
+   /* _mesa_function_pool[17412]: ReplacementCodePointerSUN (dynamic) */
    "iip\0"
    "glReplacementCodePointerSUN\0"
    "\0"
-   /* _mesa_function_pool[17084]: ProgramEnvParameter4dARB (will be remapped) */
+   /* _mesa_function_pool[17445]: ProgramEnvParameter4dARB (will be remapped) */
    "iidddd\0"
    "glProgramEnvParameter4dARB\0"
    "glProgramParameter4dNV\0"
    "\0"
-   /* _mesa_function_pool[17142]: ColorTableParameterfv (offset 340) */
+   /* _mesa_function_pool[17503]: ColorTableParameterfv (offset 340) */
    "iip\0"
    "glColorTableParameterfv\0"
    "glColorTableParameterfvSGI\0"
    "\0"
-   /* _mesa_function_pool[17198]: FragmentLightModelfSGIX (dynamic) */
+   /* _mesa_function_pool[17559]: FragmentLightModelfSGIX (dynamic) */
    "if\0"
    "glFragmentLightModelfSGIX\0"
    "\0"
-   /* _mesa_function_pool[17228]: Binormal3bvEXT (dynamic) */
+   /* _mesa_function_pool[17589]: Binormal3bvEXT (dynamic) */
    "p\0"
    "glBinormal3bvEXT\0"
    "\0"
-   /* _mesa_function_pool[17248]: PixelMapuiv (offset 252) */
+   /* _mesa_function_pool[17609]: PixelMapuiv (offset 252) */
    "iip\0"
    "glPixelMapuiv\0"
    "\0"
-   /* _mesa_function_pool[17267]: Color3dv (offset 12) */
+   /* _mesa_function_pool[17628]: Color3dv (offset 12) */
    "p\0"
    "glColor3dv\0"
    "\0"
-   /* _mesa_function_pool[17281]: IsTexture (offset 330) */
+   /* _mesa_function_pool[17642]: IsTexture (offset 330) */
    "i\0"
    "glIsTexture\0"
    "glIsTextureEXT\0"
    "\0"
-   /* _mesa_function_pool[17311]: VertexWeightfvEXT (dynamic) */
+   /* _mesa_function_pool[17672]: VertexWeightfvEXT (dynamic) */
    "p\0"
    "glVertexWeightfvEXT\0"
    "\0"
-   /* _mesa_function_pool[17334]: VertexAttrib1dARB (will be remapped) */
+   /* _mesa_function_pool[17695]: VertexAttrib1dARB (will be remapped) */
    "id\0"
    "glVertexAttrib1d\0"
    "glVertexAttrib1dARB\0"
    "\0"
-   /* _mesa_function_pool[17375]: ImageTransformParameterivHP (dynamic) */
+   /* _mesa_function_pool[17736]: ImageTransformParameterivHP (dynamic) */
    "iip\0"
    "glImageTransformParameterivHP\0"
    "\0"
-   /* _mesa_function_pool[17410]: TexCoord4i (offset 122) */
+   /* _mesa_function_pool[17771]: TexCoord4i (offset 122) */
    "iiii\0"
    "glTexCoord4i\0"
    "\0"
-   /* _mesa_function_pool[17429]: DeleteQueriesARB (will be remapped) */
+   /* _mesa_function_pool[17790]: DeleteQueriesARB (will be remapped) */
    "ip\0"
    "glDeleteQueries\0"
    "glDeleteQueriesARB\0"
    "\0"
-   /* _mesa_function_pool[17468]: Color4ubVertex2fSUN (dynamic) */
+   /* _mesa_function_pool[17829]: Color4ubVertex2fSUN (dynamic) */
    "iiiiff\0"
    "glColor4ubVertex2fSUN\0"
    "\0"
-   /* _mesa_function_pool[17498]: FragmentColorMaterialSGIX (dynamic) */
+   /* _mesa_function_pool[17859]: FragmentColorMaterialSGIX (dynamic) */
    "ii\0"
    "glFragmentColorMaterialSGIX\0"
    "\0"
-   /* _mesa_function_pool[17530]: CurrentPaletteMatrixARB (dynamic) */
+   /* _mesa_function_pool[17891]: CurrentPaletteMatrixARB (dynamic) */
    "i\0"
    "glCurrentPaletteMatrixARB\0"
    "\0"
-   /* _mesa_function_pool[17559]: GetMapdv (offset 266) */
+   /* _mesa_function_pool[17920]: GetMapdv (offset 266) */
    "iip\0"
    "glGetMapdv\0"
    "\0"
-   /* _mesa_function_pool[17575]: ObjectPurgeableAPPLE (will be remapped) */
+   /* _mesa_function_pool[17936]: ObjectPurgeableAPPLE (will be remapped) */
    "iii\0"
    "glObjectPurgeableAPPLE\0"
    "\0"
-   /* _mesa_function_pool[17603]: SamplePatternSGIS (will be remapped) */
+   /* _mesa_function_pool[17964]: SamplePatternSGIS (will be remapped) */
    "i\0"
    "glSamplePatternSGIS\0"
    "glSamplePatternEXT\0"
    "\0"
-   /* _mesa_function_pool[17645]: PixelStoref (offset 249) */
+   /* _mesa_function_pool[18006]: PixelStoref (offset 249) */
    "if\0"
    "glPixelStoref\0"
    "\0"
-   /* _mesa_function_pool[17663]: IsQueryARB (will be remapped) */
+   /* _mesa_function_pool[18024]: IsQueryARB (will be remapped) */
    "i\0"
    "glIsQuery\0"
    "glIsQueryARB\0"
    "\0"
-   /* _mesa_function_pool[17689]: ReplacementCodeuiColor4ubVertex3fSUN (dynamic) */
+   /* _mesa_function_pool[18050]: ReplacementCodeuiColor4ubVertex3fSUN (dynamic) */
    "iiiiifff\0"
    "glReplacementCodeuiColor4ubVertex3fSUN\0"
    "\0"
-   /* _mesa_function_pool[17738]: PixelStorei (offset 250) */
+   /* _mesa_function_pool[18099]: PixelStorei (offset 250) */
    "ii\0"
    "glPixelStorei\0"
    "\0"
-   /* _mesa_function_pool[17756]: VertexAttrib4usvARB (will be remapped) */
+   /* _mesa_function_pool[18117]: VertexAttrib4usvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4usv\0"
    "glVertexAttrib4usvARB\0"
    "\0"
-   /* _mesa_function_pool[17801]: LinkProgramARB (will be remapped) */
+   /* _mesa_function_pool[18162]: LinkProgramARB (will be remapped) */
    "i\0"
    "glLinkProgram\0"
    "glLinkProgramARB\0"
    "\0"
-   /* _mesa_function_pool[17835]: VertexAttrib2fNV (will be remapped) */
+   /* _mesa_function_pool[18196]: VertexAttrib2fNV (will be remapped) */
    "iff\0"
    "glVertexAttrib2fNV\0"
    "\0"
-   /* _mesa_function_pool[17859]: ShaderSourceARB (will be remapped) */
+   /* _mesa_function_pool[18220]: ShaderSourceARB (will be remapped) */
    "iipp\0"
    "glShaderSource\0"
    "glShaderSourceARB\0"
    "\0"
-   /* _mesa_function_pool[17898]: FragmentMaterialiSGIX (dynamic) */
+   /* _mesa_function_pool[18259]: FragmentMaterialiSGIX (dynamic) */
    "iii\0"
    "glFragmentMaterialiSGIX\0"
    "\0"
-   /* _mesa_function_pool[17927]: EvalCoord2dv (offset 233) */
+   /* _mesa_function_pool[18288]: EvalCoord2dv (offset 233) */
    "p\0"
    "glEvalCoord2dv\0"
    "\0"
-   /* _mesa_function_pool[17945]: VertexAttrib3svARB (will be remapped) */
+   /* _mesa_function_pool[18306]: VertexAttrib3svARB (will be remapped) */
    "ip\0"
    "glVertexAttrib3sv\0"
    "glVertexAttrib3svARB\0"
    "\0"
-   /* _mesa_function_pool[17988]: ColorMaterial (offset 151) */
+   /* _mesa_function_pool[18349]: ColorMaterial (offset 151) */
    "ii\0"
    "glColorMaterial\0"
    "\0"
-   /* _mesa_function_pool[18008]: CompressedTexSubImage3DARB (will be remapped) */
+   /* _mesa_function_pool[18369]: CompressedTexSubImage3DARB (will be remapped) */
    "iiiiiiiiiip\0"
    "glCompressedTexSubImage3D\0"
    "glCompressedTexSubImage3DARB\0"
    "\0"
-   /* _mesa_function_pool[18076]: WindowPos2ivMESA (will be remapped) */
+   /* _mesa_function_pool[18437]: WindowPos2ivMESA (will be remapped) */
    "p\0"
    "glWindowPos2iv\0"
    "glWindowPos2ivARB\0"
    "glWindowPos2ivMESA\0"
    "\0"
-   /* _mesa_function_pool[18131]: IsFramebufferEXT (will be remapped) */
+   /* _mesa_function_pool[18492]: IsFramebufferEXT (will be remapped) */
    "i\0"
    "glIsFramebuffer\0"
    "glIsFramebufferEXT\0"
    "\0"
-   /* _mesa_function_pool[18169]: Uniform4ivARB (will be remapped) */
+   /* _mesa_function_pool[18530]: Uniform4ivARB (will be remapped) */
    "iip\0"
    "glUniform4iv\0"
    "glUniform4ivARB\0"
    "\0"
-   /* _mesa_function_pool[18203]: GetVertexAttribdvARB (will be remapped) */
+   /* _mesa_function_pool[18564]: GetVertexAttribdvARB (will be remapped) */
    "iip\0"
    "glGetVertexAttribdv\0"
    "glGetVertexAttribdvARB\0"
    "\0"
-   /* _mesa_function_pool[18251]: TexBumpParameterivATI (will be remapped) */
+   /* _mesa_function_pool[18612]: TexBumpParameterivATI (will be remapped) */
    "ip\0"
    "glTexBumpParameterivATI\0"
    "\0"
-   /* _mesa_function_pool[18279]: GetSeparableFilter (offset 359) */
+   /* _mesa_function_pool[18640]: GetSeparableFilter (offset 359) */
    "iiippp\0"
    "glGetSeparableFilter\0"
    "glGetSeparableFilterEXT\0"
    "\0"
-   /* _mesa_function_pool[18332]: Binormal3dEXT (dynamic) */
+   /* _mesa_function_pool[18693]: Binormal3dEXT (dynamic) */
    "ddd\0"
    "glBinormal3dEXT\0"
    "\0"
-   /* _mesa_function_pool[18353]: SpriteParameteriSGIX (dynamic) */
+   /* _mesa_function_pool[18714]: SpriteParameteriSGIX (dynamic) */
    "ii\0"
    "glSpriteParameteriSGIX\0"
    "\0"
-   /* _mesa_function_pool[18380]: RequestResidentProgramsNV (will be remapped) */
+   /* _mesa_function_pool[18741]: RequestResidentProgramsNV (will be remapped) */
    "ip\0"
    "glRequestResidentProgramsNV\0"
    "\0"
-   /* _mesa_function_pool[18412]: TagSampleBufferSGIX (dynamic) */
+   /* _mesa_function_pool[18773]: TagSampleBufferSGIX (dynamic) */
    "\0"
    "glTagSampleBufferSGIX\0"
    "\0"
-   /* _mesa_function_pool[18436]: ReplacementCodeusSUN (dynamic) */
-   "i\0"
-   "glReplacementCodeusSUN\0"
+   /* _mesa_function_pool[18797]: TransformFeedbackVaryingsEXT (will be remapped) */
+   "iipi\0"
+   "glTransformFeedbackVaryingsEXT\0"
+   "glTransformFeedbackVaryings\0"
    "\0"
-   /* _mesa_function_pool[18462]: FeedbackBuffer (offset 194) */
+   /* _mesa_function_pool[18862]: FeedbackBuffer (offset 194) */
    "iip\0"
    "glFeedbackBuffer\0"
    "\0"
-   /* _mesa_function_pool[18484]: RasterPos2iv (offset 67) */
+   /* _mesa_function_pool[18884]: RasterPos2iv (offset 67) */
    "p\0"
    "glRasterPos2iv\0"
    "\0"
-   /* _mesa_function_pool[18502]: TexImage1D (offset 182) */
+   /* _mesa_function_pool[18902]: TexImage1D (offset 182) */
    "iiiiiiip\0"
    "glTexImage1D\0"
    "\0"
-   /* _mesa_function_pool[18525]: ListParameterivSGIX (dynamic) */
+   /* _mesa_function_pool[18925]: ListParameterivSGIX (dynamic) */
    "iip\0"
    "glListParameterivSGIX\0"
    "\0"
-   /* _mesa_function_pool[18552]: MultiDrawElementsEXT (will be remapped) */
+   /* _mesa_function_pool[18952]: MultiDrawElementsEXT (will be remapped) */
    "ipipi\0"
    "glMultiDrawElements\0"
    "glMultiDrawElementsEXT\0"
    "\0"
-   /* _mesa_function_pool[18602]: Color3s (offset 17) */
+   /* _mesa_function_pool[19002]: Color3s (offset 17) */
    "iii\0"
    "glColor3s\0"
    "\0"
-   /* _mesa_function_pool[18617]: Uniform1ivARB (will be remapped) */
+   /* _mesa_function_pool[19017]: Uniform1ivARB (will be remapped) */
    "iip\0"
    "glUniform1iv\0"
    "glUniform1ivARB\0"
    "\0"
-   /* _mesa_function_pool[18651]: WindowPos2sMESA (will be remapped) */
+   /* _mesa_function_pool[19051]: WindowPos2sMESA (will be remapped) */
    "ii\0"
    "glWindowPos2s\0"
    "glWindowPos2sARB\0"
    "glWindowPos2sMESA\0"
    "\0"
-   /* _mesa_function_pool[18704]: WeightusvARB (dynamic) */
+   /* _mesa_function_pool[19104]: WeightusvARB (dynamic) */
    "ip\0"
    "glWeightusvARB\0"
    "\0"
-   /* _mesa_function_pool[18723]: TexCoordPointer (offset 320) */
+   /* _mesa_function_pool[19123]: TexCoordPointer (offset 320) */
    "iiip\0"
    "glTexCoordPointer\0"
    "\0"
-   /* _mesa_function_pool[18747]: FogCoordPointerEXT (will be remapped) */
+   /* _mesa_function_pool[19147]: FogCoordPointerEXT (will be remapped) */
    "iip\0"
    "glFogCoordPointer\0"
    "glFogCoordPointerEXT\0"
    "\0"
-   /* _mesa_function_pool[18791]: IndexMaterialEXT (dynamic) */
+   /* _mesa_function_pool[19191]: IndexMaterialEXT (dynamic) */
    "ii\0"
    "glIndexMaterialEXT\0"
    "\0"
-   /* _mesa_function_pool[18814]: Color3i (offset 15) */
+   /* _mesa_function_pool[19214]: Color3i (offset 15) */
    "iii\0"
    "glColor3i\0"
    "\0"
-   /* _mesa_function_pool[18829]: FrontFace (offset 157) */
+   /* _mesa_function_pool[19229]: FrontFace (offset 157) */
    "i\0"
    "glFrontFace\0"
    "\0"
-   /* _mesa_function_pool[18844]: EvalCoord2d (offset 232) */
+   /* _mesa_function_pool[19244]: EvalCoord2d (offset 232) */
    "dd\0"
    "glEvalCoord2d\0"
    "\0"
-   /* _mesa_function_pool[18862]: SecondaryColor3ubvEXT (will be remapped) */
+   /* _mesa_function_pool[19262]: SecondaryColor3ubvEXT (will be remapped) */
    "p\0"
    "glSecondaryColor3ubv\0"
    "glSecondaryColor3ubvEXT\0"
    "\0"
-   /* _mesa_function_pool[18910]: EvalCoord2f (offset 234) */
+   /* _mesa_function_pool[19310]: EvalCoord2f (offset 234) */
    "ff\0"
    "glEvalCoord2f\0"
    "\0"
-   /* _mesa_function_pool[18928]: VertexAttrib4dvARB (will be remapped) */
+   /* _mesa_function_pool[19328]: VertexAttrib4dvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4dv\0"
    "glVertexAttrib4dvARB\0"
    "\0"
-   /* _mesa_function_pool[18971]: BindAttribLocationARB (will be remapped) */
+   /* _mesa_function_pool[19371]: BindAttribLocationARB (will be remapped) */
    "iip\0"
    "glBindAttribLocation\0"
    "glBindAttribLocationARB\0"
    "\0"
-   /* _mesa_function_pool[19021]: Color3b (offset 9) */
+   /* _mesa_function_pool[19421]: Color3b (offset 9) */
    "iii\0"
    "glColor3b\0"
    "\0"
-   /* _mesa_function_pool[19036]: MultiTexCoord2dARB (offset 384) */
+   /* _mesa_function_pool[19436]: MultiTexCoord2dARB (offset 384) */
    "idd\0"
    "glMultiTexCoord2d\0"
    "glMultiTexCoord2dARB\0"
    "\0"
-   /* _mesa_function_pool[19080]: ExecuteProgramNV (will be remapped) */
+   /* _mesa_function_pool[19480]: ExecuteProgramNV (will be remapped) */
    "iip\0"
    "glExecuteProgramNV\0"
    "\0"
-   /* _mesa_function_pool[19104]: Color3f (offset 13) */
+   /* _mesa_function_pool[19504]: Color3f (offset 13) */
    "fff\0"
    "glColor3f\0"
    "\0"
-   /* _mesa_function_pool[19119]: LightEnviSGIX (dynamic) */
+   /* _mesa_function_pool[19519]: LightEnviSGIX (dynamic) */
    "ii\0"
    "glLightEnviSGIX\0"
    "\0"
-   /* _mesa_function_pool[19139]: Color3d (offset 11) */
+   /* _mesa_function_pool[19539]: Color3d (offset 11) */
    "ddd\0"
    "glColor3d\0"
    "\0"
-   /* _mesa_function_pool[19154]: Normal3dv (offset 55) */
+   /* _mesa_function_pool[19554]: Normal3dv (offset 55) */
    "p\0"
    "glNormal3dv\0"
    "\0"
-   /* _mesa_function_pool[19169]: Lightf (offset 159) */
+   /* _mesa_function_pool[19569]: Lightf (offset 159) */
    "iif\0"
    "glLightf\0"
    "\0"
-   /* _mesa_function_pool[19183]: ReplacementCodeuiSUN (dynamic) */
+   /* _mesa_function_pool[19583]: ReplacementCodeuiSUN (dynamic) */
    "i\0"
    "glReplacementCodeuiSUN\0"
    "\0"
-   /* _mesa_function_pool[19209]: MatrixMode (offset 293) */
+   /* _mesa_function_pool[19609]: MatrixMode (offset 293) */
    "i\0"
    "glMatrixMode\0"
    "\0"
-   /* _mesa_function_pool[19225]: GetPixelMapusv (offset 273) */
+   /* _mesa_function_pool[19625]: GetPixelMapusv (offset 273) */
    "ip\0"
    "glGetPixelMapusv\0"
    "\0"
-   /* _mesa_function_pool[19246]: Lighti (offset 161) */
+   /* _mesa_function_pool[19646]: Lighti (offset 161) */
    "iii\0"
    "glLighti\0"
    "\0"
-   /* _mesa_function_pool[19260]: VertexAttribPointerNV (will be remapped) */
+   /* _mesa_function_pool[19660]: VertexAttribPointerNV (will be remapped) */
    "iiiip\0"
    "glVertexAttribPointerNV\0"
    "\0"
-   /* _mesa_function_pool[19291]: GetBooleanIndexedvEXT (will be remapped) */
+   /* _mesa_function_pool[19691]: ProgramLocalParameters4fvEXT (will be remapped) */
+   "iiip\0"
+   "glProgramLocalParameters4fvEXT\0"
+   "\0"
+   /* _mesa_function_pool[19728]: GetBooleanIndexedvEXT (will be remapped) */
    "iip\0"
    "glGetBooleanIndexedvEXT\0"
    "\0"
-   /* _mesa_function_pool[19320]: GetFramebufferAttachmentParameterivEXT (will be remapped) */
+   /* _mesa_function_pool[19757]: GetFramebufferAttachmentParameterivEXT (will be remapped) */
    "iiip\0"
    "glGetFramebufferAttachmentParameteriv\0"
    "glGetFramebufferAttachmentParameterivEXT\0"
    "\0"
-   /* _mesa_function_pool[19405]: PixelTransformParameterfEXT (dynamic) */
+   /* _mesa_function_pool[19842]: PixelTransformParameterfEXT (dynamic) */
    "iif\0"
    "glPixelTransformParameterfEXT\0"
    "\0"
-   /* _mesa_function_pool[19440]: MultiTexCoord4dvARB (offset 401) */
+   /* _mesa_function_pool[19877]: MultiTexCoord4dvARB (offset 401) */
    "ip\0"
    "glMultiTexCoord4dv\0"
    "glMultiTexCoord4dvARB\0"
    "\0"
-   /* _mesa_function_pool[19485]: PixelTransformParameteriEXT (dynamic) */
+   /* _mesa_function_pool[19922]: PixelTransformParameteriEXT (dynamic) */
    "iii\0"
    "glPixelTransformParameteriEXT\0"
    "\0"
-   /* _mesa_function_pool[19520]: GetDoublev (offset 260) */
+   /* _mesa_function_pool[19957]: GetDoublev (offset 260) */
    "ip\0"
    "glGetDoublev\0"
    "\0"
-   /* _mesa_function_pool[19537]: MultMatrixd (offset 295) */
+   /* _mesa_function_pool[19974]: MultMatrixd (offset 295) */
    "p\0"
    "glMultMatrixd\0"
    "\0"
-   /* _mesa_function_pool[19554]: MultMatrixf (offset 294) */
+   /* _mesa_function_pool[19991]: MultMatrixf (offset 294) */
    "p\0"
    "glMultMatrixf\0"
    "\0"
-   /* _mesa_function_pool[19571]: TexCoord2fColor4ubVertex3fSUN (dynamic) */
+   /* _mesa_function_pool[20008]: TexCoord2fColor4ubVertex3fSUN (dynamic) */
    "ffiiiifff\0"
    "glTexCoord2fColor4ubVertex3fSUN\0"
    "\0"
-   /* _mesa_function_pool[19614]: Uniform1iARB (will be remapped) */
+   /* _mesa_function_pool[20051]: Uniform1iARB (will be remapped) */
    "ii\0"
    "glUniform1i\0"
    "glUniform1iARB\0"
    "\0"
-   /* _mesa_function_pool[19645]: VertexAttribPointerARB (will be remapped) */
+   /* _mesa_function_pool[20082]: VertexAttribPointerARB (will be remapped) */
    "iiiiip\0"
    "glVertexAttribPointer\0"
    "glVertexAttribPointerARB\0"
    "\0"
-   /* _mesa_function_pool[19700]: SharpenTexFuncSGIS (dynamic) */
+   /* _mesa_function_pool[20137]: SharpenTexFuncSGIS (dynamic) */
    "iip\0"
    "glSharpenTexFuncSGIS\0"
    "\0"
-   /* _mesa_function_pool[19726]: MultiTexCoord4fvARB (offset 403) */
+   /* _mesa_function_pool[20163]: MultiTexCoord4fvARB (offset 403) */
    "ip\0"
    "glMultiTexCoord4fv\0"
    "glMultiTexCoord4fvARB\0"
    "\0"
-   /* _mesa_function_pool[19771]: UniformMatrix2x3fv (will be remapped) */
+   /* _mesa_function_pool[20208]: UniformMatrix2x3fv (will be remapped) */
    "iiip\0"
    "glUniformMatrix2x3fv\0"
    "\0"
-   /* _mesa_function_pool[19798]: TrackMatrixNV (will be remapped) */
+   /* _mesa_function_pool[20235]: TrackMatrixNV (will be remapped) */
    "iiii\0"
    "glTrackMatrixNV\0"
    "\0"
-   /* _mesa_function_pool[19820]: CombinerParameteriNV (will be remapped) */
+   /* _mesa_function_pool[20257]: CombinerParameteriNV (will be remapped) */
    "ii\0"
    "glCombinerParameteriNV\0"
    "\0"
-   /* _mesa_function_pool[19847]: DeleteAsyncMarkersSGIX (dynamic) */
+   /* _mesa_function_pool[20284]: DeleteAsyncMarkersSGIX (dynamic) */
    "ii\0"
    "glDeleteAsyncMarkersSGIX\0"
    "\0"
-   /* _mesa_function_pool[19876]: IsAsyncMarkerSGIX (dynamic) */
+   /* _mesa_function_pool[20313]: ReplacementCodeusSUN (dynamic) */
+   "i\0"
+   "glReplacementCodeusSUN\0"
+   "\0"
+   /* _mesa_function_pool[20339]: IsAsyncMarkerSGIX (dynamic) */
    "i\0"
    "glIsAsyncMarkerSGIX\0"
    "\0"
-   /* _mesa_function_pool[19899]: FrameZoomSGIX (dynamic) */
+   /* _mesa_function_pool[20362]: FrameZoomSGIX (dynamic) */
    "i\0"
    "glFrameZoomSGIX\0"
    "\0"
-   /* _mesa_function_pool[19918]: Normal3fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[20381]: Normal3fVertex3fvSUN (dynamic) */
    "pp\0"
    "glNormal3fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[19945]: RasterPos4sv (offset 85) */
+   /* _mesa_function_pool[20408]: RasterPos4sv (offset 85) */
    "p\0"
    "glRasterPos4sv\0"
    "\0"
-   /* _mesa_function_pool[19963]: VertexAttrib4NsvARB (will be remapped) */
+   /* _mesa_function_pool[20426]: VertexAttrib4NsvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4Nsv\0"
    "glVertexAttrib4NsvARB\0"
    "\0"
-   /* _mesa_function_pool[20008]: VertexAttrib3fvARB (will be remapped) */
+   /* _mesa_function_pool[20471]: VertexAttrib3fvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib3fv\0"
    "glVertexAttrib3fvARB\0"
    "\0"
-   /* _mesa_function_pool[20051]: ClearColor (offset 206) */
+   /* _mesa_function_pool[20514]: ClearColor (offset 206) */
    "ffff\0"
    "glClearColor\0"
    "\0"
-   /* _mesa_function_pool[20070]: GetSynciv (will be remapped) */
+   /* _mesa_function_pool[20533]: GetSynciv (will be remapped) */
    "iiipp\0"
    "glGetSynciv\0"
    "\0"
-   /* _mesa_function_pool[20089]: DeleteFramebuffersEXT (will be remapped) */
+   /* _mesa_function_pool[20552]: DeleteFramebuffersEXT (will be remapped) */
    "ip\0"
    "glDeleteFramebuffers\0"
    "glDeleteFramebuffersEXT\0"
    "\0"
-   /* _mesa_function_pool[20138]: GlobalAlphaFactorsSUN (dynamic) */
+   /* _mesa_function_pool[20601]: GlobalAlphaFactorsSUN (dynamic) */
    "i\0"
    "glGlobalAlphaFactorsSUN\0"
    "\0"
-   /* _mesa_function_pool[20165]: IsEnabledIndexedEXT (will be remapped) */
+   /* _mesa_function_pool[20628]: IsEnabledIndexedEXT (will be remapped) */
    "ii\0"
    "glIsEnabledIndexedEXT\0"
    "\0"
-   /* _mesa_function_pool[20191]: TexEnviv (offset 187) */
+   /* _mesa_function_pool[20654]: TexEnviv (offset 187) */
    "iip\0"
    "glTexEnviv\0"
    "\0"
-   /* _mesa_function_pool[20207]: TexSubImage3D (offset 372) */
+   /* _mesa_function_pool[20670]: TexSubImage3D (offset 372) */
    "iiiiiiiiiip\0"
    "glTexSubImage3D\0"
    "glTexSubImage3DEXT\0"
    "\0"
-   /* _mesa_function_pool[20255]: Tangent3fEXT (dynamic) */
+   /* _mesa_function_pool[20718]: Tangent3fEXT (dynamic) */
    "fff\0"
    "glTangent3fEXT\0"
    "\0"
-   /* _mesa_function_pool[20275]: SecondaryColor3uivEXT (will be remapped) */
+   /* _mesa_function_pool[20738]: SecondaryColor3uivEXT (will be remapped) */
    "p\0"
    "glSecondaryColor3uiv\0"
    "glSecondaryColor3uivEXT\0"
    "\0"
-   /* _mesa_function_pool[20323]: MatrixIndexubvARB (dynamic) */
+   /* _mesa_function_pool[20786]: MatrixIndexubvARB (dynamic) */
    "ip\0"
    "glMatrixIndexubvARB\0"
    "\0"
-   /* _mesa_function_pool[20347]: Color4fNormal3fVertex3fSUN (dynamic) */
+   /* _mesa_function_pool[20810]: Color4fNormal3fVertex3fSUN (dynamic) */
    "ffffffffff\0"
    "glColor4fNormal3fVertex3fSUN\0"
    "\0"
-   /* _mesa_function_pool[20388]: PixelTexGenParameterfSGIS (will be remapped) */
+   /* _mesa_function_pool[20851]: PixelTexGenParameterfSGIS (will be remapped) */
    "if\0"
    "glPixelTexGenParameterfSGIS\0"
    "\0"
-   /* _mesa_function_pool[20420]: CreateShader (will be remapped) */
+   /* _mesa_function_pool[20883]: CreateShader (will be remapped) */
    "i\0"
    "glCreateShader\0"
    "\0"
-   /* _mesa_function_pool[20438]: GetColorTableParameterfv (offset 344) */
+   /* _mesa_function_pool[20901]: GetColorTableParameterfv (offset 344) */
    "iip\0"
    "glGetColorTableParameterfv\0"
    "glGetColorTableParameterfvSGI\0"
    "glGetColorTableParameterfvEXT\0"
    "\0"
-   /* _mesa_function_pool[20530]: FragmentLightModelfvSGIX (dynamic) */
+   /* _mesa_function_pool[20993]: FragmentLightModelfvSGIX (dynamic) */
    "ip\0"
    "glFragmentLightModelfvSGIX\0"
    "\0"
-   /* _mesa_function_pool[20561]: Bitmap (offset 8) */
+   /* _mesa_function_pool[21024]: Bitmap (offset 8) */
    "iiffffp\0"
    "glBitmap\0"
    "\0"
-   /* _mesa_function_pool[20579]: MultiTexCoord3fARB (offset 394) */
+   /* _mesa_function_pool[21042]: MultiTexCoord3fARB (offset 394) */
    "ifff\0"
    "glMultiTexCoord3f\0"
    "glMultiTexCoord3fARB\0"
    "\0"
-   /* _mesa_function_pool[20624]: GetTexLevelParameterfv (offset 284) */
+   /* _mesa_function_pool[21087]: GetTexLevelParameterfv (offset 284) */
    "iiip\0"
    "glGetTexLevelParameterfv\0"
    "\0"
-   /* _mesa_function_pool[20655]: GetPixelTexGenParameterfvSGIS (will be remapped) */
+   /* _mesa_function_pool[21118]: GetPixelTexGenParameterfvSGIS (will be remapped) */
    "ip\0"
    "glGetPixelTexGenParameterfvSGIS\0"
    "\0"
-   /* _mesa_function_pool[20691]: GenFramebuffersEXT (will be remapped) */
+   /* _mesa_function_pool[21154]: GenFramebuffersEXT (will be remapped) */
    "ip\0"
    "glGenFramebuffers\0"
    "glGenFramebuffersEXT\0"
    "\0"
-   /* _mesa_function_pool[20734]: GetProgramParameterdvNV (will be remapped) */
+   /* _mesa_function_pool[21197]: GetProgramParameterdvNV (will be remapped) */
    "iiip\0"
    "glGetProgramParameterdvNV\0"
    "\0"
-   /* _mesa_function_pool[20766]: Vertex2sv (offset 133) */
+   /* _mesa_function_pool[21229]: Vertex2sv (offset 133) */
    "p\0"
    "glVertex2sv\0"
    "\0"
-   /* _mesa_function_pool[20781]: GetIntegerv (offset 263) */
+   /* _mesa_function_pool[21244]: GetIntegerv (offset 263) */
    "ip\0"
    "glGetIntegerv\0"
    "\0"
-   /* _mesa_function_pool[20799]: IsVertexArrayAPPLE (will be remapped) */
+   /* _mesa_function_pool[21262]: IsVertexArrayAPPLE (will be remapped) */
    "i\0"
    "glIsVertexArray\0"
    "glIsVertexArrayAPPLE\0"
    "\0"
-   /* _mesa_function_pool[20839]: FragmentLightfvSGIX (dynamic) */
+   /* _mesa_function_pool[21302]: FragmentLightfvSGIX (dynamic) */
    "iip\0"
    "glFragmentLightfvSGIX\0"
    "\0"
-   /* _mesa_function_pool[20866]: DetachShader (will be remapped) */
+   /* _mesa_function_pool[21329]: DetachShader (will be remapped) */
    "ii\0"
    "glDetachShader\0"
    "\0"
-   /* _mesa_function_pool[20885]: VertexAttrib4NubARB (will be remapped) */
+   /* _mesa_function_pool[21348]: VertexAttrib4NubARB (will be remapped) */
    "iiiii\0"
    "glVertexAttrib4Nub\0"
    "glVertexAttrib4NubARB\0"
    "\0"
-   /* _mesa_function_pool[20933]: GetProgramEnvParameterfvARB (will be remapped) */
+   /* _mesa_function_pool[21396]: GetProgramEnvParameterfvARB (will be remapped) */
    "iip\0"
    "glGetProgramEnvParameterfvARB\0"
    "\0"
-   /* _mesa_function_pool[20968]: GetTrackMatrixivNV (will be remapped) */
+   /* _mesa_function_pool[21431]: GetTrackMatrixivNV (will be remapped) */
    "iiip\0"
    "glGetTrackMatrixivNV\0"
    "\0"
-   /* _mesa_function_pool[20995]: VertexAttrib3svNV (will be remapped) */
+   /* _mesa_function_pool[21458]: VertexAttrib3svNV (will be remapped) */
    "ip\0"
    "glVertexAttrib3svNV\0"
    "\0"
-   /* _mesa_function_pool[21019]: Uniform4fvARB (will be remapped) */
+   /* _mesa_function_pool[21482]: Uniform4fvARB (will be remapped) */
    "iip\0"
    "glUniform4fv\0"
    "glUniform4fvARB\0"
    "\0"
-   /* _mesa_function_pool[21053]: MultTransposeMatrixfARB (will be remapped) */
+   /* _mesa_function_pool[21516]: MultTransposeMatrixfARB (will be remapped) */
    "p\0"
    "glMultTransposeMatrixf\0"
    "glMultTransposeMatrixfARB\0"
    "\0"
-   /* _mesa_function_pool[21105]: GetTexEnviv (offset 277) */
+   /* _mesa_function_pool[21568]: GetTexEnviv (offset 277) */
    "iip\0"
    "glGetTexEnviv\0"
    "\0"
-   /* _mesa_function_pool[21124]: ColorFragmentOp1ATI (will be remapped) */
+   /* _mesa_function_pool[21587]: ColorFragmentOp1ATI (will be remapped) */
    "iiiiiii\0"
    "glColorFragmentOp1ATI\0"
    "\0"
-   /* _mesa_function_pool[21155]: GetUniformfvARB (will be remapped) */
+   /* _mesa_function_pool[21618]: GetUniformfvARB (will be remapped) */
    "iip\0"
    "glGetUniformfv\0"
    "glGetUniformfvARB\0"
    "\0"
-   /* _mesa_function_pool[21193]: EGLImageTargetRenderbufferStorageOES (will be remapped) */
+   /* _mesa_function_pool[21656]: EGLImageTargetRenderbufferStorageOES (will be remapped) */
    "ip\0"
    "glEGLImageTargetRenderbufferStorageOES\0"
    "\0"
-   /* _mesa_function_pool[21236]: PopClientAttrib (offset 334) */
+   /* _mesa_function_pool[21699]: PopClientAttrib (offset 334) */
    "\0"
    "glPopClientAttrib\0"
    "\0"
-   /* _mesa_function_pool[21256]: ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (dynamic) */
+   /* _mesa_function_pool[21719]: ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (dynamic) */
    "iffffffffffff\0"
    "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN\0"
    "\0"
-   /* _mesa_function_pool[21327]: DetachObjectARB (will be remapped) */
+   /* _mesa_function_pool[21790]: DetachObjectARB (will be remapped) */
    "ii\0"
    "glDetachObjectARB\0"
    "\0"
-   /* _mesa_function_pool[21349]: VertexBlendARB (dynamic) */
+   /* _mesa_function_pool[21812]: VertexBlendARB (dynamic) */
    "i\0"
    "glVertexBlendARB\0"
    "\0"
-   /* _mesa_function_pool[21369]: WindowPos3iMESA (will be remapped) */
+   /* _mesa_function_pool[21832]: WindowPos3iMESA (will be remapped) */
    "iii\0"
    "glWindowPos3i\0"
    "glWindowPos3iARB\0"
    "glWindowPos3iMESA\0"
    "\0"
-   /* _mesa_function_pool[21423]: SeparableFilter2D (offset 360) */
+   /* _mesa_function_pool[21886]: SeparableFilter2D (offset 360) */
    "iiiiiipp\0"
    "glSeparableFilter2D\0"
    "glSeparableFilter2DEXT\0"
    "\0"
-   /* _mesa_function_pool[21476]: ReplacementCodeuiColor4ubVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[21939]: ReplacementCodeuiColor4ubVertex3fvSUN (dynamic) */
    "ppp\0"
    "glReplacementCodeuiColor4ubVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[21521]: Map1d (offset 220) */
+   /* _mesa_function_pool[21984]: Map1d (offset 220) */
    "iddiip\0"
    "glMap1d\0"
    "\0"
-   /* _mesa_function_pool[21537]: Map1f (offset 221) */
+   /* _mesa_function_pool[22000]: Map1f (offset 221) */
    "iffiip\0"
    "glMap1f\0"
    "\0"
-   /* _mesa_function_pool[21553]: CompressedTexImage2DARB (will be remapped) */
+   /* _mesa_function_pool[22016]: CompressedTexImage2DARB (will be remapped) */
    "iiiiiiip\0"
    "glCompressedTexImage2D\0"
    "glCompressedTexImage2DARB\0"
    "\0"
-   /* _mesa_function_pool[21612]: ArrayElement (offset 306) */
+   /* _mesa_function_pool[22075]: ArrayElement (offset 306) */
    "i\0"
    "glArrayElement\0"
    "glArrayElementEXT\0"
    "\0"
-   /* _mesa_function_pool[21648]: TexImage2D (offset 183) */
+   /* _mesa_function_pool[22111]: TexImage2D (offset 183) */
    "iiiiiiiip\0"
    "glTexImage2D\0"
    "\0"
-   /* _mesa_function_pool[21672]: DepthBoundsEXT (will be remapped) */
+   /* _mesa_function_pool[22135]: DepthBoundsEXT (will be remapped) */
    "dd\0"
    "glDepthBoundsEXT\0"
    "\0"
-   /* _mesa_function_pool[21693]: ProgramParameters4fvNV (will be remapped) */
+   /* _mesa_function_pool[22156]: ProgramParameters4fvNV (will be remapped) */
    "iiip\0"
    "glProgramParameters4fvNV\0"
    "\0"
-   /* _mesa_function_pool[21724]: DeformationMap3fSGIX (dynamic) */
+   /* _mesa_function_pool[22187]: DeformationMap3fSGIX (dynamic) */
    "iffiiffiiffiip\0"
    "glDeformationMap3fSGIX\0"
    "\0"
-   /* _mesa_function_pool[21763]: GetProgramivNV (will be remapped) */
+   /* _mesa_function_pool[22226]: GetProgramivNV (will be remapped) */
    "iip\0"
    "glGetProgramivNV\0"
    "\0"
-   /* _mesa_function_pool[21785]: GetMinmaxParameteriv (offset 366) */
+   /* _mesa_function_pool[22248]: GetMinmaxParameteriv (offset 366) */
    "iip\0"
    "glGetMinmaxParameteriv\0"
    "glGetMinmaxParameterivEXT\0"
    "\0"
-   /* _mesa_function_pool[21839]: PixelTransferf (offset 247) */
+   /* _mesa_function_pool[22302]: PixelTransferf (offset 247) */
    "if\0"
    "glPixelTransferf\0"
    "\0"
-   /* _mesa_function_pool[21860]: CopyTexImage1D (offset 323) */
+   /* _mesa_function_pool[22323]: CopyTexImage1D (offset 323) */
    "iiiiiii\0"
    "glCopyTexImage1D\0"
    "glCopyTexImage1DEXT\0"
    "\0"
-   /* _mesa_function_pool[21906]: PushMatrix (offset 298) */
+   /* _mesa_function_pool[22369]: PushMatrix (offset 298) */
    "\0"
    "glPushMatrix\0"
    "\0"
-   /* _mesa_function_pool[21921]: Fogiv (offset 156) */
+   /* _mesa_function_pool[22384]: Fogiv (offset 156) */
    "ip\0"
    "glFogiv\0"
    "\0"
-   /* _mesa_function_pool[21933]: TexCoord1dv (offset 95) */
+   /* _mesa_function_pool[22396]: TexCoord1dv (offset 95) */
    "p\0"
    "glTexCoord1dv\0"
    "\0"
-   /* _mesa_function_pool[21950]: AlphaFragmentOp3ATI (will be remapped) */
+   /* _mesa_function_pool[22413]: AlphaFragmentOp3ATI (will be remapped) */
    "iiiiiiiiiiii\0"
    "glAlphaFragmentOp3ATI\0"
    "\0"
-   /* _mesa_function_pool[21986]: PixelTransferi (offset 248) */
+   /* _mesa_function_pool[22449]: PixelTransferi (offset 248) */
    "ii\0"
    "glPixelTransferi\0"
    "\0"
-   /* _mesa_function_pool[22007]: GetVertexAttribdvNV (will be remapped) */
+   /* _mesa_function_pool[22470]: GetVertexAttribdvNV (will be remapped) */
    "iip\0"
    "glGetVertexAttribdvNV\0"
    "\0"
-   /* _mesa_function_pool[22034]: VertexAttrib3fvNV (will be remapped) */
+   /* _mesa_function_pool[22497]: VertexAttrib3fvNV (will be remapped) */
    "ip\0"
    "glVertexAttrib3fvNV\0"
    "\0"
-   /* _mesa_function_pool[22058]: Rotatef (offset 300) */
+   /* _mesa_function_pool[22521]: Rotatef (offset 300) */
    "ffff\0"
    "glRotatef\0"
    "\0"
-   /* _mesa_function_pool[22074]: GetFinalCombinerInputParameterivNV (will be remapped) */
+   /* _mesa_function_pool[22537]: GetFinalCombinerInputParameterivNV (will be remapped) */
    "iip\0"
    "glGetFinalCombinerInputParameterivNV\0"
    "\0"
-   /* _mesa_function_pool[22116]: Vertex3i (offset 138) */
+   /* _mesa_function_pool[22579]: Vertex3i (offset 138) */
    "iii\0"
    "glVertex3i\0"
    "\0"
-   /* _mesa_function_pool[22132]: Vertex3f (offset 136) */
+   /* _mesa_function_pool[22595]: Vertex3f (offset 136) */
    "fff\0"
    "glVertex3f\0"
    "\0"
-   /* _mesa_function_pool[22148]: Clear (offset 203) */
+   /* _mesa_function_pool[22611]: Clear (offset 203) */
    "i\0"
    "glClear\0"
    "\0"
-   /* _mesa_function_pool[22159]: Vertex3d (offset 134) */
+   /* _mesa_function_pool[22622]: Vertex3d (offset 134) */
    "ddd\0"
    "glVertex3d\0"
    "\0"
-   /* _mesa_function_pool[22175]: GetMapParameterivNV (dynamic) */
+   /* _mesa_function_pool[22638]: GetMapParameterivNV (dynamic) */
    "iip\0"
    "glGetMapParameterivNV\0"
    "\0"
-   /* _mesa_function_pool[22202]: Uniform4iARB (will be remapped) */
+   /* _mesa_function_pool[22665]: Uniform4iARB (will be remapped) */
    "iiiii\0"
    "glUniform4i\0"
    "glUniform4iARB\0"
    "\0"
-   /* _mesa_function_pool[22236]: ReadBuffer (offset 254) */
+   /* _mesa_function_pool[22699]: ReadBuffer (offset 254) */
    "i\0"
    "glReadBuffer\0"
    "\0"
-   /* _mesa_function_pool[22252]: ConvolutionParameteri (offset 352) */
+   /* _mesa_function_pool[22715]: ConvolutionParameteri (offset 352) */
    "iii\0"
    "glConvolutionParameteri\0"
    "glConvolutionParameteriEXT\0"
    "\0"
-   /* _mesa_function_pool[22308]: Ortho (offset 296) */
+   /* _mesa_function_pool[22771]: Ortho (offset 296) */
    "dddddd\0"
    "glOrtho\0"
    "\0"
-   /* _mesa_function_pool[22324]: Binormal3sEXT (dynamic) */
+   /* _mesa_function_pool[22787]: Binormal3sEXT (dynamic) */
    "iii\0"
    "glBinormal3sEXT\0"
    "\0"
-   /* _mesa_function_pool[22345]: ListBase (offset 6) */
+   /* _mesa_function_pool[22808]: ListBase (offset 6) */
    "i\0"
    "glListBase\0"
    "\0"
-   /* _mesa_function_pool[22359]: Vertex3s (offset 140) */
+   /* _mesa_function_pool[22822]: Vertex3s (offset 140) */
    "iii\0"
    "glVertex3s\0"
    "\0"
-   /* _mesa_function_pool[22375]: ConvolutionParameterf (offset 350) */
+   /* _mesa_function_pool[22838]: ConvolutionParameterf (offset 350) */
    "iif\0"
    "glConvolutionParameterf\0"
    "glConvolutionParameterfEXT\0"
    "\0"
-   /* _mesa_function_pool[22431]: GetColorTableParameteriv (offset 345) */
+   /* _mesa_function_pool[22894]: GetColorTableParameteriv (offset 345) */
    "iip\0"
    "glGetColorTableParameteriv\0"
    "glGetColorTableParameterivSGI\0"
    "glGetColorTableParameterivEXT\0"
    "\0"
-   /* _mesa_function_pool[22523]: ProgramEnvParameter4dvARB (will be remapped) */
+   /* _mesa_function_pool[22986]: ProgramEnvParameter4dvARB (will be remapped) */
    "iip\0"
    "glProgramEnvParameter4dvARB\0"
    "glProgramParameter4dvNV\0"
    "\0"
-   /* _mesa_function_pool[22580]: ShadeModel (offset 177) */
+   /* _mesa_function_pool[23043]: ShadeModel (offset 177) */
    "i\0"
    "glShadeModel\0"
    "\0"
-   /* _mesa_function_pool[22596]: VertexAttribs2fvNV (will be remapped) */
+   /* _mesa_function_pool[23059]: VertexAttribs2fvNV (will be remapped) */
    "iip\0"
    "glVertexAttribs2fvNV\0"
    "\0"
-   /* _mesa_function_pool[22622]: Rectiv (offset 91) */
+   /* _mesa_function_pool[23085]: Rectiv (offset 91) */
    "pp\0"
    "glRectiv\0"
    "\0"
-   /* _mesa_function_pool[22635]: UseProgramObjectARB (will be remapped) */
+   /* _mesa_function_pool[23098]: UseProgramObjectARB (will be remapped) */
    "i\0"
    "glUseProgram\0"
    "glUseProgramObjectARB\0"
    "\0"
-   /* _mesa_function_pool[22673]: GetMapParameterfvNV (dynamic) */
+   /* _mesa_function_pool[23136]: GetMapParameterfvNV (dynamic) */
    "iip\0"
    "glGetMapParameterfvNV\0"
    "\0"
-   /* _mesa_function_pool[22700]: EndConditionalRenderNV (will be remapped) */
+   /* _mesa_function_pool[23163]: EndConditionalRenderNV (will be remapped) */
    "\0"
    "glEndConditionalRenderNV\0"
    "\0"
-   /* _mesa_function_pool[22727]: PassTexCoordATI (will be remapped) */
+   /* _mesa_function_pool[23190]: PassTexCoordATI (will be remapped) */
    "iii\0"
    "glPassTexCoordATI\0"
    "\0"
-   /* _mesa_function_pool[22750]: DeleteProgram (will be remapped) */
+   /* _mesa_function_pool[23213]: DeleteProgram (will be remapped) */
    "i\0"
    "glDeleteProgram\0"
    "\0"
-   /* _mesa_function_pool[22769]: Tangent3ivEXT (dynamic) */
+   /* _mesa_function_pool[23232]: Tangent3ivEXT (dynamic) */
    "p\0"
    "glTangent3ivEXT\0"
    "\0"
-   /* _mesa_function_pool[22788]: Tangent3dEXT (dynamic) */
+   /* _mesa_function_pool[23251]: Tangent3dEXT (dynamic) */
    "ddd\0"
    "glTangent3dEXT\0"
    "\0"
-   /* _mesa_function_pool[22808]: SecondaryColor3dvEXT (will be remapped) */
+   /* _mesa_function_pool[23271]: SecondaryColor3dvEXT (will be remapped) */
    "p\0"
    "glSecondaryColor3dv\0"
    "glSecondaryColor3dvEXT\0"
    "\0"
-   /* _mesa_function_pool[22854]: Vertex2fv (offset 129) */
+   /* _mesa_function_pool[23317]: Vertex2fv (offset 129) */
    "p\0"
    "glVertex2fv\0"
    "\0"
-   /* _mesa_function_pool[22869]: MultiDrawArraysEXT (will be remapped) */
+   /* _mesa_function_pool[23332]: MultiDrawArraysEXT (will be remapped) */
    "ippi\0"
    "glMultiDrawArrays\0"
    "glMultiDrawArraysEXT\0"
    "\0"
-   /* _mesa_function_pool[22914]: BindRenderbufferEXT (will be remapped) */
+   /* _mesa_function_pool[23377]: BindRenderbufferEXT (will be remapped) */
    "ii\0"
    "glBindRenderbuffer\0"
    "glBindRenderbufferEXT\0"
    "\0"
-   /* _mesa_function_pool[22959]: MultiTexCoord4dARB (offset 400) */
+   /* _mesa_function_pool[23422]: MultiTexCoord4dARB (offset 400) */
    "idddd\0"
    "glMultiTexCoord4d\0"
    "glMultiTexCoord4dARB\0"
    "\0"
-   /* _mesa_function_pool[23005]: Vertex3sv (offset 141) */
+   /* _mesa_function_pool[23468]: Vertex3sv (offset 141) */
    "p\0"
    "glVertex3sv\0"
    "\0"
-   /* _mesa_function_pool[23020]: SecondaryColor3usEXT (will be remapped) */
+   /* _mesa_function_pool[23483]: SecondaryColor3usEXT (will be remapped) */
    "iii\0"
    "glSecondaryColor3us\0"
    "glSecondaryColor3usEXT\0"
    "\0"
-   /* _mesa_function_pool[23068]: ProgramLocalParameter4fvARB (will be remapped) */
+   /* _mesa_function_pool[23531]: ProgramLocalParameter4fvARB (will be remapped) */
    "iip\0"
    "glProgramLocalParameter4fvARB\0"
    "\0"
-   /* _mesa_function_pool[23103]: DeleteProgramsNV (will be remapped) */
+   /* _mesa_function_pool[23566]: DeleteProgramsNV (will be remapped) */
    "ip\0"
    "glDeleteProgramsARB\0"
    "glDeleteProgramsNV\0"
    "\0"
-   /* _mesa_function_pool[23146]: EvalMesh1 (offset 236) */
+   /* _mesa_function_pool[23609]: EvalMesh1 (offset 236) */
    "iii\0"
    "glEvalMesh1\0"
    "\0"
-   /* _mesa_function_pool[23163]: MultiTexCoord1sARB (offset 382) */
+   /* _mesa_function_pool[23626]: MultiTexCoord1sARB (offset 382) */
    "ii\0"
    "glMultiTexCoord1s\0"
    "glMultiTexCoord1sARB\0"
    "\0"
-   /* _mesa_function_pool[23206]: ReplacementCodeuiColor3fVertex3fSUN (dynamic) */
+   /* _mesa_function_pool[23669]: ReplacementCodeuiColor3fVertex3fSUN (dynamic) */
    "iffffff\0"
    "glReplacementCodeuiColor3fVertex3fSUN\0"
    "\0"
-   /* _mesa_function_pool[23253]: GetVertexAttribPointervNV (will be remapped) */
+   /* _mesa_function_pool[23716]: GetVertexAttribPointervNV (will be remapped) */
    "iip\0"
    "glGetVertexAttribPointerv\0"
    "glGetVertexAttribPointervARB\0"
    "glGetVertexAttribPointervNV\0"
    "\0"
-   /* _mesa_function_pool[23341]: DisableIndexedEXT (will be remapped) */
-   "ii\0"
-   "glDisableIndexedEXT\0"
+   /* _mesa_function_pool[23804]: VertexAttribs1fvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs1fvNV\0"
    "\0"
-   /* _mesa_function_pool[23365]: MultiTexCoord1dvARB (offset 377) */
+   /* _mesa_function_pool[23830]: MultiTexCoord1dvARB (offset 377) */
    "ip\0"
    "glMultiTexCoord1dv\0"
    "glMultiTexCoord1dvARB\0"
    "\0"
-   /* _mesa_function_pool[23410]: Uniform2iARB (will be remapped) */
+   /* _mesa_function_pool[23875]: Uniform2iARB (will be remapped) */
    "iii\0"
    "glUniform2i\0"
    "glUniform2iARB\0"
    "\0"
-   /* _mesa_function_pool[23442]: Vertex2iv (offset 131) */
+   /* _mesa_function_pool[23907]: Vertex2iv (offset 131) */
    "p\0"
    "glVertex2iv\0"
    "\0"
-   /* _mesa_function_pool[23457]: GetProgramStringNV (will be remapped) */
+   /* _mesa_function_pool[23922]: GetProgramStringNV (will be remapped) */
    "iip\0"
    "glGetProgramStringNV\0"
    "\0"
-   /* _mesa_function_pool[23483]: ColorPointerEXT (will be remapped) */
+   /* _mesa_function_pool[23948]: ColorPointerEXT (will be remapped) */
    "iiiip\0"
    "glColorPointerEXT\0"
    "\0"
-   /* _mesa_function_pool[23508]: LineWidth (offset 168) */
+   /* _mesa_function_pool[23973]: LineWidth (offset 168) */
    "f\0"
    "glLineWidth\0"
    "\0"
-   /* _mesa_function_pool[23523]: MapBufferARB (will be remapped) */
+   /* _mesa_function_pool[23988]: MapBufferARB (will be remapped) */
    "ii\0"
    "glMapBuffer\0"
    "glMapBufferARB\0"
    "\0"
-   /* _mesa_function_pool[23554]: MultiDrawElementsBaseVertex (will be remapped) */
+   /* _mesa_function_pool[24019]: MultiDrawElementsBaseVertex (will be remapped) */
    "ipipip\0"
    "glMultiDrawElementsBaseVertex\0"
    "\0"
-   /* _mesa_function_pool[23592]: Binormal3svEXT (dynamic) */
+   /* _mesa_function_pool[24057]: Binormal3svEXT (dynamic) */
    "p\0"
    "glBinormal3svEXT\0"
    "\0"
-   /* _mesa_function_pool[23612]: ApplyTextureEXT (dynamic) */
+   /* _mesa_function_pool[24077]: ApplyTextureEXT (dynamic) */
    "i\0"
    "glApplyTextureEXT\0"
    "\0"
-   /* _mesa_function_pool[23633]: TexGendv (offset 189) */
+   /* _mesa_function_pool[24098]: TexGendv (offset 189) */
    "iip\0"
    "glTexGendv\0"
    "\0"
-   /* _mesa_function_pool[23649]: EnableIndexedEXT (will be remapped) */
+   /* _mesa_function_pool[24114]: EnableIndexedEXT (will be remapped) */
    "ii\0"
    "glEnableIndexedEXT\0"
    "\0"
-   /* _mesa_function_pool[23672]: TextureMaterialEXT (dynamic) */
+   /* _mesa_function_pool[24137]: TextureMaterialEXT (dynamic) */
    "ii\0"
    "glTextureMaterialEXT\0"
    "\0"
-   /* _mesa_function_pool[23697]: TextureLightEXT (dynamic) */
+   /* _mesa_function_pool[24162]: TextureLightEXT (dynamic) */
    "i\0"
    "glTextureLightEXT\0"
    "\0"
-   /* _mesa_function_pool[23718]: ResetMinmax (offset 370) */
+   /* _mesa_function_pool[24183]: ResetMinmax (offset 370) */
    "i\0"
    "glResetMinmax\0"
    "glResetMinmaxEXT\0"
    "\0"
-   /* _mesa_function_pool[23752]: SpriteParameterfSGIX (dynamic) */
+   /* _mesa_function_pool[24217]: SpriteParameterfSGIX (dynamic) */
    "if\0"
    "glSpriteParameterfSGIX\0"
    "\0"
-   /* _mesa_function_pool[23779]: EnableClientState (offset 313) */
+   /* _mesa_function_pool[24244]: EnableClientState (offset 313) */
    "i\0"
    "glEnableClientState\0"
    "\0"
-   /* _mesa_function_pool[23802]: VertexAttrib4sNV (will be remapped) */
+   /* _mesa_function_pool[24267]: VertexAttrib4sNV (will be remapped) */
    "iiiii\0"
    "glVertexAttrib4sNV\0"
    "\0"
-   /* _mesa_function_pool[23828]: GetConvolutionParameterfv (offset 357) */
+   /* _mesa_function_pool[24293]: GetConvolutionParameterfv (offset 357) */
    "iip\0"
    "glGetConvolutionParameterfv\0"
    "glGetConvolutionParameterfvEXT\0"
    "\0"
-   /* _mesa_function_pool[23892]: VertexAttribs4dvNV (will be remapped) */
+   /* _mesa_function_pool[24357]: VertexAttribs4dvNV (will be remapped) */
    "iip\0"
    "glVertexAttribs4dvNV\0"
    "\0"
-   /* _mesa_function_pool[23918]: VertexAttrib4dARB (will be remapped) */
+   /* _mesa_function_pool[24383]: MultiModeDrawArraysIBM (will be remapped) */
+   "pppii\0"
+   "glMultiModeDrawArraysIBM\0"
+   "\0"
+   /* _mesa_function_pool[24415]: VertexAttrib4dARB (will be remapped) */
    "idddd\0"
    "glVertexAttrib4d\0"
    "glVertexAttrib4dARB\0"
    "\0"
-   /* _mesa_function_pool[23962]: GetTexBumpParameterfvATI (will be remapped) */
+   /* _mesa_function_pool[24459]: GetTexBumpParameterfvATI (will be remapped) */
    "ip\0"
    "glGetTexBumpParameterfvATI\0"
    "\0"
-   /* _mesa_function_pool[23993]: ProgramNamedParameter4dNV (will be remapped) */
+   /* _mesa_function_pool[24490]: ProgramNamedParameter4dNV (will be remapped) */
    "iipdddd\0"
    "glProgramNamedParameter4dNV\0"
    "\0"
-   /* _mesa_function_pool[24030]: GetMaterialfv (offset 269) */
+   /* _mesa_function_pool[24527]: GetMaterialfv (offset 269) */
    "iip\0"
    "glGetMaterialfv\0"
    "\0"
-   /* _mesa_function_pool[24051]: VertexWeightfEXT (dynamic) */
+   /* _mesa_function_pool[24548]: VertexWeightfEXT (dynamic) */
    "f\0"
    "glVertexWeightfEXT\0"
    "\0"
-   /* _mesa_function_pool[24073]: Binormal3fEXT (dynamic) */
+   /* _mesa_function_pool[24570]: Binormal3fEXT (dynamic) */
    "fff\0"
    "glBinormal3fEXT\0"
    "\0"
-   /* _mesa_function_pool[24094]: CallList (offset 2) */
+   /* _mesa_function_pool[24591]: CallList (offset 2) */
    "i\0"
    "glCallList\0"
    "\0"
-   /* _mesa_function_pool[24108]: Materialfv (offset 170) */
+   /* _mesa_function_pool[24605]: Materialfv (offset 170) */
    "iip\0"
    "glMaterialfv\0"
    "\0"
-   /* _mesa_function_pool[24126]: TexCoord3fv (offset 113) */
+   /* _mesa_function_pool[24623]: TexCoord3fv (offset 113) */
    "p\0"
    "glTexCoord3fv\0"
    "\0"
-   /* _mesa_function_pool[24143]: FogCoordfvEXT (will be remapped) */
+   /* _mesa_function_pool[24640]: FogCoordfvEXT (will be remapped) */
    "p\0"
    "glFogCoordfv\0"
    "glFogCoordfvEXT\0"
    "\0"
-   /* _mesa_function_pool[24175]: MultiTexCoord1ivARB (offset 381) */
+   /* _mesa_function_pool[24672]: MultiTexCoord1ivARB (offset 381) */
    "ip\0"
    "glMultiTexCoord1iv\0"
    "glMultiTexCoord1ivARB\0"
    "\0"
-   /* _mesa_function_pool[24220]: SecondaryColor3ubEXT (will be remapped) */
+   /* _mesa_function_pool[24717]: SecondaryColor3ubEXT (will be remapped) */
    "iii\0"
    "glSecondaryColor3ub\0"
    "glSecondaryColor3ubEXT\0"
    "\0"
-   /* _mesa_function_pool[24268]: MultiTexCoord2ivARB (offset 389) */
+   /* _mesa_function_pool[24765]: MultiTexCoord2ivARB (offset 389) */
    "ip\0"
    "glMultiTexCoord2iv\0"
    "glMultiTexCoord2ivARB\0"
    "\0"
-   /* _mesa_function_pool[24313]: FogFuncSGIS (dynamic) */
+   /* _mesa_function_pool[24810]: FogFuncSGIS (dynamic) */
    "ip\0"
    "glFogFuncSGIS\0"
    "\0"
-   /* _mesa_function_pool[24331]: CopyTexSubImage2D (offset 326) */
+   /* _mesa_function_pool[24828]: CopyTexSubImage2D (offset 326) */
    "iiiiiiii\0"
    "glCopyTexSubImage2D\0"
    "glCopyTexSubImage2DEXT\0"
    "\0"
-   /* _mesa_function_pool[24384]: GetObjectParameterivARB (will be remapped) */
+   /* _mesa_function_pool[24881]: GetObjectParameterivARB (will be remapped) */
    "iip\0"
    "glGetObjectParameterivARB\0"
    "\0"
-   /* _mesa_function_pool[24415]: Color3iv (offset 16) */
+   /* _mesa_function_pool[24912]: Color3iv (offset 16) */
    "p\0"
    "glColor3iv\0"
    "\0"
-   /* _mesa_function_pool[24429]: TexCoord4fVertex4fSUN (dynamic) */
+   /* _mesa_function_pool[24926]: TexCoord4fVertex4fSUN (dynamic) */
    "ffffffff\0"
    "glTexCoord4fVertex4fSUN\0"
    "\0"
-   /* _mesa_function_pool[24463]: DrawElements (offset 311) */
+   /* _mesa_function_pool[24960]: DrawElements (offset 311) */
    "iiip\0"
    "glDrawElements\0"
    "\0"
-   /* _mesa_function_pool[24484]: BindVertexArrayAPPLE (will be remapped) */
+   /* _mesa_function_pool[24981]: BindVertexArrayAPPLE (will be remapped) */
    "i\0"
    "glBindVertexArrayAPPLE\0"
    "\0"
-   /* _mesa_function_pool[24510]: GetProgramLocalParameterdvARB (will be remapped) */
+   /* _mesa_function_pool[25007]: GetProgramLocalParameterdvARB (will be remapped) */
    "iip\0"
    "glGetProgramLocalParameterdvARB\0"
    "\0"
-   /* _mesa_function_pool[24547]: GetHistogramParameteriv (offset 363) */
+   /* _mesa_function_pool[25044]: GetHistogramParameteriv (offset 363) */
    "iip\0"
    "glGetHistogramParameteriv\0"
    "glGetHistogramParameterivEXT\0"
    "\0"
-   /* _mesa_function_pool[24607]: MultiTexCoord1iARB (offset 380) */
+   /* _mesa_function_pool[25104]: MultiTexCoord1iARB (offset 380) */
    "ii\0"
    "glMultiTexCoord1i\0"
    "glMultiTexCoord1iARB\0"
    "\0"
-   /* _mesa_function_pool[24650]: GetConvolutionFilter (offset 356) */
+   /* _mesa_function_pool[25147]: GetConvolutionFilter (offset 356) */
    "iiip\0"
    "glGetConvolutionFilter\0"
    "glGetConvolutionFilterEXT\0"
    "\0"
-   /* _mesa_function_pool[24705]: GetProgramivARB (will be remapped) */
+   /* _mesa_function_pool[25202]: GetProgramivARB (will be remapped) */
    "iip\0"
    "glGetProgramivARB\0"
    "\0"
-   /* _mesa_function_pool[24728]: BlendFuncSeparateEXT (will be remapped) */
+   /* _mesa_function_pool[25225]: BlendFuncSeparateEXT (will be remapped) */
    "iiii\0"
    "glBlendFuncSeparate\0"
    "glBlendFuncSeparateEXT\0"
    "glBlendFuncSeparateINGR\0"
    "\0"
-   /* _mesa_function_pool[24801]: MapBufferRange (will be remapped) */
+   /* _mesa_function_pool[25298]: MapBufferRange (will be remapped) */
    "iiii\0"
    "glMapBufferRange\0"
    "\0"
-   /* _mesa_function_pool[24824]: ProgramParameters4dvNV (will be remapped) */
+   /* _mesa_function_pool[25321]: ProgramParameters4dvNV (will be remapped) */
    "iiip\0"
    "glProgramParameters4dvNV\0"
    "\0"
-   /* _mesa_function_pool[24855]: TexCoord2fColor3fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[25352]: TexCoord2fColor3fVertex3fvSUN (dynamic) */
    "ppp\0"
    "glTexCoord2fColor3fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[24892]: EvalPoint2 (offset 239) */
+   /* _mesa_function_pool[25389]: EvalPoint2 (offset 239) */
    "ii\0"
    "glEvalPoint2\0"
    "\0"
-   /* _mesa_function_pool[24909]: EvalPoint1 (offset 237) */
+   /* _mesa_function_pool[25406]: EvalPoint1 (offset 237) */
    "i\0"
    "glEvalPoint1\0"
    "\0"
-   /* _mesa_function_pool[24925]: Binormal3dvEXT (dynamic) */
+   /* _mesa_function_pool[25422]: Binormal3dvEXT (dynamic) */
    "p\0"
    "glBinormal3dvEXT\0"
    "\0"
-   /* _mesa_function_pool[24945]: PopMatrix (offset 297) */
+   /* _mesa_function_pool[25442]: PopMatrix (offset 297) */
    "\0"
    "glPopMatrix\0"
    "\0"
-   /* _mesa_function_pool[24959]: FinishFenceNV (will be remapped) */
+   /* _mesa_function_pool[25456]: FinishFenceNV (will be remapped) */
    "i\0"
    "glFinishFenceNV\0"
    "\0"
-   /* _mesa_function_pool[24978]: GetFogFuncSGIS (dynamic) */
+   /* _mesa_function_pool[25475]: GetFogFuncSGIS (dynamic) */
    "p\0"
    "glGetFogFuncSGIS\0"
    "\0"
-   /* _mesa_function_pool[24998]: GetUniformLocationARB (will be remapped) */
+   /* _mesa_function_pool[25495]: GetUniformLocationARB (will be remapped) */
    "ip\0"
    "glGetUniformLocation\0"
    "glGetUniformLocationARB\0"
    "\0"
-   /* _mesa_function_pool[25047]: SecondaryColor3fEXT (will be remapped) */
+   /* _mesa_function_pool[25544]: SecondaryColor3fEXT (will be remapped) */
    "fff\0"
    "glSecondaryColor3f\0"
    "glSecondaryColor3fEXT\0"
    "\0"
-   /* _mesa_function_pool[25093]: GetTexGeniv (offset 280) */
+   /* _mesa_function_pool[25590]: GetTexGeniv (offset 280) */
    "iip\0"
    "glGetTexGeniv\0"
    "\0"
-   /* _mesa_function_pool[25112]: CombinerInputNV (will be remapped) */
+   /* _mesa_function_pool[25609]: CombinerInputNV (will be remapped) */
    "iiiiii\0"
    "glCombinerInputNV\0"
    "\0"
-   /* _mesa_function_pool[25138]: VertexAttrib3sARB (will be remapped) */
+   /* _mesa_function_pool[25635]: VertexAttrib3sARB (will be remapped) */
    "iiii\0"
    "glVertexAttrib3s\0"
    "glVertexAttrib3sARB\0"
    "\0"
-   /* _mesa_function_pool[25181]: ReplacementCodeuiNormal3fVertex3fvSUN (dynamic) */
+   /* _mesa_function_pool[25678]: ColorMaskIndexedEXT (will be remapped) */
+   "iiiii\0"
+   "glColorMaskIndexedEXT\0"
+   "\0"
+   /* _mesa_function_pool[25707]: ReplacementCodeuiNormal3fVertex3fvSUN (dynamic) */
    "ppp\0"
    "glReplacementCodeuiNormal3fVertex3fvSUN\0"
    "\0"
-   /* _mesa_function_pool[25226]: Map2d (offset 222) */
+   /* _mesa_function_pool[25752]: Map2d (offset 222) */
    "iddiiddiip\0"
    "glMap2d\0"
    "\0"
-   /* _mesa_function_pool[25246]: Map2f (offset 223) */
+   /* _mesa_function_pool[25772]: Map2f (offset 223) */
    "iffiiffiip\0"
    "glMap2f\0"
    "\0"
-   /* _mesa_function_pool[25266]: ProgramStringARB (will be remapped) */
+   /* _mesa_function_pool[25792]: ProgramStringARB (will be remapped) */
    "iiip\0"
    "glProgramStringARB\0"
    "\0"
-   /* _mesa_function_pool[25291]: Vertex4s (offset 148) */
+   /* _mesa_function_pool[25817]: Vertex4s (offset 148) */
    "iiii\0"
    "glVertex4s\0"
    "\0"
-   /* _mesa_function_pool[25308]: TexCoord4fVertex4fvSUN (dynamic) */
+   /* _mesa_function_pool[25834]: TexCoord4fVertex4fvSUN (dynamic) */
    "pp\0"
    "glTexCoord4fVertex4fvSUN\0"
    "\0"
-   /* _mesa_function_pool[25337]: VertexAttrib3sNV (will be remapped) */
+   /* _mesa_function_pool[25863]: VertexAttrib3sNV (will be remapped) */
    "iiii\0"
    "glVertexAttrib3sNV\0"
    "\0"
-   /* _mesa_function_pool[25362]: VertexAttrib1fNV (will be remapped) */
+   /* _mesa_function_pool[25888]: VertexAttrib1fNV (will be remapped) */
    "if\0"
    "glVertexAttrib1fNV\0"
    "\0"
-   /* _mesa_function_pool[25385]: Vertex4f (offset 144) */
+   /* _mesa_function_pool[25911]: Vertex4f (offset 144) */
    "ffff\0"
    "glVertex4f\0"
    "\0"
-   /* _mesa_function_pool[25402]: EvalCoord1d (offset 228) */
+   /* _mesa_function_pool[25928]: EvalCoord1d (offset 228) */
    "d\0"
    "glEvalCoord1d\0"
    "\0"
-   /* _mesa_function_pool[25419]: Vertex4d (offset 142) */
+   /* _mesa_function_pool[25945]: Vertex4d (offset 142) */
    "dddd\0"
    "glVertex4d\0"
    "\0"
-   /* _mesa_function_pool[25436]: RasterPos4dv (offset 79) */
+   /* _mesa_function_pool[25962]: RasterPos4dv (offset 79) */
    "p\0"
    "glRasterPos4dv\0"
    "\0"
-   /* _mesa_function_pool[25454]: FragmentLightfSGIX (dynamic) */
+   /* _mesa_function_pool[25980]: FragmentLightfSGIX (dynamic) */
    "iif\0"
    "glFragmentLightfSGIX\0"
    "\0"
-   /* _mesa_function_pool[25480]: GetCompressedTexImageARB (will be remapped) */
+   /* _mesa_function_pool[26006]: GetCompressedTexImageARB (will be remapped) */
    "iip\0"
    "glGetCompressedTexImage\0"
    "glGetCompressedTexImageARB\0"
    "\0"
-   /* _mesa_function_pool[25536]: GetTexGenfv (offset 279) */
+   /* _mesa_function_pool[26062]: GetTexGenfv (offset 279) */
    "iip\0"
    "glGetTexGenfv\0"
    "\0"
-   /* _mesa_function_pool[25555]: Vertex4i (offset 146) */
+   /* _mesa_function_pool[26081]: Vertex4i (offset 146) */
    "iiii\0"
    "glVertex4i\0"
    "\0"
-   /* _mesa_function_pool[25572]: VertexWeightPointerEXT (dynamic) */
+   /* _mesa_function_pool[26098]: VertexWeightPointerEXT (dynamic) */
    "iiip\0"
    "glVertexWeightPointerEXT\0"
    "\0"
-   /* _mesa_function_pool[25603]: GetHistogram (offset 361) */
+   /* _mesa_function_pool[26129]: GetHistogram (offset 361) */
    "iiiip\0"
    "glGetHistogram\0"
    "glGetHistogramEXT\0"
    "\0"
-   /* _mesa_function_pool[25643]: ActiveStencilFaceEXT (will be remapped) */
+   /* _mesa_function_pool[26169]: ActiveStencilFaceEXT (will be remapped) */
    "i\0"
    "glActiveStencilFaceEXT\0"
    "\0"
-   /* _mesa_function_pool[25669]: StencilFuncSeparateATI (will be remapped) */
+   /* _mesa_function_pool[26195]: StencilFuncSeparateATI (will be remapped) */
    "iiii\0"
    "glStencilFuncSeparateATI\0"
    "\0"
-   /* _mesa_function_pool[25700]: Materialf (offset 169) */
+   /* _mesa_function_pool[26226]: Materialf (offset 169) */
    "iif\0"
    "glMaterialf\0"
    "\0"
-   /* _mesa_function_pool[25717]: GetShaderSourceARB (will be remapped) */
+   /* _mesa_function_pool[26243]: GetShaderSourceARB (will be remapped) */
    "iipp\0"
    "glGetShaderSource\0"
    "glGetShaderSourceARB\0"
    "\0"
-   /* _mesa_function_pool[25762]: IglooInterfaceSGIX (dynamic) */
+   /* _mesa_function_pool[26288]: IglooInterfaceSGIX (dynamic) */
    "ip\0"
    "glIglooInterfaceSGIX\0"
    "\0"
-   /* _mesa_function_pool[25787]: Materiali (offset 171) */
+   /* _mesa_function_pool[26313]: Materiali (offset 171) */
    "iii\0"
    "glMateriali\0"
    "\0"
-   /* _mesa_function_pool[25804]: VertexAttrib4dNV (will be remapped) */
+   /* _mesa_function_pool[26330]: VertexAttrib4dNV (will be remapped) */
    "idddd\0"
    "glVertexAttrib4dNV\0"
    "\0"
-   /* _mesa_function_pool[25830]: MultiModeDrawElementsIBM (will be remapped) */
+   /* _mesa_function_pool[26356]: MultiModeDrawElementsIBM (will be remapped) */
    "ppipii\0"
    "glMultiModeDrawElementsIBM\0"
    "\0"
-   /* _mesa_function_pool[25865]: Indexsv (offset 51) */
+   /* _mesa_function_pool[26391]: Indexsv (offset 51) */
    "p\0"
    "glIndexsv\0"
    "\0"
-   /* _mesa_function_pool[25878]: MultiTexCoord4svARB (offset 407) */
+   /* _mesa_function_pool[26404]: MultiTexCoord4svARB (offset 407) */
    "ip\0"
    "glMultiTexCoord4sv\0"
    "glMultiTexCoord4svARB\0"
    "\0"
-   /* _mesa_function_pool[25923]: LightModelfv (offset 164) */
+   /* _mesa_function_pool[26449]: LightModelfv (offset 164) */
    "ip\0"
    "glLightModelfv\0"
    "\0"
-   /* _mesa_function_pool[25942]: TexCoord2dv (offset 103) */
+   /* _mesa_function_pool[26468]: TexCoord2dv (offset 103) */
    "p\0"
    "glTexCoord2dv\0"
    "\0"
-   /* _mesa_function_pool[25959]: GenQueriesARB (will be remapped) */
+   /* _mesa_function_pool[26485]: GenQueriesARB (will be remapped) */
    "ip\0"
    "glGenQueries\0"
    "glGenQueriesARB\0"
    "\0"
-   /* _mesa_function_pool[25992]: EvalCoord1dv (offset 229) */
+   /* _mesa_function_pool[26518]: EvalCoord1dv (offset 229) */
    "p\0"
    "glEvalCoord1dv\0"
    "\0"
-   /* _mesa_function_pool[26010]: ReplacementCodeuiVertex3fSUN (dynamic) */
+   /* _mesa_function_pool[26536]: ReplacementCodeuiVertex3fSUN (dynamic) */
    "ifff\0"
    "glReplacementCodeuiVertex3fSUN\0"
    "\0"
-   /* _mesa_function_pool[26047]: Translated (offset 303) */
+   /* _mesa_function_pool[26573]: Translated (offset 303) */
    "ddd\0"
    "glTranslated\0"
    "\0"
-   /* _mesa_function_pool[26065]: Translatef (offset 304) */
+   /* _mesa_function_pool[26591]: Translatef (offset 304) */
    "fff\0"
    "glTranslatef\0"
    "\0"
-   /* _mesa_function_pool[26083]: StencilMask (offset 209) */
+   /* _mesa_function_pool[26609]: StencilMask (offset 209) */
    "i\0"
    "glStencilMask\0"
    "\0"
-   /* _mesa_function_pool[26100]: Tangent3iEXT (dynamic) */
+   /* _mesa_function_pool[26626]: Tangent3iEXT (dynamic) */
    "iii\0"
    "glTangent3iEXT\0"
    "\0"
-   /* _mesa_function_pool[26120]: GetLightiv (offset 265) */
+   /* _mesa_function_pool[26646]: GetLightiv (offset 265) */
    "iip\0"
    "glGetLightiv\0"
    "\0"
-   /* _mesa_function_pool[26138]: DrawMeshArraysSUN (dynamic) */
+   /* _mesa_function_pool[26664]: DrawMeshArraysSUN (dynamic) */
    "iiii\0"
    "glDrawMeshArraysSUN\0"
    "\0"
-   /* _mesa_function_pool[26164]: IsList (offset 287) */
+   /* _mesa_function_pool[26690]: IsList (offset 287) */
    "i\0"
    "glIsList\0"
    "\0"
-   /* _mesa_function_pool[26176]: IsSync (will be remapped) */
+   /* _mesa_function_pool[26702]: IsSync (will be remapped) */
    "i\0"
    "glIsSync\0"
    "\0"
-   /* _mesa_function_pool[26188]: RenderMode (offset 196) */
+   /* _mesa_function_pool[26714]: RenderMode (offset 196) */
    "i\0"
    "glRenderMode\0"
    "\0"
-   /* _mesa_function_pool[26204]: GetMapControlPointsNV (dynamic) */
+   /* _mesa_function_pool[26730]: GetMapControlPointsNV (dynamic) */
    "iiiiiip\0"
    "glGetMapControlPointsNV\0"
    "\0"
-   /* _mesa_function_pool[26237]: DrawBuffersARB (will be remapped) */
+   /* _mesa_function_pool[26763]: DrawBuffersARB (will be remapped) */
    "ip\0"
    "glDrawBuffers\0"
    "glDrawBuffersARB\0"
    "glDrawBuffersATI\0"
    "\0"
-   /* _mesa_function_pool[26289]: ProgramLocalParameter4fARB (will be remapped) */
+   /* _mesa_function_pool[26815]: ProgramLocalParameter4fARB (will be remapped) */
    "iiffff\0"
    "glProgramLocalParameter4fARB\0"
    "\0"
-   /* _mesa_function_pool[26326]: SpriteParameterivSGIX (dynamic) */
+   /* _mesa_function_pool[26852]: SpriteParameterivSGIX (dynamic) */
    "ip\0"
    "glSpriteParameterivSGIX\0"
    "\0"
-   /* _mesa_function_pool[26354]: ProvokingVertexEXT (will be remapped) */
+   /* _mesa_function_pool[26880]: ProvokingVertexEXT (will be remapped) */
    "i\0"
    "glProvokingVertexEXT\0"
    "glProvokingVertex\0"
    "\0"
-   /* _mesa_function_pool[26396]: MultiTexCoord1fARB (offset 378) */
+   /* _mesa_function_pool[26922]: MultiTexCoord1fARB (offset 378) */
    "if\0"
    "glMultiTexCoord1f\0"
    "glMultiTexCoord1fARB\0"
    "\0"
-   /* _mesa_function_pool[26439]: LoadName (offset 198) */
+   /* _mesa_function_pool[26965]: LoadName (offset 198) */
    "i\0"
    "glLoadName\0"
    "\0"
-   /* _mesa_function_pool[26453]: VertexAttribs4ubvNV (will be remapped) */
+   /* _mesa_function_pool[26979]: VertexAttribs4ubvNV (will be remapped) */
    "iip\0"
    "glVertexAttribs4ubvNV\0"
    "\0"
-   /* _mesa_function_pool[26480]: WeightsvARB (dynamic) */
+   /* _mesa_function_pool[27006]: WeightsvARB (dynamic) */
    "ip\0"
    "glWeightsvARB\0"
    "\0"
-   /* _mesa_function_pool[26498]: Uniform1fvARB (will be remapped) */
+   /* _mesa_function_pool[27024]: Uniform1fvARB (will be remapped) */
    "iip\0"
    "glUniform1fv\0"
    "glUniform1fvARB\0"
    "\0"
-   /* _mesa_function_pool[26532]: CopyTexSubImage1D (offset 325) */
+   /* _mesa_function_pool[27058]: CopyTexSubImage1D (offset 325) */
    "iiiiii\0"
    "glCopyTexSubImage1D\0"
    "glCopyTexSubImage1DEXT\0"
    "\0"
-   /* _mesa_function_pool[26583]: CullFace (offset 152) */
+   /* _mesa_function_pool[27109]: CullFace (offset 152) */
    "i\0"
    "glCullFace\0"
    "\0"
-   /* _mesa_function_pool[26597]: BindTexture (offset 307) */
+   /* _mesa_function_pool[27123]: BindTexture (offset 307) */
    "ii\0"
    "glBindTexture\0"
    "glBindTextureEXT\0"
    "\0"
-   /* _mesa_function_pool[26632]: BeginFragmentShaderATI (will be remapped) */
+   /* _mesa_function_pool[27158]: BeginFragmentShaderATI (will be remapped) */
    "\0"
    "glBeginFragmentShaderATI\0"
    "\0"
-   /* _mesa_function_pool[26659]: MultiTexCoord4fARB (offset 402) */
+   /* _mesa_function_pool[27185]: MultiTexCoord4fARB (offset 402) */
    "iffff\0"
    "glMultiTexCoord4f\0"
    "glMultiTexCoord4fARB\0"
    "\0"
-   /* _mesa_function_pool[26705]: VertexAttribs3svNV (will be remapped) */
+   /* _mesa_function_pool[27231]: VertexAttribs3svNV (will be remapped) */
    "iip\0"
    "glVertexAttribs3svNV\0"
    "\0"
-   /* _mesa_function_pool[26731]: StencilFunc (offset 243) */
+   /* _mesa_function_pool[27257]: StencilFunc (offset 243) */
    "iii\0"
    "glStencilFunc\0"
    "\0"
-   /* _mesa_function_pool[26750]: CopyPixels (offset 255) */
+   /* _mesa_function_pool[27276]: CopyPixels (offset 255) */
    "iiiii\0"
    "glCopyPixels\0"
    "\0"
-   /* _mesa_function_pool[26770]: Rectsv (offset 93) */
+   /* _mesa_function_pool[27296]: Rectsv (offset 93) */
    "pp\0"
    "glRectsv\0"
    "\0"
-   /* _mesa_function_pool[26783]: ReplacementCodeuivSUN (dynamic) */
+   /* _mesa_function_pool[27309]: ReplacementCodeuivSUN (dynamic) */
    "p\0"
    "glReplacementCodeuivSUN\0"
    "\0"
-   /* _mesa_function_pool[26810]: EnableVertexAttribArrayARB (will be remapped) */
+   /* _mesa_function_pool[27336]: EnableVertexAttribArrayARB (will be remapped) */
    "i\0"
    "glEnableVertexAttribArray\0"
    "glEnableVertexAttribArrayARB\0"
    "\0"
-   /* _mesa_function_pool[26868]: NormalPointervINTEL (dynamic) */
+   /* _mesa_function_pool[27394]: NormalPointervINTEL (dynamic) */
    "ip\0"
    "glNormalPointervINTEL\0"
    "\0"
-   /* _mesa_function_pool[26894]: CopyConvolutionFilter2D (offset 355) */
+   /* _mesa_function_pool[27420]: CopyConvolutionFilter2D (offset 355) */
    "iiiiii\0"
    "glCopyConvolutionFilter2D\0"
    "glCopyConvolutionFilter2DEXT\0"
    "\0"
-   /* _mesa_function_pool[26957]: WindowPos3ivMESA (will be remapped) */
+   /* _mesa_function_pool[27483]: WindowPos3ivMESA (will be remapped) */
    "p\0"
    "glWindowPos3iv\0"
    "glWindowPos3ivARB\0"
    "glWindowPos3ivMESA\0"
    "\0"
-   /* _mesa_function_pool[27012]: CopyBufferSubData (will be remapped) */
+   /* _mesa_function_pool[27538]: CopyBufferSubData (will be remapped) */
    "iiiii\0"
    "glCopyBufferSubData\0"
    "\0"
-   /* _mesa_function_pool[27039]: NormalPointer (offset 318) */
+   /* _mesa_function_pool[27565]: NormalPointer (offset 318) */
    "iip\0"
    "glNormalPointer\0"
    "\0"
-   /* _mesa_function_pool[27060]: TexParameterfv (offset 179) */
+   /* _mesa_function_pool[27586]: TexParameterfv (offset 179) */
    "iip\0"
    "glTexParameterfv\0"
    "\0"
-   /* _mesa_function_pool[27082]: IsBufferARB (will be remapped) */
+   /* _mesa_function_pool[27608]: IsBufferARB (will be remapped) */
    "i\0"
    "glIsBuffer\0"
    "glIsBufferARB\0"
    "\0"
-   /* _mesa_function_pool[27110]: WindowPos4iMESA (will be remapped) */
+   /* _mesa_function_pool[27636]: WindowPos4iMESA (will be remapped) */
    "iiii\0"
    "glWindowPos4iMESA\0"
    "\0"
-   /* _mesa_function_pool[27134]: VertexAttrib4uivARB (will be remapped) */
+   /* _mesa_function_pool[27660]: VertexAttrib4uivARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4uiv\0"
    "glVertexAttrib4uivARB\0"
    "\0"
-   /* _mesa_function_pool[27179]: Tangent3bvEXT (dynamic) */
+   /* _mesa_function_pool[27705]: Tangent3bvEXT (dynamic) */
    "p\0"
    "glTangent3bvEXT\0"
    "\0"
-   /* _mesa_function_pool[27198]: UniformMatrix3x4fv (will be remapped) */
+   /* _mesa_function_pool[27724]: UniformMatrix3x4fv (will be remapped) */
    "iiip\0"
    "glUniformMatrix3x4fv\0"
    "\0"
-   /* _mesa_function_pool[27225]: ClipPlane (offset 150) */
+   /* _mesa_function_pool[27751]: ClipPlane (offset 150) */
    "ip\0"
    "glClipPlane\0"
    "\0"
-   /* _mesa_function_pool[27241]: Recti (offset 90) */
+   /* _mesa_function_pool[27767]: Recti (offset 90) */
    "iiii\0"
    "glRecti\0"
    "\0"
-   /* _mesa_function_pool[27255]: DrawRangeElementsBaseVertex (will be remapped) */
+   /* _mesa_function_pool[27781]: DrawRangeElementsBaseVertex (will be remapped) */
    "iiiiipi\0"
    "glDrawRangeElementsBaseVertex\0"
    "\0"
-   /* _mesa_function_pool[27294]: TexCoordPointervINTEL (dynamic) */
+   /* _mesa_function_pool[27820]: TexCoordPointervINTEL (dynamic) */
    "iip\0"
    "glTexCoordPointervINTEL\0"
    "\0"
-   /* _mesa_function_pool[27323]: DeleteBuffersARB (will be remapped) */
+   /* _mesa_function_pool[27849]: DeleteBuffersARB (will be remapped) */
    "ip\0"
    "glDeleteBuffers\0"
    "glDeleteBuffersARB\0"
    "\0"
-   /* _mesa_function_pool[27362]: WindowPos4fvMESA (will be remapped) */
+   /* _mesa_function_pool[27888]: PixelTransformParameterfvEXT (dynamic) */
+   "iip\0"
+   "glPixelTransformParameterfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[27924]: WindowPos4fvMESA (will be remapped) */
    "p\0"
    "glWindowPos4fvMESA\0"
    "\0"
-   /* _mesa_function_pool[27384]: GetPixelMapuiv (offset 272) */
+   /* _mesa_function_pool[27946]: GetPixelMapuiv (offset 272) */
    "ip\0"
    "glGetPixelMapuiv\0"
    "\0"
-   /* _mesa_function_pool[27405]: Rectf (offset 88) */
+   /* _mesa_function_pool[27967]: Rectf (offset 88) */
    "ffff\0"
    "glRectf\0"
    "\0"
-   /* _mesa_function_pool[27419]: VertexAttrib1sNV (will be remapped) */
+   /* _mesa_function_pool[27981]: VertexAttrib1sNV (will be remapped) */
    "ii\0"
    "glVertexAttrib1sNV\0"
    "\0"
-   /* _mesa_function_pool[27442]: Indexfv (offset 47) */
+   /* _mesa_function_pool[28004]: Indexfv (offset 47) */
    "p\0"
    "glIndexfv\0"
    "\0"
-   /* _mesa_function_pool[27455]: SecondaryColor3svEXT (will be remapped) */
+   /* _mesa_function_pool[28017]: SecondaryColor3svEXT (will be remapped) */
    "p\0"
    "glSecondaryColor3sv\0"
    "glSecondaryColor3svEXT\0"
    "\0"
-   /* _mesa_function_pool[27501]: LoadTransposeMatrixfARB (will be remapped) */
+   /* _mesa_function_pool[28063]: LoadTransposeMatrixfARB (will be remapped) */
    "p\0"
    "glLoadTransposeMatrixf\0"
    "glLoadTransposeMatrixfARB\0"
    "\0"
-   /* _mesa_function_pool[27553]: GetPointerv (offset 329) */
+   /* _mesa_function_pool[28115]: GetPointerv (offset 329) */
    "ip\0"
    "glGetPointerv\0"
    "glGetPointervEXT\0"
    "\0"
-   /* _mesa_function_pool[27588]: Tangent3bEXT (dynamic) */
+   /* _mesa_function_pool[28150]: Tangent3bEXT (dynamic) */
    "iii\0"
    "glTangent3bEXT\0"
    "\0"
-   /* _mesa_function_pool[27608]: CombinerParameterfNV (will be remapped) */
+   /* _mesa_function_pool[28170]: CombinerParameterfNV (will be remapped) */
    "if\0"
    "glCombinerParameterfNV\0"
    "\0"
-   /* _mesa_function_pool[27635]: IndexMask (offset 212) */
+   /* _mesa_function_pool[28197]: IndexMask (offset 212) */
    "i\0"
    "glIndexMask\0"
    "\0"
-   /* _mesa_function_pool[27650]: BindProgramNV (will be remapped) */
+   /* _mesa_function_pool[28212]: BindProgramNV (will be remapped) */
    "ii\0"
    "glBindProgramARB\0"
    "glBindProgramNV\0"
    "\0"
-   /* _mesa_function_pool[27687]: VertexAttrib4svARB (will be remapped) */
+   /* _mesa_function_pool[28249]: VertexAttrib4svARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4sv\0"
    "glVertexAttrib4svARB\0"
    "\0"
-   /* _mesa_function_pool[27730]: GetFloatv (offset 262) */
+   /* _mesa_function_pool[28292]: GetFloatv (offset 262) */
    "ip\0"
    "glGetFloatv\0"
    "\0"
-   /* _mesa_function_pool[27746]: CreateDebugObjectMESA (dynamic) */
+   /* _mesa_function_pool[28308]: CreateDebugObjectMESA (dynamic) */
    "\0"
    "glCreateDebugObjectMESA\0"
    "\0"
-   /* _mesa_function_pool[27772]: GetShaderiv (will be remapped) */
+   /* _mesa_function_pool[28334]: GetShaderiv (will be remapped) */
    "iip\0"
    "glGetShaderiv\0"
    "\0"
-   /* _mesa_function_pool[27791]: ClientWaitSync (will be remapped) */
+   /* _mesa_function_pool[28353]: ClientWaitSync (will be remapped) */
    "iii\0"
    "glClientWaitSync\0"
    "\0"
-   /* _mesa_function_pool[27813]: TexCoord4s (offset 124) */
+   /* _mesa_function_pool[28375]: TexCoord4s (offset 124) */
    "iiii\0"
    "glTexCoord4s\0"
    "\0"
-   /* _mesa_function_pool[27832]: TexCoord3sv (offset 117) */
+   /* _mesa_function_pool[28394]: TexCoord3sv (offset 117) */
    "p\0"
    "glTexCoord3sv\0"
    "\0"
-   /* _mesa_function_pool[27849]: BindFragmentShaderATI (will be remapped) */
+   /* _mesa_function_pool[28411]: BindFragmentShaderATI (will be remapped) */
    "i\0"
    "glBindFragmentShaderATI\0"
    "\0"
-   /* _mesa_function_pool[27876]: PopAttrib (offset 218) */
+   /* _mesa_function_pool[28438]: PopAttrib (offset 218) */
    "\0"
    "glPopAttrib\0"
    "\0"
-   /* _mesa_function_pool[27890]: Fogfv (offset 154) */
+   /* _mesa_function_pool[28452]: Fogfv (offset 154) */
    "ip\0"
    "glFogfv\0"
    "\0"
-   /* _mesa_function_pool[27902]: UnmapBufferARB (will be remapped) */
+   /* _mesa_function_pool[28464]: UnmapBufferARB (will be remapped) */
    "i\0"
    "glUnmapBuffer\0"
    "glUnmapBufferARB\0"
    "\0"
-   /* _mesa_function_pool[27936]: InitNames (offset 197) */
+   /* _mesa_function_pool[28498]: InitNames (offset 197) */
    "\0"
    "glInitNames\0"
    "\0"
-   /* _mesa_function_pool[27950]: Normal3sv (offset 61) */
+   /* _mesa_function_pool[28512]: Normal3sv (offset 61) */
    "p\0"
    "glNormal3sv\0"
    "\0"
-   /* _mesa_function_pool[27965]: Minmax (offset 368) */
+   /* _mesa_function_pool[28527]: Minmax (offset 368) */
    "iii\0"
    "glMinmax\0"
    "glMinmaxEXT\0"
    "\0"
-   /* _mesa_function_pool[27991]: TexCoord4d (offset 118) */
+   /* _mesa_function_pool[28553]: TexCoord4d (offset 118) */
    "dddd\0"
    "glTexCoord4d\0"
    "\0"
-   /* _mesa_function_pool[28010]: DeformationMap3dSGIX (dynamic) */
-   "iddiiddiiddiip\0"
-   "glDeformationMap3dSGIX\0"
-   "\0"
-   /* _mesa_function_pool[28049]: TexCoord4f (offset 120) */
+   /* _mesa_function_pool[28572]: TexCoord4f (offset 120) */
    "ffff\0"
    "glTexCoord4f\0"
    "\0"
-   /* _mesa_function_pool[28068]: FogCoorddvEXT (will be remapped) */
+   /* _mesa_function_pool[28591]: FogCoorddvEXT (will be remapped) */
    "p\0"
    "glFogCoorddv\0"
    "glFogCoorddvEXT\0"
    "\0"
-   /* _mesa_function_pool[28100]: FinishTextureSUNX (dynamic) */
+   /* _mesa_function_pool[28623]: FinishTextureSUNX (dynamic) */
    "\0"
    "glFinishTextureSUNX\0"
    "\0"
-   /* _mesa_function_pool[28122]: GetFragmentLightfvSGIX (dynamic) */
+   /* _mesa_function_pool[28645]: GetFragmentLightfvSGIX (dynamic) */
    "iip\0"
    "glGetFragmentLightfvSGIX\0"
    "\0"
-   /* _mesa_function_pool[28152]: Binormal3fvEXT (dynamic) */
+   /* _mesa_function_pool[28675]: Binormal3fvEXT (dynamic) */
    "p\0"
    "glBinormal3fvEXT\0"
    "\0"
-   /* _mesa_function_pool[28172]: GetBooleanv (offset 258) */
+   /* _mesa_function_pool[28695]: GetBooleanv (offset 258) */
    "ip\0"
    "glGetBooleanv\0"
    "\0"
-   /* _mesa_function_pool[28190]: ColorFragmentOp3ATI (will be remapped) */
+   /* _mesa_function_pool[28713]: ColorFragmentOp3ATI (will be remapped) */
    "iiiiiiiiiiiii\0"
    "glColorFragmentOp3ATI\0"
    "\0"
-   /* _mesa_function_pool[28227]: Hint (offset 158) */
+   /* _mesa_function_pool[28750]: Hint (offset 158) */
    "ii\0"
    "glHint\0"
    "\0"
-   /* _mesa_function_pool[28238]: Color4dv (offset 28) */
+   /* _mesa_function_pool[28761]: Color4dv (offset 28) */
    "p\0"
    "glColor4dv\0"
    "\0"
-   /* _mesa_function_pool[28252]: VertexAttrib2svARB (will be remapped) */
+   /* _mesa_function_pool[28775]: VertexAttrib2svARB (will be remapped) */
    "ip\0"
    "glVertexAttrib2sv\0"
    "glVertexAttrib2svARB\0"
    "\0"
-   /* _mesa_function_pool[28295]: AreProgramsResidentNV (will be remapped) */
+   /* _mesa_function_pool[28818]: AreProgramsResidentNV (will be remapped) */
    "ipp\0"
    "glAreProgramsResidentNV\0"
    "\0"
-   /* _mesa_function_pool[28324]: WindowPos3svMESA (will be remapped) */
+   /* _mesa_function_pool[28847]: WindowPos3svMESA (will be remapped) */
    "p\0"
    "glWindowPos3sv\0"
    "glWindowPos3svARB\0"
    "glWindowPos3svMESA\0"
    "\0"
-   /* _mesa_function_pool[28379]: CopyColorSubTable (offset 347) */
+   /* _mesa_function_pool[28902]: CopyColorSubTable (offset 347) */
    "iiiii\0"
    "glCopyColorSubTable\0"
    "glCopyColorSubTableEXT\0"
    "\0"
-   /* _mesa_function_pool[28429]: WeightdvARB (dynamic) */
+   /* _mesa_function_pool[28952]: WeightdvARB (dynamic) */
    "ip\0"
    "glWeightdvARB\0"
    "\0"
-   /* _mesa_function_pool[28447]: DeleteRenderbuffersEXT (will be remapped) */
+   /* _mesa_function_pool[28970]: DeleteRenderbuffersEXT (will be remapped) */
    "ip\0"
    "glDeleteRenderbuffers\0"
    "glDeleteRenderbuffersEXT\0"
    "\0"
-   /* _mesa_function_pool[28498]: VertexAttrib4NubvARB (will be remapped) */
+   /* _mesa_function_pool[29021]: VertexAttrib4NubvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib4Nubv\0"
    "glVertexAttrib4NubvARB\0"
    "\0"
-   /* _mesa_function_pool[28545]: VertexAttrib3dvNV (will be remapped) */
+   /* _mesa_function_pool[29068]: VertexAttrib3dvNV (will be remapped) */
    "ip\0"
    "glVertexAttrib3dvNV\0"
    "\0"
-   /* _mesa_function_pool[28569]: GetObjectParameterfvARB (will be remapped) */
+   /* _mesa_function_pool[29092]: GetObjectParameterfvARB (will be remapped) */
    "iip\0"
    "glGetObjectParameterfvARB\0"
    "\0"
-   /* _mesa_function_pool[28600]: Vertex4iv (offset 147) */
+   /* _mesa_function_pool[29123]: Vertex4iv (offset 147) */
    "p\0"
    "glVertex4iv\0"
    "\0"
-   /* _mesa_function_pool[28615]: GetProgramEnvParameterdvARB (will be remapped) */
+   /* _mesa_function_pool[29138]: GetProgramEnvParameterdvARB (will be remapped) */
    "iip\0"
    "glGetProgramEnvParameterdvARB\0"
    "\0"
-   /* _mesa_function_pool[28650]: TexCoord4dv (offset 119) */
+   /* _mesa_function_pool[29173]: TexCoord4dv (offset 119) */
    "p\0"
    "glTexCoord4dv\0"
    "\0"
-   /* _mesa_function_pool[28667]: LockArraysEXT (will be remapped) */
+   /* _mesa_function_pool[29190]: LockArraysEXT (will be remapped) */
    "ii\0"
    "glLockArraysEXT\0"
    "\0"
-   /* _mesa_function_pool[28687]: Begin (offset 7) */
+   /* _mesa_function_pool[29210]: Begin (offset 7) */
    "i\0"
    "glBegin\0"
    "\0"
-   /* _mesa_function_pool[28698]: LightModeli (offset 165) */
+   /* _mesa_function_pool[29221]: LightModeli (offset 165) */
    "ii\0"
    "glLightModeli\0"
    "\0"
-   /* _mesa_function_pool[28716]: Rectfv (offset 89) */
+   /* _mesa_function_pool[29239]: Rectfv (offset 89) */
    "pp\0"
    "glRectfv\0"
    "\0"
-   /* _mesa_function_pool[28729]: LightModelf (offset 163) */
+   /* _mesa_function_pool[29252]: LightModelf (offset 163) */
    "if\0"
    "glLightModelf\0"
    "\0"
-   /* _mesa_function_pool[28747]: GetTexParameterfv (offset 282) */
+   /* _mesa_function_pool[29270]: GetTexParameterfv (offset 282) */
    "iip\0"
    "glGetTexParameterfv\0"
    "\0"
-   /* _mesa_function_pool[28772]: GetLightfv (offset 264) */
+   /* _mesa_function_pool[29295]: GetLightfv (offset 264) */
    "iip\0"
    "glGetLightfv\0"
    "\0"
-   /* _mesa_function_pool[28790]: PixelTransformParameterivEXT (dynamic) */
+   /* _mesa_function_pool[29313]: PixelTransformParameterivEXT (dynamic) */
    "iip\0"
    "glPixelTransformParameterivEXT\0"
    "\0"
-   /* _mesa_function_pool[28826]: BinormalPointerEXT (dynamic) */
+   /* _mesa_function_pool[29349]: BinormalPointerEXT (dynamic) */
    "iip\0"
    "glBinormalPointerEXT\0"
    "\0"
-   /* _mesa_function_pool[28852]: VertexAttrib1dNV (will be remapped) */
+   /* _mesa_function_pool[29375]: VertexAttrib1dNV (will be remapped) */
    "id\0"
    "glVertexAttrib1dNV\0"
    "\0"
-   /* _mesa_function_pool[28875]: GetCombinerInputParameterivNV (will be remapped) */
+   /* _mesa_function_pool[29398]: GetCombinerInputParameterivNV (will be remapped) */
    "iiiip\0"
    "glGetCombinerInputParameterivNV\0"
    "\0"
-   /* _mesa_function_pool[28914]: Disable (offset 214) */
+   /* _mesa_function_pool[29437]: Disable (offset 214) */
    "i\0"
    "glDisable\0"
    "\0"
-   /* _mesa_function_pool[28927]: MultiTexCoord2fvARB (offset 387) */
+   /* _mesa_function_pool[29450]: MultiTexCoord2fvARB (offset 387) */
    "ip\0"
    "glMultiTexCoord2fv\0"
    "glMultiTexCoord2fvARB\0"
    "\0"
-   /* _mesa_function_pool[28972]: GetRenderbufferParameterivEXT (will be remapped) */
+   /* _mesa_function_pool[29495]: GetRenderbufferParameterivEXT (will be remapped) */
    "iip\0"
    "glGetRenderbufferParameteriv\0"
    "glGetRenderbufferParameterivEXT\0"
    "\0"
-   /* _mesa_function_pool[29038]: CombinerParameterivNV (will be remapped) */
+   /* _mesa_function_pool[29561]: CombinerParameterivNV (will be remapped) */
    "ip\0"
    "glCombinerParameterivNV\0"
    "\0"
-   /* _mesa_function_pool[29066]: GenFragmentShadersATI (will be remapped) */
+   /* _mesa_function_pool[29589]: GenFragmentShadersATI (will be remapped) */
    "i\0"
    "glGenFragmentShadersATI\0"
    "\0"
-   /* _mesa_function_pool[29093]: DrawArrays (offset 310) */
+   /* _mesa_function_pool[29616]: DrawArrays (offset 310) */
    "iii\0"
    "glDrawArrays\0"
    "glDrawArraysEXT\0"
    "\0"
-   /* _mesa_function_pool[29127]: WeightuivARB (dynamic) */
+   /* _mesa_function_pool[29650]: WeightuivARB (dynamic) */
    "ip\0"
    "glWeightuivARB\0"
    "\0"
-   /* _mesa_function_pool[29146]: VertexAttrib2sARB (will be remapped) */
+   /* _mesa_function_pool[29669]: VertexAttrib2sARB (will be remapped) */
    "iii\0"
    "glVertexAttrib2s\0"
    "glVertexAttrib2sARB\0"
    "\0"
-   /* _mesa_function_pool[29188]: ColorMask (offset 210) */
+   /* _mesa_function_pool[29711]: ColorMask (offset 210) */
    "iiii\0"
    "glColorMask\0"
    "\0"
-   /* _mesa_function_pool[29206]: GenAsyncMarkersSGIX (dynamic) */
+   /* _mesa_function_pool[29729]: GenAsyncMarkersSGIX (dynamic) */
    "i\0"
    "glGenAsyncMarkersSGIX\0"
    "\0"
-   /* _mesa_function_pool[29231]: Tangent3svEXT (dynamic) */
+   /* _mesa_function_pool[29754]: Tangent3svEXT (dynamic) */
    "p\0"
    "glTangent3svEXT\0"
    "\0"
-   /* _mesa_function_pool[29250]: GetListParameterivSGIX (dynamic) */
+   /* _mesa_function_pool[29773]: GetListParameterivSGIX (dynamic) */
    "iip\0"
    "glGetListParameterivSGIX\0"
    "\0"
-   /* _mesa_function_pool[29280]: BindBufferARB (will be remapped) */
+   /* _mesa_function_pool[29803]: BindBufferARB (will be remapped) */
    "ii\0"
    "glBindBuffer\0"
    "glBindBufferARB\0"
    "\0"
-   /* _mesa_function_pool[29313]: GetInfoLogARB (will be remapped) */
+   /* _mesa_function_pool[29836]: GetInfoLogARB (will be remapped) */
    "iipp\0"
    "glGetInfoLogARB\0"
    "\0"
-   /* _mesa_function_pool[29335]: RasterPos4iv (offset 83) */
+   /* _mesa_function_pool[29858]: RasterPos4iv (offset 83) */
    "p\0"
    "glRasterPos4iv\0"
    "\0"
-   /* _mesa_function_pool[29353]: Enable (offset 215) */
+   /* _mesa_function_pool[29876]: Enable (offset 215) */
    "i\0"
    "glEnable\0"
    "\0"
-   /* _mesa_function_pool[29365]: LineStipple (offset 167) */
+   /* _mesa_function_pool[29888]: LineStipple (offset 167) */
    "ii\0"
    "glLineStipple\0"
    "\0"
-   /* _mesa_function_pool[29383]: VertexAttribs4svNV (will be remapped) */
+   /* _mesa_function_pool[29906]: VertexAttribs4svNV (will be remapped) */
    "iip\0"
    "glVertexAttribs4svNV\0"
    "\0"
-   /* _mesa_function_pool[29409]: EdgeFlagPointerListIBM (dynamic) */
+   /* _mesa_function_pool[29932]: EdgeFlagPointerListIBM (dynamic) */
    "ipi\0"
    "glEdgeFlagPointerListIBM\0"
    "\0"
-   /* _mesa_function_pool[29439]: UniformMatrix3x2fv (will be remapped) */
+   /* _mesa_function_pool[29962]: UniformMatrix3x2fv (will be remapped) */
    "iiip\0"
    "glUniformMatrix3x2fv\0"
    "\0"
-   /* _mesa_function_pool[29466]: GetMinmaxParameterfv (offset 365) */
+   /* _mesa_function_pool[29989]: GetMinmaxParameterfv (offset 365) */
    "iip\0"
    "glGetMinmaxParameterfv\0"
    "glGetMinmaxParameterfvEXT\0"
    "\0"
-   /* _mesa_function_pool[29520]: VertexAttrib1fvARB (will be remapped) */
+   /* _mesa_function_pool[30043]: VertexAttrib1fvARB (will be remapped) */
    "ip\0"
    "glVertexAttrib1fv\0"
    "glVertexAttrib1fvARB\0"
    "\0"
-   /* _mesa_function_pool[29563]: GenBuffersARB (will be remapped) */
+   /* _mesa_function_pool[30086]: GenBuffersARB (will be remapped) */
    "ip\0"
    "glGenBuffers\0"
    "glGenBuffersARB\0"
    "\0"
-   /* _mesa_function_pool[29596]: VertexAttribs1svNV (will be remapped) */
+   /* _mesa_function_pool[30119]: VertexAttribs1svNV (will be remapped) */
    "iip\0"
    "glVertexAttribs1svNV\0"
    "\0"
-   /* _mesa_function_pool[29622]: Vertex3fv (offset 137) */
+   /* _mesa_function_pool[30145]: Vertex3fv (offset 137) */
    "p\0"
    "glVertex3fv\0"
    "\0"
-   /* _mesa_function_pool[29637]: GetTexBumpParameterivATI (will be remapped) */
+   /* _mesa_function_pool[30160]: GetTexBumpParameterivATI (will be remapped) */
    "ip\0"
    "glGetTexBumpParameterivATI\0"
    "\0"
-   /* _mesa_function_pool[29668]: Binormal3bEXT (dynamic) */
+   /* _mesa_function_pool[30191]: Binormal3bEXT (dynamic) */
    "iii\0"
    "glBinormal3bEXT\0"
    "\0"
-   /* _mesa_function_pool[29689]: FragmentMaterialivSGIX (dynamic) */
+   /* _mesa_function_pool[30212]: FragmentMaterialivSGIX (dynamic) */
    "iip\0"
    "glFragmentMaterialivSGIX\0"
    "\0"
-   /* _mesa_function_pool[29719]: IsRenderbufferEXT (will be remapped) */
+   /* _mesa_function_pool[30242]: IsRenderbufferEXT (will be remapped) */
    "i\0"
    "glIsRenderbuffer\0"
    "glIsRenderbufferEXT\0"
    "\0"
-   /* _mesa_function_pool[29759]: GenProgramsNV (will be remapped) */
+   /* _mesa_function_pool[30282]: GenProgramsNV (will be remapped) */
    "ip\0"
    "glGenProgramsARB\0"
    "glGenProgramsNV\0"
    "\0"
-   /* _mesa_function_pool[29796]: VertexAttrib4dvNV (will be remapped) */
+   /* _mesa_function_pool[30319]: VertexAttrib4dvNV (will be remapped) */
    "ip\0"
    "glVertexAttrib4dvNV\0"
    "\0"
-   /* _mesa_function_pool[29820]: EndFragmentShaderATI (will be remapped) */
+   /* _mesa_function_pool[30343]: EndFragmentShaderATI (will be remapped) */
    "\0"
    "glEndFragmentShaderATI\0"
    "\0"
-   /* _mesa_function_pool[29845]: Binormal3iEXT (dynamic) */
+   /* _mesa_function_pool[30368]: Binormal3iEXT (dynamic) */
    "iii\0"
    "glBinormal3iEXT\0"
    "\0"
-   /* _mesa_function_pool[29866]: WindowPos2fMESA (will be remapped) */
+   /* _mesa_function_pool[30389]: WindowPos2fMESA (will be remapped) */
    "ff\0"
    "glWindowPos2f\0"
    "glWindowPos2fARB\0"
@@ -4386,405 +4432,414 @@ static const struct {
    GLint remap_index;
 } MESA_remap_table_functions[] = {
    {  1461, AttachShader_remap_index },
-   {  8794, CreateProgram_remap_index },
-   { 20420, CreateShader_remap_index },
-   { 22750, DeleteProgram_remap_index },
-   { 16372, DeleteShader_remap_index },
-   { 20866, DetachShader_remap_index },
-   { 15896, GetAttachedShaders_remap_index },
+   {  8848, CreateProgram_remap_index },
+   { 20883, CreateShader_remap_index },
+   { 23213, DeleteProgram_remap_index },
+   { 16692, DeleteShader_remap_index },
+   { 21329, DetachShader_remap_index },
+   { 16216, GetAttachedShaders_remap_index },
    {  4275, GetProgramInfoLog_remap_index },
    {   361, GetProgramiv_remap_index },
    {  5608, GetShaderInfoLog_remap_index },
-   { 27772, GetShaderiv_remap_index },
-   { 11879, IsProgram_remap_index },
-   { 10914, IsShader_remap_index },
-   {  8898, StencilFuncSeparate_remap_index },
+   { 28334, GetShaderiv_remap_index },
+   { 12054, IsProgram_remap_index },
+   { 11089, IsShader_remap_index },
+   {  8952, StencilFuncSeparate_remap_index },
    {  3487, StencilMaskSeparate_remap_index },
    {  6684, StencilOpSeparate_remap_index },
-   { 19771, UniformMatrix2x3fv_remap_index },
+   { 20208, UniformMatrix2x3fv_remap_index },
    {  2615, UniformMatrix2x4fv_remap_index },
-   { 29439, UniformMatrix3x2fv_remap_index },
-   { 27198, UniformMatrix3x4fv_remap_index },
-   { 14444, UniformMatrix4x2fv_remap_index },
+   { 29962, UniformMatrix3x2fv_remap_index },
+   { 27724, UniformMatrix3x4fv_remap_index },
+   { 14716, UniformMatrix4x2fv_remap_index },
    {  2937, UniformMatrix4x3fv_remap_index },
-   {  8812, LoadTransposeMatrixdARB_remap_index },
-   { 27501, LoadTransposeMatrixfARB_remap_index },
+   { 14377, DrawArraysInstanced_remap_index },
+   { 15480, DrawElementsInstanced_remap_index },
+   {  8866, LoadTransposeMatrixdARB_remap_index },
+   { 28063, LoadTransposeMatrixfARB_remap_index },
    {  4848, MultTransposeMatrixdARB_remap_index },
-   { 21053, MultTransposeMatrixfARB_remap_index },
+   { 21516, MultTransposeMatrixfARB_remap_index },
    {   172, SampleCoverageARB_remap_index },
    {  5032, CompressedTexImage1DARB_remap_index },
-   { 21553, CompressedTexImage2DARB_remap_index },
+   { 22016, CompressedTexImage2DARB_remap_index },
    {  3550, CompressedTexImage3DARB_remap_index },
-   { 16188, CompressedTexSubImage1DARB_remap_index },
+   { 16508, CompressedTexSubImage1DARB_remap_index },
    {  1880, CompressedTexSubImage2DARB_remap_index },
-   { 18008, CompressedTexSubImage3DARB_remap_index },
-   { 25480, GetCompressedTexImageARB_remap_index },
+   { 18369, CompressedTexSubImage3DARB_remap_index },
+   { 26006, GetCompressedTexImageARB_remap_index },
    {  3395, DisableVertexAttribArrayARB_remap_index },
-   { 26810, EnableVertexAttribArrayARB_remap_index },
-   { 28615, GetProgramEnvParameterdvARB_remap_index },
-   { 20933, GetProgramEnvParameterfvARB_remap_index },
-   { 24510, GetProgramLocalParameterdvARB_remap_index },
+   { 27336, EnableVertexAttribArrayARB_remap_index },
+   { 29138, GetProgramEnvParameterdvARB_remap_index },
+   { 21396, GetProgramEnvParameterfvARB_remap_index },
+   { 25007, GetProgramLocalParameterdvARB_remap_index },
    {  7126, GetProgramLocalParameterfvARB_remap_index },
-   { 16279, GetProgramStringARB_remap_index },
-   { 24705, GetProgramivARB_remap_index },
-   { 18203, GetVertexAttribdvARB_remap_index },
-   { 14333, GetVertexAttribfvARB_remap_index },
-   {  8707, GetVertexAttribivARB_remap_index },
-   { 17084, ProgramEnvParameter4dARB_remap_index },
-   { 22523, ProgramEnvParameter4dvARB_remap_index },
-   { 14941, ProgramEnvParameter4fARB_remap_index },
+   { 16599, GetProgramStringARB_remap_index },
+   { 25202, GetProgramivARB_remap_index },
+   { 18564, GetVertexAttribdvARB_remap_index },
+   { 14605, GetVertexAttribfvARB_remap_index },
+   {  8761, GetVertexAttribivARB_remap_index },
+   { 17445, ProgramEnvParameter4dARB_remap_index },
+   { 22986, ProgramEnvParameter4dvARB_remap_index },
+   { 15213, ProgramEnvParameter4fARB_remap_index },
    {  7989, ProgramEnvParameter4fvARB_remap_index },
    {  3513, ProgramLocalParameter4dARB_remap_index },
-   { 11589, ProgramLocalParameter4dvARB_remap_index },
-   { 26289, ProgramLocalParameter4fARB_remap_index },
-   { 23068, ProgramLocalParameter4fvARB_remap_index },
-   { 25266, ProgramStringARB_remap_index },
-   { 17334, VertexAttrib1dARB_remap_index },
-   { 13987, VertexAttrib1dvARB_remap_index },
+   { 11764, ProgramLocalParameter4dvARB_remap_index },
+   { 26815, ProgramLocalParameter4fARB_remap_index },
+   { 23531, ProgramLocalParameter4fvARB_remap_index },
+   { 25792, ProgramStringARB_remap_index },
+   { 17695, VertexAttrib1dARB_remap_index },
+   { 14181, VertexAttrib1dvARB_remap_index },
    {  3688, VertexAttrib1fARB_remap_index },
-   { 29520, VertexAttrib1fvARB_remap_index },
+   { 30043, VertexAttrib1fvARB_remap_index },
    {  6210, VertexAttrib1sARB_remap_index },
    {  2054, VertexAttrib1svARB_remap_index },
-   { 13418, VertexAttrib2dARB_remap_index },
-   { 15515, VertexAttrib2dvARB_remap_index },
+   { 13612, VertexAttrib2dARB_remap_index },
+   { 15835, VertexAttrib2dvARB_remap_index },
    {  1480, VertexAttrib2fARB_remap_index },
-   { 15628, VertexAttrib2fvARB_remap_index },
-   { 29146, VertexAttrib2sARB_remap_index },
-   { 28252, VertexAttrib2svARB_remap_index },
-   { 10045, VertexAttrib3dARB_remap_index },
+   { 15948, VertexAttrib2fvARB_remap_index },
+   { 29669, VertexAttrib2sARB_remap_index },
+   { 28775, VertexAttrib2svARB_remap_index },
+   { 10135, VertexAttrib3dARB_remap_index },
    {  7692, VertexAttrib3dvARB_remap_index },
    {  1567, VertexAttrib3fARB_remap_index },
-   { 20008, VertexAttrib3fvARB_remap_index },
-   { 25138, VertexAttrib3sARB_remap_index },
-   { 17945, VertexAttrib3svARB_remap_index },
+   { 20471, VertexAttrib3fvARB_remap_index },
+   { 25635, VertexAttrib3sARB_remap_index },
+   { 18306, VertexAttrib3svARB_remap_index },
    {  4301, VertexAttrib4NbvARB_remap_index },
-   { 15851, VertexAttrib4NivARB_remap_index },
-   { 19963, VertexAttrib4NsvARB_remap_index },
-   { 20885, VertexAttrib4NubARB_remap_index },
-   { 28498, VertexAttrib4NubvARB_remap_index },
-   { 16745, VertexAttrib4NuivARB_remap_index },
+   { 16171, VertexAttrib4NivARB_remap_index },
+   { 20426, VertexAttrib4NsvARB_remap_index },
+   { 21348, VertexAttrib4NubARB_remap_index },
+   { 29021, VertexAttrib4NubvARB_remap_index },
+   { 17106, VertexAttrib4NuivARB_remap_index },
    {  2810, VertexAttrib4NusvARB_remap_index },
-   {  9639, VertexAttrib4bvARB_remap_index },
-   { 23918, VertexAttrib4dARB_remap_index },
-   { 18928, VertexAttrib4dvARB_remap_index },
-   { 10152, VertexAttrib4fARB_remap_index },
-   { 10556, VertexAttrib4fvARB_remap_index },
-   {  9091, VertexAttrib4ivARB_remap_index },
-   { 15329, VertexAttrib4sARB_remap_index },
-   { 27687, VertexAttrib4svARB_remap_index },
-   { 14746, VertexAttrib4ubvARB_remap_index },
-   { 27134, VertexAttrib4uivARB_remap_index },
-   { 17756, VertexAttrib4usvARB_remap_index },
-   { 19645, VertexAttribPointerARB_remap_index },
-   { 29280, BindBufferARB_remap_index },
+   {  9729, VertexAttrib4bvARB_remap_index },
+   { 24415, VertexAttrib4dARB_remap_index },
+   { 19328, VertexAttrib4dvARB_remap_index },
+   { 10242, VertexAttrib4fARB_remap_index },
+   { 10646, VertexAttrib4fvARB_remap_index },
+   {  9145, VertexAttrib4ivARB_remap_index },
+   { 15649, VertexAttrib4sARB_remap_index },
+   { 28249, VertexAttrib4svARB_remap_index },
+   { 15018, VertexAttrib4ubvARB_remap_index },
+   { 27660, VertexAttrib4uivARB_remap_index },
+   { 18117, VertexAttrib4usvARB_remap_index },
+   { 20082, VertexAttribPointerARB_remap_index },
+   { 29803, BindBufferARB_remap_index },
    {  5923, BufferDataARB_remap_index },
    {  1382, BufferSubDataARB_remap_index },
-   { 27323, DeleteBuffersARB_remap_index },
-   { 29563, GenBuffersARB_remap_index },
-   { 15671, GetBufferParameterivARB_remap_index },
-   { 14893, GetBufferPointervARB_remap_index },
+   { 27849, DeleteBuffersARB_remap_index },
+   { 30086, GenBuffersARB_remap_index },
+   { 15991, GetBufferParameterivARB_remap_index },
+   { 15165, GetBufferPointervARB_remap_index },
    {  1335, GetBufferSubDataARB_remap_index },
-   { 27082, IsBufferARB_remap_index },
-   { 23523, MapBufferARB_remap_index },
-   { 27902, UnmapBufferARB_remap_index },
+   { 27608, IsBufferARB_remap_index },
+   { 23988, MapBufferARB_remap_index },
+   { 28464, UnmapBufferARB_remap_index },
    {   268, BeginQueryARB_remap_index },
-   { 17429, DeleteQueriesARB_remap_index },
-   { 10850, EndQueryARB_remap_index },
-   { 25959, GenQueriesARB_remap_index },
+   { 17790, DeleteQueriesARB_remap_index },
+   { 10940, EndQueryARB_remap_index },
+   { 26485, GenQueriesARB_remap_index },
    {  1772, GetQueryObjectivARB_remap_index },
-   { 15373, GetQueryObjectuivARB_remap_index },
+   { 15693, GetQueryObjectuivARB_remap_index },
    {  1624, GetQueryivARB_remap_index },
-   { 17663, IsQueryARB_remap_index },
+   { 18024, IsQueryARB_remap_index },
    {  7302, AttachObjectARB_remap_index },
-   { 16334, CompileShaderARB_remap_index },
+   { 16654, CompileShaderARB_remap_index },
    {  2879, CreateProgramObjectARB_remap_index },
    {  5868, CreateShaderObjectARB_remap_index },
-   { 12835, DeleteObjectARB_remap_index },
-   { 21327, DetachObjectARB_remap_index },
-   { 10628, GetActiveUniformARB_remap_index },
-   {  8410, GetAttachedObjectsARB_remap_index },
-   {  8689, GetHandleARB_remap_index },
-   { 29313, GetInfoLogARB_remap_index },
-   { 28569, GetObjectParameterfvARB_remap_index },
-   { 24384, GetObjectParameterivARB_remap_index },
-   { 25717, GetShaderSourceARB_remap_index },
-   { 24998, GetUniformLocationARB_remap_index },
-   { 21155, GetUniformfvARB_remap_index },
-   { 11211, GetUniformivARB_remap_index },
-   { 17801, LinkProgramARB_remap_index },
-   { 17859, ShaderSourceARB_remap_index },
+   { 13029, DeleteObjectARB_remap_index },
+   { 21790, DetachObjectARB_remap_index },
+   { 10718, GetActiveUniformARB_remap_index },
+   {  8464, GetAttachedObjectsARB_remap_index },
+   {  8743, GetHandleARB_remap_index },
+   { 29836, GetInfoLogARB_remap_index },
+   { 29092, GetObjectParameterfvARB_remap_index },
+   { 24881, GetObjectParameterivARB_remap_index },
+   { 26243, GetShaderSourceARB_remap_index },
+   { 25495, GetUniformLocationARB_remap_index },
+   { 21618, GetUniformfvARB_remap_index },
+   { 11386, GetUniformivARB_remap_index },
+   { 18162, LinkProgramARB_remap_index },
+   { 18220, ShaderSourceARB_remap_index },
    {  6584, Uniform1fARB_remap_index },
-   { 26498, Uniform1fvARB_remap_index },
-   { 19614, Uniform1iARB_remap_index },
-   { 18617, Uniform1ivARB_remap_index },
+   { 27024, Uniform1fvARB_remap_index },
+   { 20051, Uniform1iARB_remap_index },
+   { 19017, Uniform1ivARB_remap_index },
    {  2003, Uniform2fARB_remap_index },
-   { 12671, Uniform2fvARB_remap_index },
-   { 23410, Uniform2iARB_remap_index },
+   { 12865, Uniform2fvARB_remap_index },
+   { 23875, Uniform2iARB_remap_index },
    {  2123, Uniform2ivARB_remap_index },
-   { 16444, Uniform3fARB_remap_index },
-   {  8440, Uniform3fvARB_remap_index },
+   { 16764, Uniform3fARB_remap_index },
+   {  8494, Uniform3fvARB_remap_index },
    {  5542, Uniform3iARB_remap_index },
-   { 14999, Uniform3ivARB_remap_index },
-   { 16890, Uniform4fARB_remap_index },
-   { 21019, Uniform4fvARB_remap_index },
-   { 22202, Uniform4iARB_remap_index },
-   { 18169, Uniform4ivARB_remap_index },
+   { 15271, Uniform3ivARB_remap_index },
+   { 17251, Uniform4fARB_remap_index },
+   { 21482, Uniform4fvARB_remap_index },
+   { 22665, Uniform4iARB_remap_index },
+   { 18530, Uniform4ivARB_remap_index },
    {  7354, UniformMatrix2fvARB_remap_index },
    {    17, UniformMatrix3fvARB_remap_index },
    {  2475, UniformMatrix4fvARB_remap_index },
-   { 22635, UseProgramObjectARB_remap_index },
-   { 13106, ValidateProgramARB_remap_index },
-   { 18971, BindAttribLocationARB_remap_index },
+   { 23098, UseProgramObjectARB_remap_index },
+   { 13300, ValidateProgramARB_remap_index },
+   { 19371, BindAttribLocationARB_remap_index },
    {  4346, GetActiveAttribARB_remap_index },
-   { 14680, GetAttribLocationARB_remap_index },
-   { 26237, DrawBuffersARB_remap_index },
-   { 11694, RenderbufferStorageMultisample_remap_index },
-   { 16938, FlushMappedBufferRange_remap_index },
-   { 24801, MapBufferRange_remap_index },
-   { 14555, BindVertexArray_remap_index },
-   { 12965, GenVertexArrays_remap_index },
-   { 27012, CopyBufferSubData_remap_index },
-   { 27791, ClientWaitSync_remap_index },
+   { 14952, GetAttribLocationARB_remap_index },
+   { 26763, DrawBuffersARB_remap_index },
+   { 11869, RenderbufferStorageMultisample_remap_index },
+   { 17299, FlushMappedBufferRange_remap_index },
+   { 25298, MapBufferRange_remap_index },
+   { 14827, BindVertexArray_remap_index },
+   { 13159, GenVertexArrays_remap_index },
+   { 27538, CopyBufferSubData_remap_index },
+   { 28353, ClientWaitSync_remap_index },
    {  2394, DeleteSync_remap_index },
    {  6251, FenceSync_remap_index },
-   { 13477, GetInteger64v_remap_index },
-   { 20070, GetSynciv_remap_index },
-   { 26176, IsSync_remap_index },
-   {  8358, WaitSync_remap_index },
+   { 13671, GetInteger64v_remap_index },
+   { 20533, GetSynciv_remap_index },
+   { 26702, IsSync_remap_index },
+   {  8412, WaitSync_remap_index },
    {  3363, DrawElementsBaseVertex_remap_index },
-   { 27255, DrawRangeElementsBaseVertex_remap_index },
-   { 23554, MultiDrawElementsBaseVertex_remap_index },
+   { 27781, DrawRangeElementsBaseVertex_remap_index },
+   { 24019, MultiDrawElementsBaseVertex_remap_index },
    {  4711, PolygonOffsetEXT_remap_index },
-   { 20655, GetPixelTexGenParameterfvSGIS_remap_index },
+   { 21118, GetPixelTexGenParameterfvSGIS_remap_index },
    {  3895, GetPixelTexGenParameterivSGIS_remap_index },
-   { 20388, PixelTexGenParameterfSGIS_remap_index },
+   { 20851, PixelTexGenParameterfSGIS_remap_index },
    {   580, PixelTexGenParameterfvSGIS_remap_index },
-   { 11249, PixelTexGenParameteriSGIS_remap_index },
-   { 12242, PixelTexGenParameterivSGIS_remap_index },
-   { 14643, SampleMaskSGIS_remap_index },
-   { 17603, SamplePatternSGIS_remap_index },
-   { 23483, ColorPointerEXT_remap_index },
-   { 15558, EdgeFlagPointerEXT_remap_index },
+   { 11424, PixelTexGenParameteriSGIS_remap_index },
+   { 12385, PixelTexGenParameterivSGIS_remap_index },
+   { 14915, SampleMaskSGIS_remap_index },
+   { 17964, SamplePatternSGIS_remap_index },
+   { 23948, ColorPointerEXT_remap_index },
+   { 15878, EdgeFlagPointerEXT_remap_index },
    {  5196, IndexPointerEXT_remap_index },
    {  5276, NormalPointerEXT_remap_index },
-   { 14071, TexCoordPointerEXT_remap_index },
+   { 14265, TexCoordPointerEXT_remap_index },
    {  6046, VertexPointerEXT_remap_index },
    {  3165, PointParameterfEXT_remap_index },
    {  6891, PointParameterfvEXT_remap_index },
-   { 28667, LockArraysEXT_remap_index },
-   { 13170, UnlockArraysEXT_remap_index },
+   { 29190, LockArraysEXT_remap_index },
+   { 13364, UnlockArraysEXT_remap_index },
    {  7898, CullParameterdvEXT_remap_index },
-   { 10423, CullParameterfvEXT_remap_index },
+   { 10513, CullParameterfvEXT_remap_index },
    {  1151, SecondaryColor3bEXT_remap_index },
    {  7050, SecondaryColor3bvEXT_remap_index },
-   {  9268, SecondaryColor3dEXT_remap_index },
-   { 22808, SecondaryColor3dvEXT_remap_index },
-   { 25047, SecondaryColor3fEXT_remap_index },
-   { 16124, SecondaryColor3fvEXT_remap_index },
+   {  9322, SecondaryColor3dEXT_remap_index },
+   { 23271, SecondaryColor3dvEXT_remap_index },
+   { 25544, SecondaryColor3fEXT_remap_index },
+   { 16444, SecondaryColor3fvEXT_remap_index },
    {   426, SecondaryColor3iEXT_remap_index },
-   { 14381, SecondaryColor3ivEXT_remap_index },
-   {  8926, SecondaryColor3sEXT_remap_index },
-   { 27455, SecondaryColor3svEXT_remap_index },
-   { 24220, SecondaryColor3ubEXT_remap_index },
-   { 18862, SecondaryColor3ubvEXT_remap_index },
-   { 11444, SecondaryColor3uiEXT_remap_index },
-   { 20275, SecondaryColor3uivEXT_remap_index },
-   { 23020, SecondaryColor3usEXT_remap_index },
-   { 11517, SecondaryColor3usvEXT_remap_index },
-   { 10499, SecondaryColorPointerEXT_remap_index },
-   { 22869, MultiDrawArraysEXT_remap_index },
-   { 18552, MultiDrawElementsEXT_remap_index },
-   { 18747, FogCoordPointerEXT_remap_index },
+   { 14653, SecondaryColor3ivEXT_remap_index },
+   {  8980, SecondaryColor3sEXT_remap_index },
+   { 28017, SecondaryColor3svEXT_remap_index },
+   { 24717, SecondaryColor3ubEXT_remap_index },
+   { 19262, SecondaryColor3ubvEXT_remap_index },
+   { 11619, SecondaryColor3uiEXT_remap_index },
+   { 20738, SecondaryColor3uivEXT_remap_index },
+   { 23483, SecondaryColor3usEXT_remap_index },
+   { 11692, SecondaryColor3usvEXT_remap_index },
+   { 10589, SecondaryColorPointerEXT_remap_index },
+   { 23332, MultiDrawArraysEXT_remap_index },
+   { 18952, MultiDrawElementsEXT_remap_index },
+   { 19147, FogCoordPointerEXT_remap_index },
    {  4044, FogCoorddEXT_remap_index },
-   { 28068, FogCoorddvEXT_remap_index },
+   { 28591, FogCoorddvEXT_remap_index },
    {  4136, FogCoordfEXT_remap_index },
-   { 24143, FogCoordfvEXT_remap_index },
-   { 16842, PixelTexGenSGIX_remap_index },
-   { 24728, BlendFuncSeparateEXT_remap_index },
+   { 24640, FogCoordfvEXT_remap_index },
+   { 17203, PixelTexGenSGIX_remap_index },
+   { 25225, BlendFuncSeparateEXT_remap_index },
    {  5958, FlushVertexArrayRangeNV_remap_index },
    {  4660, VertexArrayRangeNV_remap_index },
-   { 25112, CombinerInputNV_remap_index },
+   { 25609, CombinerInputNV_remap_index },
    {  1946, CombinerOutputNV_remap_index },
-   { 27608, CombinerParameterfNV_remap_index },
+   { 28170, CombinerParameterfNV_remap_index },
    {  4580, CombinerParameterfvNV_remap_index },
-   { 19820, CombinerParameteriNV_remap_index },
-   { 29038, CombinerParameterivNV_remap_index },
+   { 20257, CombinerParameteriNV_remap_index },
+   { 29561, CombinerParameterivNV_remap_index },
    {  6328, FinalCombinerInputNV_remap_index },
-   {  8755, GetCombinerInputParameterfvNV_remap_index },
-   { 28875, GetCombinerInputParameterivNV_remap_index },
+   {  8809, GetCombinerInputParameterfvNV_remap_index },
+   { 29398, GetCombinerInputParameterivNV_remap_index },
    {  6127, GetCombinerOutputParameterfvNV_remap_index },
-   { 12171, GetCombinerOutputParameterivNV_remap_index },
+   { 12346, GetCombinerOutputParameterivNV_remap_index },
    {  5703, GetFinalCombinerInputParameterfvNV_remap_index },
-   { 22074, GetFinalCombinerInputParameterivNV_remap_index },
-   { 11189, ResizeBuffersMESA_remap_index },
-   {  9872, WindowPos2dMESA_remap_index },
+   { 22537, GetFinalCombinerInputParameterivNV_remap_index },
+   { 11364, ResizeBuffersMESA_remap_index },
+   {  9962, WindowPos2dMESA_remap_index },
    {   944, WindowPos2dvMESA_remap_index },
-   { 29866, WindowPos2fMESA_remap_index },
+   { 30389, WindowPos2fMESA_remap_index },
    {  6995, WindowPos2fvMESA_remap_index },
-   { 16071, WindowPos2iMESA_remap_index },
-   { 18076, WindowPos2ivMESA_remap_index },
-   { 18651, WindowPos2sMESA_remap_index },
+   { 16391, WindowPos2iMESA_remap_index },
+   { 18437, WindowPos2ivMESA_remap_index },
+   { 19051, WindowPos2sMESA_remap_index },
    {  4946, WindowPos2svMESA_remap_index },
    {  6820, WindowPos3dMESA_remap_index },
-   { 12450, WindowPos3dvMESA_remap_index },
+   { 12593, WindowPos3dvMESA_remap_index },
    {   472, WindowPos3fMESA_remap_index },
-   { 13231, WindowPos3fvMESA_remap_index },
-   { 21369, WindowPos3iMESA_remap_index },
-   { 26957, WindowPos3ivMESA_remap_index },
-   { 16588, WindowPos3sMESA_remap_index },
-   { 28324, WindowPos3svMESA_remap_index },
-   {  9823, WindowPos4dMESA_remap_index },
-   { 15084, WindowPos4dvMESA_remap_index },
-   { 12409, WindowPos4fMESA_remap_index },
-   { 27362, WindowPos4fvMESA_remap_index },
-   { 27110, WindowPos4iMESA_remap_index },
-   { 11028, WindowPos4ivMESA_remap_index },
-   { 16721, WindowPos4sMESA_remap_index },
+   { 13425, WindowPos3fvMESA_remap_index },
+   { 21832, WindowPos3iMESA_remap_index },
+   { 27483, WindowPos3ivMESA_remap_index },
+   { 16909, WindowPos3sMESA_remap_index },
+   { 28847, WindowPos3svMESA_remap_index },
+   {  9913, WindowPos4dMESA_remap_index },
+   { 15356, WindowPos4dvMESA_remap_index },
+   { 12552, WindowPos4fMESA_remap_index },
+   { 27924, WindowPos4fvMESA_remap_index },
+   { 27636, WindowPos4iMESA_remap_index },
+   { 11203, WindowPos4ivMESA_remap_index },
+   { 17082, WindowPos4sMESA_remap_index },
    {  2857, WindowPos4svMESA_remap_index },
-   { 12210, MultiModeDrawArraysIBM_remap_index },
-   { 25830, MultiModeDrawElementsIBM_remap_index },
-   { 10878, DeleteFencesNV_remap_index },
-   { 24959, FinishFenceNV_remap_index },
+   { 24383, MultiModeDrawArraysIBM_remap_index },
+   { 26356, MultiModeDrawElementsIBM_remap_index },
+   { 10968, DeleteFencesNV_remap_index },
+   { 25456, FinishFenceNV_remap_index },
    {  3287, GenFencesNV_remap_index },
-   { 15064, GetFenceivNV_remap_index },
+   { 15336, GetFenceivNV_remap_index },
    {  7287, IsFenceNV_remap_index },
-   { 12098, SetFenceNV_remap_index },
+   { 12273, SetFenceNV_remap_index },
    {  3744, TestFenceNV_remap_index },
-   { 28295, AreProgramsResidentNV_remap_index },
-   { 27650, BindProgramNV_remap_index },
-   { 23103, DeleteProgramsNV_remap_index },
-   { 19080, ExecuteProgramNV_remap_index },
-   { 29759, GenProgramsNV_remap_index },
-   { 20734, GetProgramParameterdvNV_remap_index },
-   {  9330, GetProgramParameterfvNV_remap_index },
-   { 23457, GetProgramStringNV_remap_index },
-   { 21763, GetProgramivNV_remap_index },
-   { 20968, GetTrackMatrixivNV_remap_index },
-   { 23253, GetVertexAttribPointervNV_remap_index },
-   { 22007, GetVertexAttribdvNV_remap_index },
-   { 16561, GetVertexAttribfvNV_remap_index },
-   { 16252, GetVertexAttribivNV_remap_index },
-   { 16968, IsProgramNV_remap_index },
-   {  8336, LoadProgramNV_remap_index },
-   { 24824, ProgramParameters4dvNV_remap_index },
-   { 21693, ProgramParameters4fvNV_remap_index },
-   { 18380, RequestResidentProgramsNV_remap_index },
-   { 19798, TrackMatrixNV_remap_index },
-   { 28852, VertexAttrib1dNV_remap_index },
-   { 12039, VertexAttrib1dvNV_remap_index },
-   { 25362, VertexAttrib1fNV_remap_index },
+   { 28818, AreProgramsResidentNV_remap_index },
+   { 28212, BindProgramNV_remap_index },
+   { 23566, DeleteProgramsNV_remap_index },
+   { 19480, ExecuteProgramNV_remap_index },
+   { 30282, GenProgramsNV_remap_index },
+   { 21197, GetProgramParameterdvNV_remap_index },
+   {  9384, GetProgramParameterfvNV_remap_index },
+   { 23922, GetProgramStringNV_remap_index },
+   { 22226, GetProgramivNV_remap_index },
+   { 21431, GetTrackMatrixivNV_remap_index },
+   { 23716, GetVertexAttribPointervNV_remap_index },
+   { 22470, GetVertexAttribdvNV_remap_index },
+   {  8307, GetVertexAttribfvNV_remap_index },
+   { 16572, GetVertexAttribivNV_remap_index },
+   { 17329, IsProgramNV_remap_index },
+   {  8390, LoadProgramNV_remap_index },
+   { 25321, ProgramParameters4dvNV_remap_index },
+   { 22156, ProgramParameters4fvNV_remap_index },
+   { 18741, RequestResidentProgramsNV_remap_index },
+   { 20235, TrackMatrixNV_remap_index },
+   { 29375, VertexAttrib1dNV_remap_index },
+   { 12214, VertexAttrib1dvNV_remap_index },
+   { 25888, VertexAttrib1fNV_remap_index },
    {  2245, VertexAttrib1fvNV_remap_index },
-   { 27419, VertexAttrib1sNV_remap_index },
-   { 13304, VertexAttrib1svNV_remap_index },
+   { 27981, VertexAttrib1sNV_remap_index },
+   { 13498, VertexAttrib1svNV_remap_index },
    {  4251, VertexAttrib2dNV_remap_index },
-   { 11954, VertexAttrib2dvNV_remap_index },
-   { 17835, VertexAttrib2fNV_remap_index },
-   { 11565, VertexAttrib2fvNV_remap_index },
+   { 12129, VertexAttrib2dvNV_remap_index },
+   { 18196, VertexAttrib2fNV_remap_index },
+   { 11740, VertexAttrib2fvNV_remap_index },
    {  5106, VertexAttrib2sNV_remap_index },
-   { 16642, VertexAttrib2svNV_remap_index },
-   { 10020, VertexAttrib3dNV_remap_index },
-   { 28545, VertexAttrib3dvNV_remap_index },
-   {  9142, VertexAttrib3fNV_remap_index },
-   { 22034, VertexAttrib3fvNV_remap_index },
-   { 25337, VertexAttrib3sNV_remap_index },
-   { 20995, VertexAttrib3svNV_remap_index },
-   { 25804, VertexAttrib4dNV_remap_index },
-   { 29796, VertexAttrib4dvNV_remap_index },
+   { 16963, VertexAttrib2svNV_remap_index },
+   { 10110, VertexAttrib3dNV_remap_index },
+   { 29068, VertexAttrib3dvNV_remap_index },
+   {  9196, VertexAttrib3fNV_remap_index },
+   { 22497, VertexAttrib3fvNV_remap_index },
+   { 25863, VertexAttrib3sNV_remap_index },
+   { 21458, VertexAttrib3svNV_remap_index },
+   { 26330, VertexAttrib4dNV_remap_index },
+   { 30319, VertexAttrib4dvNV_remap_index },
    {  3945, VertexAttrib4fNV_remap_index },
-   {  8386, VertexAttrib4fvNV_remap_index },
-   { 23802, VertexAttrib4sNV_remap_index },
+   {  8440, VertexAttrib4fvNV_remap_index },
+   { 24267, VertexAttrib4sNV_remap_index },
    {  1293, VertexAttrib4svNV_remap_index },
    {  4409, VertexAttrib4ubNV_remap_index },
    {   734, VertexAttrib4ubvNV_remap_index },
-   { 19260, VertexAttribPointerNV_remap_index },
+   { 19660, VertexAttribPointerNV_remap_index },
    {  2097, VertexAttribs1dvNV_remap_index },
-   { 16666, VertexAttribs1fvNV_remap_index },
-   { 29596, VertexAttribs1svNV_remap_index },
-   {  9167, VertexAttribs2dvNV_remap_index },
-   { 22596, VertexAttribs2fvNV_remap_index },
-   { 15584, VertexAttribs2svNV_remap_index },
+   { 23804, VertexAttribs1fvNV_remap_index },
+   { 30119, VertexAttribs1svNV_remap_index },
+   {  9221, VertexAttribs2dvNV_remap_index },
+   { 23059, VertexAttribs2fvNV_remap_index },
+   { 15904, VertexAttribs2svNV_remap_index },
    {  4608, VertexAttribs3dvNV_remap_index },
    {  1977, VertexAttribs3fvNV_remap_index },
-   { 26705, VertexAttribs3svNV_remap_index },
-   { 23892, VertexAttribs4dvNV_remap_index },
+   { 27231, VertexAttribs3svNV_remap_index },
+   { 24357, VertexAttribs4dvNV_remap_index },
    {  4634, VertexAttribs4fvNV_remap_index },
-   { 29383, VertexAttribs4svNV_remap_index },
-   { 26453, VertexAttribs4ubvNV_remap_index },
-   { 23962, GetTexBumpParameterfvATI_remap_index },
-   { 29637, GetTexBumpParameterivATI_remap_index },
-   { 16306, TexBumpParameterfvATI_remap_index },
-   { 18251, TexBumpParameterivATI_remap_index },
-   { 13850, AlphaFragmentOp1ATI_remap_index },
-   {  9682, AlphaFragmentOp2ATI_remap_index },
-   { 21950, AlphaFragmentOp3ATI_remap_index },
-   { 26632, BeginFragmentShaderATI_remap_index },
-   { 27849, BindFragmentShaderATI_remap_index },
-   { 21124, ColorFragmentOp1ATI_remap_index },
+   { 29906, VertexAttribs4svNV_remap_index },
+   { 26979, VertexAttribs4ubvNV_remap_index },
+   { 24459, GetTexBumpParameterfvATI_remap_index },
+   { 30160, GetTexBumpParameterivATI_remap_index },
+   { 16626, TexBumpParameterfvATI_remap_index },
+   { 18612, TexBumpParameterivATI_remap_index },
+   { 14044, AlphaFragmentOp1ATI_remap_index },
+   {  9772, AlphaFragmentOp2ATI_remap_index },
+   { 22413, AlphaFragmentOp3ATI_remap_index },
+   { 27158, BeginFragmentShaderATI_remap_index },
+   { 28411, BindFragmentShaderATI_remap_index },
+   { 21587, ColorFragmentOp1ATI_remap_index },
    {  3823, ColorFragmentOp2ATI_remap_index },
-   { 28190, ColorFragmentOp3ATI_remap_index },
+   { 28713, ColorFragmentOp3ATI_remap_index },
    {  4753, DeleteFragmentShaderATI_remap_index },
-   { 29820, EndFragmentShaderATI_remap_index },
-   { 29066, GenFragmentShadersATI_remap_index },
-   { 22727, PassTexCoordATI_remap_index },
+   { 30343, EndFragmentShaderATI_remap_index },
+   { 29589, GenFragmentShadersATI_remap_index },
+   { 23190, PassTexCoordATI_remap_index },
    {  6026, SampleMapATI_remap_index },
    {  5799, SetFragmentShaderConstantATI_remap_index },
    {   319, PointParameteriNV_remap_index },
-   { 12611, PointParameterivNV_remap_index },
-   { 25643, ActiveStencilFaceEXT_remap_index },
-   { 24484, BindVertexArrayAPPLE_remap_index },
+   { 12754, PointParameterivNV_remap_index },
+   { 26169, ActiveStencilFaceEXT_remap_index },
+   { 24981, BindVertexArrayAPPLE_remap_index },
    {  2522, DeleteVertexArraysAPPLE_remap_index },
-   { 15923, GenVertexArraysAPPLE_remap_index },
-   { 20799, IsVertexArrayAPPLE_remap_index },
+   { 16243, GenVertexArraysAPPLE_remap_index },
+   { 21262, IsVertexArrayAPPLE_remap_index },
    {   775, GetProgramNamedParameterdvNV_remap_index },
    {  3128, GetProgramNamedParameterfvNV_remap_index },
-   { 23993, ProgramNamedParameter4dNV_remap_index },
-   { 12886, ProgramNamedParameter4dvNV_remap_index },
+   { 24490, ProgramNamedParameter4dNV_remap_index },
+   { 13080, ProgramNamedParameter4dvNV_remap_index },
    {  7923, ProgramNamedParameter4fNV_remap_index },
-   { 10464, ProgramNamedParameter4fvNV_remap_index },
-   { 21672, DepthBoundsEXT_remap_index },
+   { 10554, ProgramNamedParameter4fvNV_remap_index },
+   { 22135, DepthBoundsEXT_remap_index },
    {  1043, BlendEquationSeparateEXT_remap_index },
-   { 13005, BindFramebufferEXT_remap_index },
-   { 22914, BindRenderbufferEXT_remap_index },
-   {  8605, CheckFramebufferStatusEXT_remap_index },
-   { 20089, DeleteFramebuffersEXT_remap_index },
-   { 28447, DeleteRenderbuffersEXT_remap_index },
-   { 11978, FramebufferRenderbufferEXT_remap_index },
-   { 12115, FramebufferTexture1DEXT_remap_index },
-   { 10258, FramebufferTexture2DEXT_remap_index },
-   {  9925, FramebufferTexture3DEXT_remap_index },
-   { 20691, GenFramebuffersEXT_remap_index },
-   { 15470, GenRenderbuffersEXT_remap_index },
+   { 13199, BindFramebufferEXT_remap_index },
+   { 23377, BindRenderbufferEXT_remap_index },
+   {  8659, CheckFramebufferStatusEXT_remap_index },
+   { 20552, DeleteFramebuffersEXT_remap_index },
+   { 28970, DeleteRenderbuffersEXT_remap_index },
+   { 12153, FramebufferRenderbufferEXT_remap_index },
+   { 12290, FramebufferTexture1DEXT_remap_index },
+   { 10348, FramebufferTexture2DEXT_remap_index },
+   { 10015, FramebufferTexture3DEXT_remap_index },
+   { 21154, GenFramebuffersEXT_remap_index },
+   { 15790, GenRenderbuffersEXT_remap_index },
    {  5745, GenerateMipmapEXT_remap_index },
-   { 19320, GetFramebufferAttachmentParameterivEXT_remap_index },
-   { 28972, GetRenderbufferParameterivEXT_remap_index },
-   { 18131, IsFramebufferEXT_remap_index },
-   { 29719, IsRenderbufferEXT_remap_index },
+   { 19757, GetFramebufferAttachmentParameterivEXT_remap_index },
+   { 29495, GetRenderbufferParameterivEXT_remap_index },
+   { 18492, IsFramebufferEXT_remap_index },
+   { 30242, IsRenderbufferEXT_remap_index },
    {  7234, RenderbufferStorageEXT_remap_index },
    {   651, BlitFramebufferEXT_remap_index },
-   { 12705, BufferParameteriAPPLE_remap_index },
-   { 17000, FlushMappedBufferRangeAPPLE_remap_index },
+   { 12899, BufferParameteriAPPLE_remap_index },
+   { 17361, FlushMappedBufferRangeAPPLE_remap_index },
    {  2701, FramebufferTextureLayerEXT_remap_index },
-   {  8307, ColorMaskIndexedEXT_remap_index },
-   { 23341, DisableIndexedEXT_remap_index },
-   { 23649, EnableIndexedEXT_remap_index },
-   { 19291, GetBooleanIndexedvEXT_remap_index },
-   {  9715, GetIntegerIndexedvEXT_remap_index },
-   { 20165, IsEnabledIndexedEXT_remap_index },
+   { 25678, ColorMaskIndexedEXT_remap_index },
+   { 16987, DisableIndexedEXT_remap_index },
+   { 24114, EnableIndexedEXT_remap_index },
+   { 19728, GetBooleanIndexedvEXT_remap_index },
+   {  9805, GetIntegerIndexedvEXT_remap_index },
+   { 20628, IsEnabledIndexedEXT_remap_index },
    {  4074, BeginConditionalRenderNV_remap_index },
-   { 22700, EndConditionalRenderNV_remap_index },
-   { 26354, ProvokingVertexEXT_remap_index },
-   {  9551, GetTexParameterPointervAPPLE_remap_index },
+   { 23163, EndConditionalRenderNV_remap_index },
+   {  8334, BeginTransformFeedbackEXT_remap_index },
+   { 17011, BindBufferBaseEXT_remap_index },
+   { 16881, BindBufferOffsetEXT_remap_index },
+   { 11028, BindBufferRangeEXT_remap_index },
+   { 12814, EndTransformFeedbackEXT_remap_index },
+   {  9657, GetTransformFeedbackVaryingEXT_remap_index },
+   { 18797, TransformFeedbackVaryingsEXT_remap_index },
+   { 26880, ProvokingVertexEXT_remap_index },
+   {  9605, GetTexParameterPointervAPPLE_remap_index },
    {  4436, TextureRangeAPPLE_remap_index },
-   { 10330, GetObjectParameterivAPPLE_remap_index },
-   { 17575, ObjectPurgeableAPPLE_remap_index },
+   { 10420, GetObjectParameterivAPPLE_remap_index },
+   { 17936, ObjectPurgeableAPPLE_remap_index },
    {  4900, ObjectUnpurgeableAPPLE_remap_index },
-   { 25669, StencilFuncSeparateATI_remap_index },
-   { 15990, ProgramEnvParameters4fvEXT_remap_index },
-   { 15208, ProgramLocalParameters4fvEXT_remap_index },
-   { 12539, GetQueryObjecti64vEXT_remap_index },
-   {  9193, GetQueryObjectui64vEXT_remap_index },
-   { 21193, EGLImageTargetRenderbufferStorageOES_remap_index },
-   { 10817, EGLImageTargetTexture2DOES_remap_index },
+   { 26195, StencilFuncSeparateATI_remap_index },
+   { 16310, ProgramEnvParameters4fvEXT_remap_index },
+   { 19691, ProgramLocalParameters4fvEXT_remap_index },
+   { 12682, GetQueryObjecti64vEXT_remap_index },
+   {  9247, GetQueryObjectui64vEXT_remap_index },
+   { 21656, EGLImageTargetRenderbufferStorageOES_remap_index },
+   { 10907, EGLImageTargetTexture2DOES_remap_index },
    {    -1, -1 }
 };
 
@@ -4793,10 +4848,10 @@ static const struct gl_function_remap MESA_alt_functions[] = {
    /* from GL_EXT_blend_color */
    {  2440, _gloffset_BlendColor },
    /* from GL_EXT_blend_minmax */
-   {  9982, _gloffset_BlendEquation },
+   { 10072, _gloffset_BlendEquation },
    /* from GL_EXT_color_subtable */
-   { 15106, _gloffset_ColorSubTable },
-   { 28379, _gloffset_CopyColorSubTable },
+   { 15378, _gloffset_ColorSubTable },
+   { 28902, _gloffset_CopyColorSubTable },
    /* from GL_EXT_convolution */
    {   213, _gloffset_ConvolutionFilter1D },
    {  2284, _gloffset_CopyConvolutionFilter1D },
@@ -4804,62 +4859,62 @@ static const struct gl_function_remap MESA_alt_functions[] = {
    {  7583, _gloffset_ConvolutionFilter2D },
    {  7749, _gloffset_ConvolutionParameteriv },
    {  8209, _gloffset_ConvolutionParameterfv },
-   { 18279, _gloffset_GetSeparableFilter },
-   { 21423, _gloffset_SeparableFilter2D },
-   { 22252, _gloffset_ConvolutionParameteri },
-   { 22375, _gloffset_ConvolutionParameterf },
-   { 23828, _gloffset_GetConvolutionParameterfv },
-   { 24650, _gloffset_GetConvolutionFilter },
-   { 26894, _gloffset_CopyConvolutionFilter2D },
+   { 18640, _gloffset_GetSeparableFilter },
+   { 21886, _gloffset_SeparableFilter2D },
+   { 22715, _gloffset_ConvolutionParameteri },
+   { 22838, _gloffset_ConvolutionParameterf },
+   { 24293, _gloffset_GetConvolutionParameterfv },
+   { 25147, _gloffset_GetConvolutionFilter },
+   { 27420, _gloffset_CopyConvolutionFilter2D },
    /* from GL_EXT_copy_texture */
-   { 13364, _gloffset_CopyTexSubImage3D },
-   { 14846, _gloffset_CopyTexImage2D },
-   { 21860, _gloffset_CopyTexImage1D },
-   { 24331, _gloffset_CopyTexSubImage2D },
-   { 26532, _gloffset_CopyTexSubImage1D },
+   { 13558, _gloffset_CopyTexSubImage3D },
+   { 15118, _gloffset_CopyTexImage2D },
+   { 22323, _gloffset_CopyTexImage1D },
+   { 24828, _gloffset_CopyTexSubImage2D },
+   { 27058, _gloffset_CopyTexSubImage1D },
    /* from GL_EXT_draw_range_elements */
-   {  8492, _gloffset_DrawRangeElements },
+   {  8546, _gloffset_DrawRangeElements },
    /* from GL_EXT_histogram */
    {   812, _gloffset_Histogram },
    {  3088, _gloffset_ResetHistogram },
-   {  8864, _gloffset_GetMinmax },
-   { 13698, _gloffset_GetHistogramParameterfv },
-   { 21785, _gloffset_GetMinmaxParameteriv },
-   { 23718, _gloffset_ResetMinmax },
-   { 24547, _gloffset_GetHistogramParameteriv },
-   { 25603, _gloffset_GetHistogram },
-   { 27965, _gloffset_Minmax },
-   { 29466, _gloffset_GetMinmaxParameterfv },
+   {  8918, _gloffset_GetMinmax },
+   { 13892, _gloffset_GetHistogramParameterfv },
+   { 22248, _gloffset_GetMinmaxParameteriv },
+   { 24183, _gloffset_ResetMinmax },
+   { 25044, _gloffset_GetHistogramParameteriv },
+   { 26129, _gloffset_GetHistogram },
+   { 28527, _gloffset_Minmax },
+   { 29989, _gloffset_GetMinmaxParameterfv },
    /* from GL_EXT_paletted_texture */
    {  7445, _gloffset_ColorTable },
-   { 13544, _gloffset_GetColorTable },
-   { 20438, _gloffset_GetColorTableParameterfv },
-   { 22431, _gloffset_GetColorTableParameteriv },
+   { 13738, _gloffset_GetColorTable },
+   { 20901, _gloffset_GetColorTableParameterfv },
+   { 22894, _gloffset_GetColorTableParameteriv },
    /* from GL_EXT_subtexture */
    {  6166, _gloffset_TexSubImage1D },
-   {  9478, _gloffset_TexSubImage2D },
+   {  9532, _gloffset_TexSubImage2D },
    /* from GL_EXT_texture3D */
    {  1658, _gloffset_TexImage3D },
-   { 20207, _gloffset_TexSubImage3D },
+   { 20670, _gloffset_TexSubImage3D },
    /* from GL_EXT_texture_object */
    {  2964, _gloffset_PrioritizeTextures },
    {  6615, _gloffset_AreTexturesResident },
-   { 12063, _gloffset_GenTextures },
-   { 14030, _gloffset_DeleteTextures },
-   { 17281, _gloffset_IsTexture },
-   { 26597, _gloffset_BindTexture },
+   { 12238, _gloffset_GenTextures },
+   { 14224, _gloffset_DeleteTextures },
+   { 17642, _gloffset_IsTexture },
+   { 27123, _gloffset_BindTexture },
    /* from GL_EXT_vertex_array */
-   { 21612, _gloffset_ArrayElement },
-   { 27553, _gloffset_GetPointerv },
-   { 29093, _gloffset_DrawArrays },
+   { 22075, _gloffset_ArrayElement },
+   { 28115, _gloffset_GetPointerv },
+   { 29616, _gloffset_DrawArrays },
    /* from GL_SGI_color_table */
    {  6733, _gloffset_ColorTableParameteriv },
    {  7445, _gloffset_ColorTable },
-   { 13544, _gloffset_GetColorTable },
-   { 13654, _gloffset_CopyColorTable },
-   { 17142, _gloffset_ColorTableParameterfv },
-   { 20438, _gloffset_GetColorTableParameterfv },
-   { 22431, _gloffset_GetColorTableParameteriv },
+   { 13738, _gloffset_GetColorTable },
+   { 13848, _gloffset_CopyColorTable },
+   { 17503, _gloffset_ColorTableParameterfv },
+   { 20901, _gloffset_GetColorTableParameterfv },
+   { 22894, _gloffset_GetColorTableParameteriv },
    /* from GL_VERSION_1_3 */
    {   381, _gloffset_MultiTexCoord3sARB },
    {   613, _gloffset_ActiveTextureARB },
@@ -4868,33 +4923,33 @@ static const struct gl_function_remap MESA_alt_functions[] = {
    {  5346, _gloffset_MultiTexCoord2iARB },
    {  5470, _gloffset_MultiTexCoord2svARB },
    {  7401, _gloffset_MultiTexCoord2fARB },
-   {  9223, _gloffset_MultiTexCoord3fvARB },
-   {  9744, _gloffset_MultiTexCoord4sARB },
-   { 10378, _gloffset_MultiTexCoord2dvARB },
-   { 10760, _gloffset_MultiTexCoord1svARB },
-   { 11050, _gloffset_MultiTexCoord3svARB },
-   { 11111, _gloffset_MultiTexCoord4iARB },
-   { 11834, _gloffset_MultiTexCoord3iARB },
-   { 12568, _gloffset_MultiTexCoord1dARB },
-   { 12734, _gloffset_MultiTexCoord3dvARB },
-   { 13898, _gloffset_MultiTexCoord3ivARB },
-   { 13943, _gloffset_MultiTexCoord2sARB },
-   { 15163, _gloffset_MultiTexCoord4ivARB },
-   { 16792, _gloffset_ClientActiveTextureARB },
-   { 19036, _gloffset_MultiTexCoord2dARB },
-   { 19440, _gloffset_MultiTexCoord4dvARB },
-   { 19726, _gloffset_MultiTexCoord4fvARB },
-   { 20579, _gloffset_MultiTexCoord3fARB },
-   { 22959, _gloffset_MultiTexCoord4dARB },
-   { 23163, _gloffset_MultiTexCoord1sARB },
-   { 23365, _gloffset_MultiTexCoord1dvARB },
-   { 24175, _gloffset_MultiTexCoord1ivARB },
-   { 24268, _gloffset_MultiTexCoord2ivARB },
-   { 24607, _gloffset_MultiTexCoord1iARB },
-   { 25878, _gloffset_MultiTexCoord4svARB },
-   { 26396, _gloffset_MultiTexCoord1fARB },
-   { 26659, _gloffset_MultiTexCoord4fARB },
-   { 28927, _gloffset_MultiTexCoord2fvARB },
+   {  9277, _gloffset_MultiTexCoord3fvARB },
+   {  9834, _gloffset_MultiTexCoord4sARB },
+   { 10468, _gloffset_MultiTexCoord2dvARB },
+   { 10850, _gloffset_MultiTexCoord1svARB },
+   { 11225, _gloffset_MultiTexCoord3svARB },
+   { 11286, _gloffset_MultiTexCoord4iARB },
+   { 12009, _gloffset_MultiTexCoord3iARB },
+   { 12711, _gloffset_MultiTexCoord1dARB },
+   { 12928, _gloffset_MultiTexCoord3dvARB },
+   { 14092, _gloffset_MultiTexCoord3ivARB },
+   { 14137, _gloffset_MultiTexCoord2sARB },
+   { 15435, _gloffset_MultiTexCoord4ivARB },
+   { 17153, _gloffset_ClientActiveTextureARB },
+   { 19436, _gloffset_MultiTexCoord2dARB },
+   { 19877, _gloffset_MultiTexCoord4dvARB },
+   { 20163, _gloffset_MultiTexCoord4fvARB },
+   { 21042, _gloffset_MultiTexCoord3fARB },
+   { 23422, _gloffset_MultiTexCoord4dARB },
+   { 23626, _gloffset_MultiTexCoord1sARB },
+   { 23830, _gloffset_MultiTexCoord1dvARB },
+   { 24672, _gloffset_MultiTexCoord1ivARB },
+   { 24765, _gloffset_MultiTexCoord2ivARB },
+   { 25104, _gloffset_MultiTexCoord1iARB },
+   { 26404, _gloffset_MultiTexCoord4svARB },
+   { 26922, _gloffset_MultiTexCoord1fARB },
+   { 27185, _gloffset_MultiTexCoord4fARB },
+   { 29450, _gloffset_MultiTexCoord2fvARB },
    {    -1, -1 }
 };
 
@@ -4956,6 +5011,13 @@ static const struct gl_function_remap GL_ARB_draw_elements_base_vertex_functions
 };
 #endif
 
+#if defined(need_GL_ARB_draw_instanced)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_draw_instanced_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
 #if defined(need_GL_ARB_framebuffer_object)
 /* functions defined in MESA_remap_table_functions are excluded */
 static const struct gl_function_remap GL_ARB_framebuffer_object_functions[] = {
@@ -4973,10 +5035,10 @@ static const struct gl_function_remap GL_ARB_map_buffer_range_functions[] = {
 #if defined(need_GL_ARB_matrix_palette)
 static const struct gl_function_remap GL_ARB_matrix_palette_functions[] = {
    {  3339, -1 }, /* MatrixIndexusvARB */
-   { 11655, -1 }, /* MatrixIndexuivARB */
-   { 12856, -1 }, /* MatrixIndexPointerARB */
-   { 17530, -1 }, /* CurrentPaletteMatrixARB */
-   { 20323, -1 }, /* MatrixIndexubvARB */
+   { 11830, -1 }, /* MatrixIndexuivARB */
+   { 13050, -1 }, /* MatrixIndexPointerARB */
+   { 17891, -1 }, /* CurrentPaletteMatrixARB */
+   { 20786, -1 }, /* MatrixIndexubvARB */
    {    -1, -1 }
 };
 #endif
@@ -5048,14 +5110,14 @@ static const struct gl_function_remap GL_ARB_vertex_array_object_functions[] = {
 static const struct gl_function_remap GL_ARB_vertex_blend_functions[] = {
    {  2226, -1 }, /* WeightubvARB */
    {  5633, -1 }, /* WeightivARB */
-   {  9847, -1 }, /* WeightPointerARB */
-   { 12325, -1 }, /* WeightfvARB */
-   { 15610, -1 }, /* WeightbvARB */
-   { 18704, -1 }, /* WeightusvARB */
-   { 21349, -1 }, /* VertexBlendARB */
-   { 26480, -1 }, /* WeightsvARB */
-   { 28429, -1 }, /* WeightdvARB */
-   { 29127, -1 }, /* WeightuivARB */
+   {  9937, -1 }, /* WeightPointerARB */
+   { 12468, -1 }, /* WeightfvARB */
+   { 15930, -1 }, /* WeightbvARB */
+   { 19104, -1 }, /* WeightusvARB */
+   { 21812, -1 }, /* VertexBlendARB */
+   { 27006, -1 }, /* WeightsvARB */
+   { 28952, -1 }, /* WeightdvARB */
+   { 29650, -1 }, /* WeightuivARB */
    {    -1, -1 }
 };
 #endif
@@ -5146,15 +5208,15 @@ static const struct gl_function_remap GL_EXT_blend_func_separate_functions[] = {
 
 #if defined(need_GL_EXT_blend_minmax)
 static const struct gl_function_remap GL_EXT_blend_minmax_functions[] = {
-   {  9982, _gloffset_BlendEquation },
+   { 10072, _gloffset_BlendEquation },
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_EXT_color_subtable)
 static const struct gl_function_remap GL_EXT_color_subtable_functions[] = {
-   { 15106, _gloffset_ColorSubTable },
-   { 28379, _gloffset_CopyColorSubTable },
+   { 15378, _gloffset_ColorSubTable },
+   { 28902, _gloffset_CopyColorSubTable },
    {    -1, -1 }
 };
 #endif
@@ -5174,52 +5236,52 @@ static const struct gl_function_remap GL_EXT_convolution_functions[] = {
    {  7583, _gloffset_ConvolutionFilter2D },
    {  7749, _gloffset_ConvolutionParameteriv },
    {  8209, _gloffset_ConvolutionParameterfv },
-   { 18279, _gloffset_GetSeparableFilter },
-   { 21423, _gloffset_SeparableFilter2D },
-   { 22252, _gloffset_ConvolutionParameteri },
-   { 22375, _gloffset_ConvolutionParameterf },
-   { 23828, _gloffset_GetConvolutionParameterfv },
-   { 24650, _gloffset_GetConvolutionFilter },
-   { 26894, _gloffset_CopyConvolutionFilter2D },
+   { 18640, _gloffset_GetSeparableFilter },
+   { 21886, _gloffset_SeparableFilter2D },
+   { 22715, _gloffset_ConvolutionParameteri },
+   { 22838, _gloffset_ConvolutionParameterf },
+   { 24293, _gloffset_GetConvolutionParameterfv },
+   { 25147, _gloffset_GetConvolutionFilter },
+   { 27420, _gloffset_CopyConvolutionFilter2D },
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_EXT_coordinate_frame)
 static const struct gl_function_remap GL_EXT_coordinate_frame_functions[] = {
-   {  9362, -1 }, /* TangentPointerEXT */
-   { 11169, -1 }, /* Binormal3ivEXT */
-   { 11787, -1 }, /* Tangent3sEXT */
-   { 12921, -1 }, /* Tangent3fvEXT */
-   { 16542, -1 }, /* Tangent3dvEXT */
-   { 17228, -1 }, /* Binormal3bvEXT */
-   { 18332, -1 }, /* Binormal3dEXT */
-   { 20255, -1 }, /* Tangent3fEXT */
-   { 22324, -1 }, /* Binormal3sEXT */
-   { 22769, -1 }, /* Tangent3ivEXT */
-   { 22788, -1 }, /* Tangent3dEXT */
-   { 23592, -1 }, /* Binormal3svEXT */
-   { 24073, -1 }, /* Binormal3fEXT */
-   { 24925, -1 }, /* Binormal3dvEXT */
-   { 26100, -1 }, /* Tangent3iEXT */
-   { 27179, -1 }, /* Tangent3bvEXT */
-   { 27588, -1 }, /* Tangent3bEXT */
-   { 28152, -1 }, /* Binormal3fvEXT */
-   { 28826, -1 }, /* BinormalPointerEXT */
-   { 29231, -1 }, /* Tangent3svEXT */
-   { 29668, -1 }, /* Binormal3bEXT */
-   { 29845, -1 }, /* Binormal3iEXT */
+   {  9416, -1 }, /* TangentPointerEXT */
+   { 11344, -1 }, /* Binormal3ivEXT */
+   { 11962, -1 }, /* Tangent3sEXT */
+   { 13115, -1 }, /* Tangent3fvEXT */
+   { 16862, -1 }, /* Tangent3dvEXT */
+   { 17589, -1 }, /* Binormal3bvEXT */
+   { 18693, -1 }, /* Binormal3dEXT */
+   { 20718, -1 }, /* Tangent3fEXT */
+   { 22787, -1 }, /* Binormal3sEXT */
+   { 23232, -1 }, /* Tangent3ivEXT */
+   { 23251, -1 }, /* Tangent3dEXT */
+   { 24057, -1 }, /* Binormal3svEXT */
+   { 24570, -1 }, /* Binormal3fEXT */
+   { 25422, -1 }, /* Binormal3dvEXT */
+   { 26626, -1 }, /* Tangent3iEXT */
+   { 27705, -1 }, /* Tangent3bvEXT */
+   { 28150, -1 }, /* Tangent3bEXT */
+   { 28675, -1 }, /* Binormal3fvEXT */
+   { 29349, -1 }, /* BinormalPointerEXT */
+   { 29754, -1 }, /* Tangent3svEXT */
+   { 30191, -1 }, /* Binormal3bEXT */
+   { 30368, -1 }, /* Binormal3iEXT */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_EXT_copy_texture)
 static const struct gl_function_remap GL_EXT_copy_texture_functions[] = {
-   { 13364, _gloffset_CopyTexSubImage3D },
-   { 14846, _gloffset_CopyTexImage2D },
-   { 21860, _gloffset_CopyTexImage1D },
-   { 24331, _gloffset_CopyTexSubImage2D },
-   { 26532, _gloffset_CopyTexSubImage1D },
+   { 13558, _gloffset_CopyTexSubImage3D },
+   { 15118, _gloffset_CopyTexImage2D },
+   { 22323, _gloffset_CopyTexImage1D },
+   { 24828, _gloffset_CopyTexSubImage2D },
+   { 27058, _gloffset_CopyTexSubImage1D },
    {    -1, -1 }
 };
 #endif
@@ -5245,9 +5307,16 @@ static const struct gl_function_remap GL_EXT_draw_buffers2_functions[] = {
 };
 #endif
 
+#if defined(need_GL_EXT_draw_instanced)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_draw_instanced_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
 #if defined(need_GL_EXT_draw_range_elements)
 static const struct gl_function_remap GL_EXT_draw_range_elements_functions[] = {
-   {  8492, _gloffset_DrawRangeElements },
+   {  8546, _gloffset_DrawRangeElements },
    {    -1, -1 }
 };
 #endif
@@ -5291,37 +5360,37 @@ static const struct gl_function_remap GL_EXT_gpu_program_parameters_functions[]
 static const struct gl_function_remap GL_EXT_histogram_functions[] = {
    {   812, _gloffset_Histogram },
    {  3088, _gloffset_ResetHistogram },
-   {  8864, _gloffset_GetMinmax },
-   { 13698, _gloffset_GetHistogramParameterfv },
-   { 21785, _gloffset_GetMinmaxParameteriv },
-   { 23718, _gloffset_ResetMinmax },
-   { 24547, _gloffset_GetHistogramParameteriv },
-   { 25603, _gloffset_GetHistogram },
-   { 27965, _gloffset_Minmax },
-   { 29466, _gloffset_GetMinmaxParameterfv },
+   {  8918, _gloffset_GetMinmax },
+   { 13892, _gloffset_GetHistogramParameterfv },
+   { 22248, _gloffset_GetMinmaxParameteriv },
+   { 24183, _gloffset_ResetMinmax },
+   { 25044, _gloffset_GetHistogramParameteriv },
+   { 26129, _gloffset_GetHistogram },
+   { 28527, _gloffset_Minmax },
+   { 29989, _gloffset_GetMinmaxParameterfv },
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_EXT_index_func)
 static const struct gl_function_remap GL_EXT_index_func_functions[] = {
-   { 10209, -1 }, /* IndexFuncEXT */
+   { 10299, -1 }, /* IndexFuncEXT */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_EXT_index_material)
 static const struct gl_function_remap GL_EXT_index_material_functions[] = {
-   { 18791, -1 }, /* IndexMaterialEXT */
+   { 19191, -1 }, /* IndexMaterialEXT */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_EXT_light_texture)
 static const struct gl_function_remap GL_EXT_light_texture_functions[] = {
-   { 23612, -1 }, /* ApplyTextureEXT */
-   { 23672, -1 }, /* TextureMaterialEXT */
-   { 23697, -1 }, /* TextureLightEXT */
+   { 24077, -1 }, /* ApplyTextureEXT */
+   { 24137, -1 }, /* TextureMaterialEXT */
+   { 24162, -1 }, /* TextureLightEXT */
    {    -1, -1 }
 };
 #endif
@@ -5343,19 +5412,19 @@ static const struct gl_function_remap GL_EXT_multisample_functions[] = {
 #if defined(need_GL_EXT_paletted_texture)
 static const struct gl_function_remap GL_EXT_paletted_texture_functions[] = {
    {  7445, _gloffset_ColorTable },
-   { 13544, _gloffset_GetColorTable },
-   { 20438, _gloffset_GetColorTableParameterfv },
-   { 22431, _gloffset_GetColorTableParameteriv },
+   { 13738, _gloffset_GetColorTable },
+   { 20901, _gloffset_GetColorTableParameterfv },
+   { 22894, _gloffset_GetColorTableParameteriv },
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_EXT_pixel_transform)
 static const struct gl_function_remap GL_EXT_pixel_transform_functions[] = {
-   {  9603, -1 }, /* PixelTransformParameterfvEXT */
-   { 19405, -1 }, /* PixelTransformParameterfEXT */
-   { 19485, -1 }, /* PixelTransformParameteriEXT */
-   { 28790, -1 }, /* PixelTransformParameterivEXT */
+   { 19842, -1 }, /* PixelTransformParameterfEXT */
+   { 19922, -1 }, /* PixelTransformParameteriEXT */
+   { 27888, -1 }, /* PixelTransformParameterfvEXT */
+   { 29313, -1 }, /* PixelTransformParameterivEXT */
    {    -1, -1 }
 };
 #endif
@@ -5398,7 +5467,7 @@ static const struct gl_function_remap GL_EXT_stencil_two_side_functions[] = {
 #if defined(need_GL_EXT_subtexture)
 static const struct gl_function_remap GL_EXT_subtexture_functions[] = {
    {  6166, _gloffset_TexSubImage1D },
-   {  9478, _gloffset_TexSubImage2D },
+   {  9532, _gloffset_TexSubImage2D },
    {    -1, -1 }
 };
 #endif
@@ -5406,7 +5475,7 @@ static const struct gl_function_remap GL_EXT_subtexture_functions[] = {
 #if defined(need_GL_EXT_texture3D)
 static const struct gl_function_remap GL_EXT_texture3D_functions[] = {
    {  1658, _gloffset_TexImage3D },
-   { 20207, _gloffset_TexSubImage3D },
+   { 20670, _gloffset_TexSubImage3D },
    {    -1, -1 }
 };
 #endif
@@ -5422,17 +5491,17 @@ static const struct gl_function_remap GL_EXT_texture_array_functions[] = {
 static const struct gl_function_remap GL_EXT_texture_object_functions[] = {
    {  2964, _gloffset_PrioritizeTextures },
    {  6615, _gloffset_AreTexturesResident },
-   { 12063, _gloffset_GenTextures },
-   { 14030, _gloffset_DeleteTextures },
-   { 17281, _gloffset_IsTexture },
-   { 26597, _gloffset_BindTexture },
+   { 12238, _gloffset_GenTextures },
+   { 14224, _gloffset_DeleteTextures },
+   { 17642, _gloffset_IsTexture },
+   { 27123, _gloffset_BindTexture },
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_EXT_texture_perturb_normal)
 static const struct gl_function_remap GL_EXT_texture_perturb_normal_functions[] = {
-   { 12275, -1 }, /* TextureNormalEXT */
+   { 12418, -1 }, /* TextureNormalEXT */
    {    -1, -1 }
 };
 #endif
@@ -5444,21 +5513,28 @@ static const struct gl_function_remap GL_EXT_timer_query_functions[] = {
 };
 #endif
 
+#if defined(need_GL_EXT_transform_feedback)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_transform_feedback_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
 #if defined(need_GL_EXT_vertex_array)
 /* functions defined in MESA_remap_table_functions are excluded */
 static const struct gl_function_remap GL_EXT_vertex_array_functions[] = {
-   { 21612, _gloffset_ArrayElement },
-   { 27553, _gloffset_GetPointerv },
-   { 29093, _gloffset_DrawArrays },
+   { 22075, _gloffset_ArrayElement },
+   { 28115, _gloffset_GetPointerv },
+   { 29616, _gloffset_DrawArrays },
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_EXT_vertex_weighting)
 static const struct gl_function_remap GL_EXT_vertex_weighting_functions[] = {
-   { 17311, -1 }, /* VertexWeightfvEXT */
-   { 24051, -1 }, /* VertexWeightfEXT */
-   { 25572, -1 }, /* VertexWeightPointerEXT */
+   { 17672, -1 }, /* VertexWeightfvEXT */
+   { 24548, -1 }, /* VertexWeightfEXT */
+   { 26098, -1 }, /* VertexWeightPointerEXT */
    {    -1, -1 }
 };
 #endif
@@ -5467,10 +5543,10 @@ static const struct gl_function_remap GL_EXT_vertex_weighting_functions[] = {
 static const struct gl_function_remap GL_HP_image_transform_functions[] = {
    {  2157, -1 }, /* GetImageTransformParameterfvHP */
    {  3305, -1 }, /* ImageTransformParameterfHP */
-   {  9056, -1 }, /* ImageTransformParameterfvHP */
-   { 10678, -1 }, /* ImageTransformParameteriHP */
-   { 10940, -1 }, /* GetImageTransformParameterivHP */
-   { 17375, -1 }, /* ImageTransformParameterivHP */
+   {  9110, -1 }, /* ImageTransformParameterfvHP */
+   { 10768, -1 }, /* ImageTransformParameteriHP */
+   { 11115, -1 }, /* GetImageTransformParameterivHP */
+   { 17736, -1 }, /* ImageTransformParameterivHP */
    {    -1, -1 }
 };
 #endif
@@ -5488,10 +5564,10 @@ static const struct gl_function_remap GL_IBM_vertex_array_lists_functions[] = {
    {  5167, -1 }, /* NormalPointerListIBM */
    {  6789, -1 }, /* FogCoordPointerListIBM */
    {  7096, -1 }, /* VertexPointerListIBM */
-   { 10599, -1 }, /* ColorPointerListIBM */
-   { 11894, -1 }, /* TexCoordPointerListIBM */
-   { 12297, -1 }, /* IndexPointerListIBM */
-   { 29409, -1 }, /* EdgeFlagPointerListIBM */
+   { 10689, -1 }, /* ColorPointerListIBM */
+   { 12069, -1 }, /* TexCoordPointerListIBM */
+   { 12440, -1 }, /* IndexPointerListIBM */
+   { 29932, -1 }, /* EdgeFlagPointerListIBM */
    {    -1, -1 }
 };
 #endif
@@ -5505,10 +5581,10 @@ static const struct gl_function_remap GL_INGR_blend_func_separate_functions[] =
 
 #if defined(need_GL_INTEL_parallel_arrays)
 static const struct gl_function_remap GL_INTEL_parallel_arrays_functions[] = {
-   { 11281, -1 }, /* VertexPointervINTEL */
-   { 13791, -1 }, /* ColorPointervINTEL */
-   { 26868, -1 }, /* NormalPointervINTEL */
-   { 27294, -1 }, /* TexCoordPointervINTEL */
+   { 11456, -1 }, /* VertexPointervINTEL */
+   { 13985, -1 }, /* ColorPointervINTEL */
+   { 27394, -1 }, /* NormalPointervINTEL */
+   { 27820, -1 }, /* TexCoordPointervINTEL */
    {    -1, -1 }
 };
 #endif
@@ -5525,7 +5601,7 @@ static const struct gl_function_remap GL_MESA_shader_debug_functions[] = {
    {  1522, -1 }, /* GetDebugLogLengthMESA */
    {  3063, -1 }, /* ClearDebugLogMESA */
    {  4018, -1 }, /* GetDebugLogMESA */
-   { 27746, -1 }, /* CreateDebugObjectMESA */
+   { 28308, -1 }, /* CreateDebugObjectMESA */
    {    -1, -1 }
 };
 #endif
@@ -5549,12 +5625,12 @@ static const struct gl_function_remap GL_NV_evaluators_functions[] = {
    {  5834, -1 }, /* GetMapAttribParameterivNV */
    {  7551, -1 }, /* MapControlPointsNV */
    {  7650, -1 }, /* MapParameterfvNV */
-   {  9461, -1 }, /* EvalMapsNV */
-   { 15280, -1 }, /* GetMapAttribParameterfvNV */
-   { 15446, -1 }, /* MapParameterivNV */
-   { 22175, -1 }, /* GetMapParameterivNV */
-   { 22673, -1 }, /* GetMapParameterfvNV */
-   { 26204, -1 }, /* GetMapControlPointsNV */
+   {  9515, -1 }, /* EvalMapsNV */
+   { 15600, -1 }, /* GetMapAttribParameterfvNV */
+   { 15766, -1 }, /* MapParameterivNV */
+   { 22638, -1 }, /* GetMapParameterivNV */
+   { 23136, -1 }, /* GetMapParameterfvNV */
+   { 26730, -1 }, /* GetMapControlPointsNV */
    {    -1, -1 }
 };
 #endif
@@ -5589,8 +5665,8 @@ static const struct gl_function_remap GL_NV_register_combiners_functions[] = {
 
 #if defined(need_GL_NV_register_combiners2)
 static const struct gl_function_remap GL_NV_register_combiners2_functions[] = {
-   { 14183, -1 }, /* CombinerStageParameterfvNV */
-   { 14498, -1 }, /* GetCombinerStageParameterfvNV */
+   { 14455, -1 }, /* CombinerStageParameterfvNV */
+   { 14770, -1 }, /* GetCombinerStageParameterfvNV */
    {    -1, -1 }
 };
 #endif
@@ -5625,16 +5701,16 @@ static const struct gl_function_remap GL_PGI_misc_hints_functions[] = {
 
 #if defined(need_GL_SGIS_detail_texture)
 static const struct gl_function_remap GL_SGIS_detail_texture_functions[] = {
-   { 14471, -1 }, /* GetDetailTexFuncSGIS */
-   { 14791, -1 }, /* DetailTexFuncSGIS */
+   { 14743, -1 }, /* GetDetailTexFuncSGIS */
+   { 15063, -1 }, /* DetailTexFuncSGIS */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_SGIS_fog_function)
 static const struct gl_function_remap GL_SGIS_fog_function_functions[] = {
-   { 24313, -1 }, /* FogFuncSGIS */
-   { 24978, -1 }, /* GetFogFuncSGIS */
+   { 24810, -1 }, /* FogFuncSGIS */
+   { 25475, -1 }, /* GetFogFuncSGIS */
    {    -1, -1 }
 };
 #endif
@@ -5663,7 +5739,7 @@ static const struct gl_function_remap GL_SGIS_point_parameters_functions[] = {
 #if defined(need_GL_SGIS_sharpen_texture)
 static const struct gl_function_remap GL_SGIS_sharpen_texture_functions[] = {
    {  5895, -1 }, /* GetSharpenTexFuncSGIS */
-   { 19700, -1 }, /* SharpenTexFuncSGIS */
+   { 20137, -1 }, /* SharpenTexFuncSGIS */
    {    -1, -1 }
 };
 #endif
@@ -5671,14 +5747,14 @@ static const struct gl_function_remap GL_SGIS_sharpen_texture_functions[] = {
 #if defined(need_GL_SGIS_texture4D)
 static const struct gl_function_remap GL_SGIS_texture4D_functions[] = {
    {   894, -1 }, /* TexImage4DSGIS */
-   { 14099, -1 }, /* TexSubImage4DSGIS */
+   { 14293, -1 }, /* TexSubImage4DSGIS */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_SGIS_texture_color_mask)
 static const struct gl_function_remap GL_SGIS_texture_color_mask_functions[] = {
-   { 13497, -1 }, /* TextureColorMaskSGIS */
+   { 13691, -1 }, /* TextureColorMaskSGIS */
    {    -1, -1 }
 };
 #endif
@@ -5686,7 +5762,7 @@ static const struct gl_function_remap GL_SGIS_texture_color_mask_functions[] = {
 #if defined(need_GL_SGIS_texture_filter4)
 static const struct gl_function_remap GL_SGIS_texture_filter4_functions[] = {
    {  6072, -1 }, /* GetTexFilterFuncSGIS */
-   { 14617, -1 }, /* TexFilterFuncSGIS */
+   { 14889, -1 }, /* TexFilterFuncSGIS */
    {    -1, -1 }
 };
 #endif
@@ -5696,9 +5772,9 @@ static const struct gl_function_remap GL_SGIX_async_functions[] = {
    {  3014, -1 }, /* AsyncMarkerSGIX */
    {  3997, -1 }, /* FinishAsyncSGIX */
    {  4734, -1 }, /* PollAsyncSGIX */
-   { 19847, -1 }, /* DeleteAsyncMarkersSGIX */
-   { 19876, -1 }, /* IsAsyncMarkerSGIX */
-   { 29206, -1 }, /* GenAsyncMarkersSGIX */
+   { 20284, -1 }, /* DeleteAsyncMarkersSGIX */
+   { 20339, -1 }, /* IsAsyncMarkerSGIX */
+   { 29729, -1 }, /* GenAsyncMarkersSGIX */
    {    -1, -1 }
 };
 #endif
@@ -5719,31 +5795,31 @@ static const struct gl_function_remap GL_SGIX_fragment_lighting_functions[] = {
    {  7163, -1 }, /* FragmentMaterialfSGIX */
    {  7324, -1 }, /* GetFragmentLightivSGIX */
    {  8161, -1 }, /* FragmentLightModeliSGIX */
-   {  9524, -1 }, /* FragmentLightivSGIX */
-   {  9790, -1 }, /* GetFragmentMaterialivSGIX */
-   { 17198, -1 }, /* FragmentLightModelfSGIX */
-   { 17498, -1 }, /* FragmentColorMaterialSGIX */
-   { 17898, -1 }, /* FragmentMaterialiSGIX */
-   { 19119, -1 }, /* LightEnviSGIX */
-   { 20530, -1 }, /* FragmentLightModelfvSGIX */
-   { 20839, -1 }, /* FragmentLightfvSGIX */
-   { 25454, -1 }, /* FragmentLightfSGIX */
-   { 28122, -1 }, /* GetFragmentLightfvSGIX */
-   { 29689, -1 }, /* FragmentMaterialivSGIX */
+   {  9578, -1 }, /* FragmentLightivSGIX */
+   {  9880, -1 }, /* GetFragmentMaterialivSGIX */
+   { 17559, -1 }, /* FragmentLightModelfSGIX */
+   { 17859, -1 }, /* FragmentColorMaterialSGIX */
+   { 18259, -1 }, /* FragmentMaterialiSGIX */
+   { 19519, -1 }, /* LightEnviSGIX */
+   { 20993, -1 }, /* FragmentLightModelfvSGIX */
+   { 21302, -1 }, /* FragmentLightfvSGIX */
+   { 25980, -1 }, /* FragmentLightfSGIX */
+   { 28645, -1 }, /* GetFragmentLightfvSGIX */
+   { 30212, -1 }, /* FragmentMaterialivSGIX */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_SGIX_framezoom)
 static const struct gl_function_remap GL_SGIX_framezoom_functions[] = {
-   { 19899, -1 }, /* FrameZoomSGIX */
+   { 20362, -1 }, /* FrameZoomSGIX */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_SGIX_igloo_interface)
 static const struct gl_function_remap GL_SGIX_igloo_interface_functions[] = {
-   { 25762, -1 }, /* IglooInterfaceSGIX */
+   { 26288, -1 }, /* IglooInterfaceSGIX */
    {    -1, -1 }
 };
 #endif
@@ -5752,10 +5828,10 @@ static const struct gl_function_remap GL_SGIX_igloo_interface_functions[] = {
 static const struct gl_function_remap GL_SGIX_instruments_functions[] = {
    {  2573, -1 }, /* ReadInstrumentsSGIX */
    {  5651, -1 }, /* PollInstrumentsSGIX */
-   {  9422, -1 }, /* GetInstrumentsSGIX */
-   { 11492, -1 }, /* StartInstrumentsSGIX */
-   { 14217, -1 }, /* StopInstrumentsSGIX */
-   { 15823, -1 }, /* InstrumentsBufferSGIX */
+   {  9476, -1 }, /* GetInstrumentsSGIX */
+   { 11667, -1 }, /* StartInstrumentsSGIX */
+   { 14489, -1 }, /* StopInstrumentsSGIX */
+   { 16143, -1 }, /* InstrumentsBufferSGIX */
    {    -1, -1 }
 };
 #endif
@@ -5764,10 +5840,10 @@ static const struct gl_function_remap GL_SGIX_instruments_functions[] = {
 static const struct gl_function_remap GL_SGIX_list_priority_functions[] = {
    {  1125, -1 }, /* ListParameterfSGIX */
    {  2763, -1 }, /* GetListParameterfvSGIX */
-   { 15738, -1 }, /* ListParameteriSGIX */
-   { 16492, -1 }, /* ListParameterfvSGIX */
-   { 18525, -1 }, /* ListParameterivSGIX */
-   { 29250, -1 }, /* GetListParameterivSGIX */
+   { 16058, -1 }, /* ListParameteriSGIX */
+   { 16812, -1 }, /* ListParameterfvSGIX */
+   { 18925, -1 }, /* ListParameterivSGIX */
+   { 29773, -1 }, /* GetListParameterivSGIX */
    {    -1, -1 }
 };
 #endif
@@ -5782,33 +5858,33 @@ static const struct gl_function_remap GL_SGIX_pixel_texture_functions[] = {
 #if defined(need_GL_SGIX_polynomial_ffd)
 static const struct gl_function_remap GL_SGIX_polynomial_ffd_functions[] = {
    {  3251, -1 }, /* LoadIdentityDeformationMapSGIX */
-   { 14317, -1 }, /* DeformSGIX */
-   { 21724, -1 }, /* DeformationMap3fSGIX */
-   { 28010, -1 }, /* DeformationMap3dSGIX */
+   { 10989, -1 }, /* DeformationMap3dSGIX */
+   { 14589, -1 }, /* DeformSGIX */
+   { 22187, -1 }, /* DeformationMap3fSGIX */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_SGIX_reference_plane)
 static const struct gl_function_remap GL_SGIX_reference_plane_functions[] = {
-   { 13048, -1 }, /* ReferencePlaneSGIX */
+   { 13242, -1 }, /* ReferencePlaneSGIX */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_SGIX_sprite)
 static const struct gl_function_remap GL_SGIX_sprite_functions[] = {
-   {  8577, -1 }, /* SpriteParameterfvSGIX */
-   { 18353, -1 }, /* SpriteParameteriSGIX */
-   { 23752, -1 }, /* SpriteParameterfSGIX */
-   { 26326, -1 }, /* SpriteParameterivSGIX */
+   {  8631, -1 }, /* SpriteParameterfvSGIX */
+   { 18714, -1 }, /* SpriteParameteriSGIX */
+   { 24217, -1 }, /* SpriteParameterfSGIX */
+   { 26852, -1 }, /* SpriteParameterivSGIX */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_SGIX_tag_sample_buffer)
 static const struct gl_function_remap GL_SGIX_tag_sample_buffer_functions[] = {
-   { 18412, -1 }, /* TagSampleBufferSGIX */
+   { 18773, -1 }, /* TagSampleBufferSGIX */
    {    -1, -1 }
 };
 #endif
@@ -5817,18 +5893,18 @@ static const struct gl_function_remap GL_SGIX_tag_sample_buffer_functions[] = {
 static const struct gl_function_remap GL_SGI_color_table_functions[] = {
    {  6733, _gloffset_ColorTableParameteriv },
    {  7445, _gloffset_ColorTable },
-   { 13544, _gloffset_GetColorTable },
-   { 13654, _gloffset_CopyColorTable },
-   { 17142, _gloffset_ColorTableParameterfv },
-   { 20438, _gloffset_GetColorTableParameterfv },
-   { 22431, _gloffset_GetColorTableParameteriv },
+   { 13738, _gloffset_GetColorTable },
+   { 13848, _gloffset_CopyColorTable },
+   { 17503, _gloffset_ColorTableParameterfv },
+   { 20901, _gloffset_GetColorTableParameterfv },
+   { 22894, _gloffset_GetColorTableParameteriv },
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_SUNX_constant_data)
 static const struct gl_function_remap GL_SUNX_constant_data_functions[] = {
-   { 28100, -1 }, /* FinishTextureSUNX */
+   { 28623, -1 }, /* FinishTextureSUNX */
    {    -1, -1 }
 };
 #endif
@@ -5838,18 +5914,18 @@ static const struct gl_function_remap GL_SUN_global_alpha_functions[] = {
    {  3035, -1 }, /* GlobalAlphaFactorubSUN */
    {  4224, -1 }, /* GlobalAlphaFactoriSUN */
    {  5676, -1 }, /* GlobalAlphaFactordSUN */
-   {  8661, -1 }, /* GlobalAlphaFactoruiSUN */
-   {  9013, -1 }, /* GlobalAlphaFactorbSUN */
-   { 11807, -1 }, /* GlobalAlphaFactorfSUN */
-   { 11926, -1 }, /* GlobalAlphaFactorusSUN */
-   { 20138, -1 }, /* GlobalAlphaFactorsSUN */
+   {  8715, -1 }, /* GlobalAlphaFactoruiSUN */
+   {  9067, -1 }, /* GlobalAlphaFactorbSUN */
+   { 11982, -1 }, /* GlobalAlphaFactorfSUN */
+   { 12101, -1 }, /* GlobalAlphaFactorusSUN */
+   { 20601, -1 }, /* GlobalAlphaFactorsSUN */
    {    -1, -1 }
 };
 #endif
 
 #if defined(need_GL_SUN_mesh_array)
 static const struct gl_function_remap GL_SUN_mesh_array_functions[] = {
-   { 26138, -1 }, /* DrawMeshArraysSUN */
+   { 26664, -1 }, /* DrawMeshArraysSUN */
    {    -1, -1 }
 };
 #endif
@@ -5858,11 +5934,11 @@ static const struct gl_function_remap GL_SUN_mesh_array_functions[] = {
 static const struct gl_function_remap GL_SUN_triangle_list_functions[] = {
    {  3971, -1 }, /* ReplacementCodeubSUN */
    {  5515, -1 }, /* ReplacementCodeubvSUN */
-   { 16863, -1 }, /* ReplacementCodeusvSUN */
-   { 17051, -1 }, /* ReplacementCodePointerSUN */
-   { 18436, -1 }, /* ReplacementCodeusSUN */
-   { 19183, -1 }, /* ReplacementCodeuiSUN */
-   { 26783, -1 }, /* ReplacementCodeuivSUN */
+   { 17224, -1 }, /* ReplacementCodeusvSUN */
+   { 17412, -1 }, /* ReplacementCodePointerSUN */
+   { 19583, -1 }, /* ReplacementCodeuiSUN */
+   { 20313, -1 }, /* ReplacementCodeusSUN */
+   { 27309, -1 }, /* ReplacementCodeuivSUN */
    {    -1, -1 }
 };
 #endif
@@ -5884,31 +5960,31 @@ static const struct gl_function_remap GL_SUN_vertex_functions[] = {
    {  6480, -1 }, /* ReplacementCodeuiTexCoord2fVertex3fSUN */
    {  7192, -1 }, /* TexCoord2fNormal3fVertex3fSUN */
    {  7960, -1 }, /* Color3fVertex3fSUN */
-   {  8972, -1 }, /* Color3fVertex3fvSUN */
-   {  9387, -1 }, /* Color4fNormal3fVertex3fvSUN */
-   { 10088, -1 }, /* ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN */
-   { 11355, -1 }, /* ReplacementCodeuiColor4fNormal3fVertex3fvSUN */
-   { 12779, -1 }, /* ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN */
-   { 13190, -1 }, /* TexCoord2fColor3fVertex3fSUN */
-   { 14242, -1 }, /* TexCoord4fColor4fNormal3fVertex4fSUN */
-   { 14576, -1 }, /* Color4ubVertex2fvSUN */
-   { 14816, -1 }, /* Normal3fVertex3fSUN */
-   { 15764, -1 }, /* ReplacementCodeuiColor4fNormal3fVertex3fSUN */
-   { 16025, -1 }, /* TexCoord2fColor4fNormal3fVertex3fvSUN */
-   { 16692, -1 }, /* TexCoord2fVertex3fvSUN */
-   { 17468, -1 }, /* Color4ubVertex2fSUN */
-   { 17689, -1 }, /* ReplacementCodeuiColor4ubVertex3fSUN */
-   { 19571, -1 }, /* TexCoord2fColor4ubVertex3fSUN */
-   { 19918, -1 }, /* Normal3fVertex3fvSUN */
-   { 20347, -1 }, /* Color4fNormal3fVertex3fSUN */
-   { 21256, -1 }, /* ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN */
-   { 21476, -1 }, /* ReplacementCodeuiColor4ubVertex3fvSUN */
-   { 23206, -1 }, /* ReplacementCodeuiColor3fVertex3fSUN */
-   { 24429, -1 }, /* TexCoord4fVertex4fSUN */
-   { 24855, -1 }, /* TexCoord2fColor3fVertex3fvSUN */
-   { 25181, -1 }, /* ReplacementCodeuiNormal3fVertex3fvSUN */
-   { 25308, -1 }, /* TexCoord4fVertex4fvSUN */
-   { 26010, -1 }, /* ReplacementCodeuiVertex3fSUN */
+   {  9026, -1 }, /* Color3fVertex3fvSUN */
+   {  9441, -1 }, /* Color4fNormal3fVertex3fvSUN */
+   { 10178, -1 }, /* ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN */
+   { 11530, -1 }, /* ReplacementCodeuiColor4fNormal3fVertex3fvSUN */
+   { 12973, -1 }, /* ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN */
+   { 13384, -1 }, /* TexCoord2fColor3fVertex3fSUN */
+   { 14514, -1 }, /* TexCoord4fColor4fNormal3fVertex4fSUN */
+   { 14848, -1 }, /* Color4ubVertex2fvSUN */
+   { 15088, -1 }, /* Normal3fVertex3fSUN */
+   { 16084, -1 }, /* ReplacementCodeuiColor4fNormal3fVertex3fSUN */
+   { 16345, -1 }, /* TexCoord2fColor4fNormal3fVertex3fvSUN */
+   { 17053, -1 }, /* TexCoord2fVertex3fvSUN */
+   { 17829, -1 }, /* Color4ubVertex2fSUN */
+   { 18050, -1 }, /* ReplacementCodeuiColor4ubVertex3fSUN */
+   { 20008, -1 }, /* TexCoord2fColor4ubVertex3fSUN */
+   { 20381, -1 }, /* Normal3fVertex3fvSUN */
+   { 20810, -1 }, /* Color4fNormal3fVertex3fSUN */
+   { 21719, -1 }, /* ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN */
+   { 21939, -1 }, /* ReplacementCodeuiColor4ubVertex3fvSUN */
+   { 23669, -1 }, /* ReplacementCodeuiColor3fVertex3fSUN */
+   { 24926, -1 }, /* TexCoord4fVertex4fSUN */
+   { 25352, -1 }, /* TexCoord2fColor3fVertex3fvSUN */
+   { 25707, -1 }, /* ReplacementCodeuiNormal3fVertex3fvSUN */
+   { 25834, -1 }, /* TexCoord4fVertex4fvSUN */
+   { 26536, -1 }, /* ReplacementCodeuiVertex3fSUN */
    {    -1, -1 }
 };
 #endif
@@ -5923,33 +5999,33 @@ static const struct gl_function_remap GL_VERSION_1_3_functions[] = {
    {  5346, _gloffset_MultiTexCoord2iARB },
    {  5470, _gloffset_MultiTexCoord2svARB },
    {  7401, _gloffset_MultiTexCoord2fARB },
-   {  9223, _gloffset_MultiTexCoord3fvARB },
-   {  9744, _gloffset_MultiTexCoord4sARB },
-   { 10378, _gloffset_MultiTexCoord2dvARB },
-   { 10760, _gloffset_MultiTexCoord1svARB },
-   { 11050, _gloffset_MultiTexCoord3svARB },
-   { 11111, _gloffset_MultiTexCoord4iARB },
-   { 11834, _gloffset_MultiTexCoord3iARB },
-   { 12568, _gloffset_MultiTexCoord1dARB },
-   { 12734, _gloffset_MultiTexCoord3dvARB },
-   { 13898, _gloffset_MultiTexCoord3ivARB },
-   { 13943, _gloffset_MultiTexCoord2sARB },
-   { 15163, _gloffset_MultiTexCoord4ivARB },
-   { 16792, _gloffset_ClientActiveTextureARB },
-   { 19036, _gloffset_MultiTexCoord2dARB },
-   { 19440, _gloffset_MultiTexCoord4dvARB },
-   { 19726, _gloffset_MultiTexCoord4fvARB },
-   { 20579, _gloffset_MultiTexCoord3fARB },
-   { 22959, _gloffset_MultiTexCoord4dARB },
-   { 23163, _gloffset_MultiTexCoord1sARB },
-   { 23365, _gloffset_MultiTexCoord1dvARB },
-   { 24175, _gloffset_MultiTexCoord1ivARB },
-   { 24268, _gloffset_MultiTexCoord2ivARB },
-   { 24607, _gloffset_MultiTexCoord1iARB },
-   { 25878, _gloffset_MultiTexCoord4svARB },
-   { 26396, _gloffset_MultiTexCoord1fARB },
-   { 26659, _gloffset_MultiTexCoord4fARB },
-   { 28927, _gloffset_MultiTexCoord2fvARB },
+   {  9277, _gloffset_MultiTexCoord3fvARB },
+   {  9834, _gloffset_MultiTexCoord4sARB },
+   { 10468, _gloffset_MultiTexCoord2dvARB },
+   { 10850, _gloffset_MultiTexCoord1svARB },
+   { 11225, _gloffset_MultiTexCoord3svARB },
+   { 11286, _gloffset_MultiTexCoord4iARB },
+   { 12009, _gloffset_MultiTexCoord3iARB },
+   { 12711, _gloffset_MultiTexCoord1dARB },
+   { 12928, _gloffset_MultiTexCoord3dvARB },
+   { 14092, _gloffset_MultiTexCoord3ivARB },
+   { 14137, _gloffset_MultiTexCoord2sARB },
+   { 15435, _gloffset_MultiTexCoord4ivARB },
+   { 17153, _gloffset_ClientActiveTextureARB },
+   { 19436, _gloffset_MultiTexCoord2dARB },
+   { 19877, _gloffset_MultiTexCoord4dvARB },
+   { 20163, _gloffset_MultiTexCoord4fvARB },
+   { 21042, _gloffset_MultiTexCoord3fARB },
+   { 23422, _gloffset_MultiTexCoord4dARB },
+   { 23626, _gloffset_MultiTexCoord1sARB },
+   { 23830, _gloffset_MultiTexCoord1dvARB },
+   { 24672, _gloffset_MultiTexCoord1ivARB },
+   { 24765, _gloffset_MultiTexCoord2ivARB },
+   { 25104, _gloffset_MultiTexCoord1iARB },
+   { 26404, _gloffset_MultiTexCoord4svARB },
+   { 26922, _gloffset_MultiTexCoord1fARB },
+   { 27185, _gloffset_MultiTexCoord4fARB },
+   { 29450, _gloffset_MultiTexCoord2fvARB },
    {    -1, -1 }
 };
 #endif
@@ -5982,3 +6058,17 @@ static const struct gl_function_remap GL_VERSION_2_1_functions[] = {
 };
 #endif
 
+#if defined(need_GL_VERSION_3_0)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_3_0_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_3_1)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_3_1_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
diff --git a/src/mesa/main/state.c b/src/mesa/main/state.c
index 589029db58b..b971cc976ee 100644
--- a/src/mesa/main/state.c
+++ b/src/mesa/main/state.c
@@ -582,9 +582,6 @@ _mesa_update_state_locked( GLcontext *ctx )
    if (new_state & _DD_NEW_SEPARATE_SPECULAR)
       update_separate_specular( ctx );
 
-   if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT))
-      update_arrays( ctx );
-
    if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT))
       update_viewport_matrix(ctx);
 
@@ -620,6 +617,8 @@ _mesa_update_state_locked( GLcontext *ctx )
       new_prog_state |= update_program( ctx );
    }
 
+   if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT))
+      update_arrays( ctx );
 
  out:
    new_prog_state |= update_program_constants(ctx);
diff --git a/src/mesa/main/texenvprogram.c b/src/mesa/main/texenvprogram.c
index 7b8a8b85f22..964ba13c700 100644
--- a/src/mesa/main/texenvprogram.c
+++ b/src/mesa/main/texenvprogram.c
@@ -1415,6 +1415,7 @@ create_new_program(GLcontext *ctx, struct state_key *key,
    struct texenv_fragment_program p;
    GLuint unit;
    struct ureg cf, out;
+   int i;
 
    memset(&p, 0, sizeof(p));
    p.state = key;
@@ -1436,7 +1437,13 @@ create_new_program(GLcontext *ctx, struct state_key *key,
    p.program->Base.NumAddressRegs = 0;
    p.program->Base.Parameters = _mesa_new_parameter_list();
    p.program->Base.InputsRead = 0x0;
-   p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR;
+
+   if (ctx->DrawBuffer->_NumColorDrawBuffers == 1)
+      p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR;
+   else {
+      for (i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; i++)
+	 p.program->Base.OutputsWritten |= (1 << (FRAG_RESULT_DATA0 + i));
+   }
 
    for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
       p.src_texture[unit] = undef;
@@ -1485,22 +1492,28 @@ create_new_program(GLcontext *ctx, struct state_key *key,
    }
 
    cf = get_source( &p, SRC_PREVIOUS, 0 );
-   out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLOR );
 
-   if (key->separate_specular) {
-      /* Emit specular add.
-       */
-      struct ureg s = register_input(&p, FRAG_ATTRIB_COL1);
-      emit_arith( &p, OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );
-      emit_arith( &p, OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );
-   }
-   else if (memcmp(&cf, &out, sizeof(cf)) != 0) {
-      /* Will wind up in here if no texture enabled or a couple of
-       * other scenarios (GL_REPLACE for instance).
-       */
-      emit_arith( &p, OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );
-   }
+   for (i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; i++) {
+      if (ctx->DrawBuffer->_NumColorDrawBuffers == 1)
+	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLOR );
+      else {
+	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_DATA0 + i );
+      }
 
+      if (key->separate_specular) {
+	 /* Emit specular add.
+	  */
+	 struct ureg s = register_input(&p, FRAG_ATTRIB_COL1);
+	 emit_arith( &p, OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );
+	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );
+      }
+      else if (memcmp(&cf, &out, sizeof(cf)) != 0) {
+	 /* Will wind up in here if no texture enabled or a couple of
+	  * other scenarios (GL_REPLACE for instance).
+	  */
+	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );
+      }
+   }
    /* Finish up:
     */
    emit_arith( &p, OPCODE_END, undef, WRITEMASK_XYZW, 0, undef, undef, undef);
diff --git a/src/mesa/main/teximage.c b/src/mesa/main/teximage.c
index d72e91b3a3b..edb80b18e98 100644
--- a/src/mesa/main/teximage.c
+++ b/src/mesa/main/teximage.c
@@ -2457,6 +2457,12 @@ _mesa_EGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image)
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
+   if (!ctx->Extensions.OES_EGL_image) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glEGLImageTargetTexture2DOES(unsupported)");
+      return;
+   }
+
    if (target != GL_TEXTURE_2D) {
       _mesa_error(ctx, GL_INVALID_ENUM,
 		  "glEGLImageTargetTexture2D(target=%d)", target);
diff --git a/src/mesa/main/vtxfmt.c b/src/mesa/main/vtxfmt.c
index 0dd3e5e52ee..ca352e88e6b 100644
--- a/src/mesa/main/vtxfmt.c
+++ b/src/mesa/main/vtxfmt.c
@@ -140,6 +140,8 @@ install_vtxfmt( struct _glapi_table *tab, const GLvertexformat *vfmt )
    SET_DrawElementsBaseVertex(tab, vfmt->DrawElementsBaseVertex);
    SET_DrawRangeElementsBaseVertex(tab, vfmt->DrawRangeElementsBaseVertex);
    SET_MultiDrawElementsBaseVertex(tab, vfmt->MultiDrawElementsBaseVertex);
+   SET_DrawArraysInstanced(tab, vfmt->DrawArraysInstanced);
+   SET_DrawElementsInstanced(tab, vfmt->DrawElementsInstanced);
 
    /* GL_NV_vertex_program */
    SET_VertexAttrib1fNV(tab, vfmt->VertexAttrib1fNV);
diff --git a/src/mesa/main/vtxfmt_tmp.h b/src/mesa/main/vtxfmt_tmp.h
index 037c4b1888b..9ec6ea49aa2 100644
--- a/src/mesa/main/vtxfmt_tmp.h
+++ b/src/mesa/main/vtxfmt_tmp.h
@@ -391,6 +391,25 @@ static void GLAPIENTRY TAG(MultiDrawElementsBaseVertex)( GLenum mode,
 						      primcount, basevertex ));
 }
 
+static void GLAPIENTRY
+TAG(DrawArraysInstanced)(GLenum mode, GLint first,
+                         GLsizei count, GLsizei primcount)
+{
+   PRE_LOOPBACK( DrawArraysInstanced );
+   CALL_DrawArraysInstanced(GET_DISPATCH(), (mode, first, count, primcount));
+}
+
+static void GLAPIENTRY
+TAG(DrawElementsInstanced)(GLenum mode, GLsizei count,
+                           GLenum type, const GLvoid *indices,
+                           GLsizei primcount)
+{
+   PRE_LOOPBACK( DrawElementsInstanced );
+   CALL_DrawElementsInstanced(GET_DISPATCH(),
+                              (mode, count, type, indices, primcount));
+}
+
+
 static void GLAPIENTRY TAG(EvalMesh1)( GLenum mode, GLint i1, GLint i2 )
 {
    PRE_LOOPBACK( EvalMesh1 );
@@ -574,6 +593,8 @@ static GLvertexformat TAG(vtxfmt) = {
    TAG(DrawElementsBaseVertex),
    TAG(DrawRangeElementsBaseVertex),
    TAG(MultiDrawElementsBaseVertex),
+   TAG(DrawArraysInstanced),
+   TAG(DrawElementsInstanced),
    TAG(EvalMesh1),
    TAG(EvalMesh2)
 };
diff --git a/src/mesa/shader/program.c b/src/mesa/shader/program.c
index f4f701b5461..f77a7737530 100644
--- a/src/mesa/shader/program.c
+++ b/src/mesa/shader/program.c
@@ -625,7 +625,7 @@ replace_registers(struct prog_instruction *inst, GLuint numInst,
    GLuint i, j;
    for (i = 0; i < numInst; i++) {
       /* src regs */
-      for (j = 0; j < _mesa_num_inst_src_regs(inst->Opcode); j++) {
+      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {
          if (inst[i].SrcReg[j].File == oldFile &&
              inst[i].SrcReg[j].Index == oldIndex) {
             inst[i].SrcReg[j].File = newFile;
@@ -652,7 +652,7 @@ adjust_param_indexes(struct prog_instruction *inst, GLuint numInst,
 {
    GLuint i, j;
    for (i = 0; i < numInst; i++) {
-      for (j = 0; j < _mesa_num_inst_src_regs(inst->Opcode); j++) {
+      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {
          GLuint f = inst[i].SrcReg[j].File;
          if (f == PROGRAM_CONSTANT ||
              f == PROGRAM_UNIFORM ||
diff --git a/src/mesa/sources.mak b/src/mesa/sources.mak
index 996172d9a50..d9ebb51a6d2 100644
--- a/src/mesa/sources.mak
+++ b/src/mesa/sources.mak
@@ -199,6 +199,7 @@ STATETRACKER_SOURCES = \
 	state_tracker/st_cb_condrender.c \
 	state_tracker/st_cb_flush.c \
 	state_tracker/st_cb_drawpixels.c \
+	state_tracker/st_cb_eglimage.c \
 	state_tracker/st_cb_fbo.c \
 	state_tracker/st_cb_feedback.c \
 	state_tracker/st_cb_program.c \
@@ -213,7 +214,6 @@ STATETRACKER_SOURCES = \
 	state_tracker/st_draw_feedback.c \
 	state_tracker/st_extensions.c \
 	state_tracker/st_format.c \
-	state_tracker/st_framebuffer.c \
 	state_tracker/st_gen_mipmap.c \
 	state_tracker/st_manager.c \
 	state_tracker/st_mesa_to_tgsi.c \
diff --git a/src/mesa/sparc/glapi_sparc.S b/src/mesa/sparc/glapi_sparc.S
index 478adc6520d..e9f887b78f2 100644
--- a/src/mesa/sparc/glapi_sparc.S
+++ b/src/mesa/sparc/glapi_sparc.S
@@ -627,6 +627,8 @@ gl_dispatch_functions_start:
 	GL_STUB(glUniformMatrix3x4fv, _gloffset_UniformMatrix3x4fv)
 	GL_STUB(glUniformMatrix4x2fv, _gloffset_UniformMatrix4x2fv)
 	GL_STUB(glUniformMatrix4x3fv, _gloffset_UniformMatrix4x3fv)
+	GL_STUB(glDrawArraysInstanced, _gloffset_DrawArraysInstanced)
+	GL_STUB(glDrawElementsInstanced, _gloffset_DrawElementsInstanced)
 	GL_STUB(glLoadTransposeMatrixdARB, _gloffset_LoadTransposeMatrixdARB)
 	GL_STUB(glLoadTransposeMatrixfARB, _gloffset_LoadTransposeMatrixfARB)
 	GL_STUB(glMultTransposeMatrixdARB, _gloffset_MultTransposeMatrixdARB)
@@ -775,22 +777,22 @@ gl_dispatch_functions_start:
 	GL_STUB(glDrawRangeElementsBaseVertex, _gloffset_DrawRangeElementsBaseVertex)
 	GL_STUB(glMultiDrawElementsBaseVertex, _gloffset_MultiDrawElementsBaseVertex)
 	GL_STUB(glPolygonOffsetEXT, _gloffset_PolygonOffsetEXT)
-	GL_STUB(gl_dispatch_stub_578, _gloffset_GetPixelTexGenParameterfvSGIS)
-	HIDDEN(gl_dispatch_stub_578)
-	GL_STUB(gl_dispatch_stub_579, _gloffset_GetPixelTexGenParameterivSGIS)
-	HIDDEN(gl_dispatch_stub_579)
-	GL_STUB(gl_dispatch_stub_580, _gloffset_PixelTexGenParameterfSGIS)
+	GL_STUB(gl_dispatch_stub_580, _gloffset_GetPixelTexGenParameterfvSGIS)
 	HIDDEN(gl_dispatch_stub_580)
-	GL_STUB(gl_dispatch_stub_581, _gloffset_PixelTexGenParameterfvSGIS)
+	GL_STUB(gl_dispatch_stub_581, _gloffset_GetPixelTexGenParameterivSGIS)
 	HIDDEN(gl_dispatch_stub_581)
-	GL_STUB(gl_dispatch_stub_582, _gloffset_PixelTexGenParameteriSGIS)
+	GL_STUB(gl_dispatch_stub_582, _gloffset_PixelTexGenParameterfSGIS)
 	HIDDEN(gl_dispatch_stub_582)
-	GL_STUB(gl_dispatch_stub_583, _gloffset_PixelTexGenParameterivSGIS)
+	GL_STUB(gl_dispatch_stub_583, _gloffset_PixelTexGenParameterfvSGIS)
 	HIDDEN(gl_dispatch_stub_583)
-	GL_STUB(gl_dispatch_stub_584, _gloffset_SampleMaskSGIS)
+	GL_STUB(gl_dispatch_stub_584, _gloffset_PixelTexGenParameteriSGIS)
 	HIDDEN(gl_dispatch_stub_584)
-	GL_STUB(gl_dispatch_stub_585, _gloffset_SamplePatternSGIS)
+	GL_STUB(gl_dispatch_stub_585, _gloffset_PixelTexGenParameterivSGIS)
 	HIDDEN(gl_dispatch_stub_585)
+	GL_STUB(gl_dispatch_stub_586, _gloffset_SampleMaskSGIS)
+	HIDDEN(gl_dispatch_stub_586)
+	GL_STUB(gl_dispatch_stub_587, _gloffset_SamplePatternSGIS)
+	HIDDEN(gl_dispatch_stub_587)
 	GL_STUB(glColorPointerEXT, _gloffset_ColorPointerEXT)
 	GL_STUB(glEdgeFlagPointerEXT, _gloffset_EdgeFlagPointerEXT)
 	GL_STUB(glIndexPointerEXT, _gloffset_IndexPointerEXT)
@@ -801,10 +803,10 @@ gl_dispatch_functions_start:
 	GL_STUB(glPointParameterfvEXT, _gloffset_PointParameterfvEXT)
 	GL_STUB(glLockArraysEXT, _gloffset_LockArraysEXT)
 	GL_STUB(glUnlockArraysEXT, _gloffset_UnlockArraysEXT)
-	GL_STUB(gl_dispatch_stub_596, _gloffset_CullParameterdvEXT)
-	HIDDEN(gl_dispatch_stub_596)
-	GL_STUB(gl_dispatch_stub_597, _gloffset_CullParameterfvEXT)
-	HIDDEN(gl_dispatch_stub_597)
+	GL_STUB(gl_dispatch_stub_598, _gloffset_CullParameterdvEXT)
+	HIDDEN(gl_dispatch_stub_598)
+	GL_STUB(gl_dispatch_stub_599, _gloffset_CullParameterfvEXT)
+	HIDDEN(gl_dispatch_stub_599)
 	GL_STUB(glSecondaryColor3bEXT, _gloffset_SecondaryColor3bEXT)
 	GL_STUB(glSecondaryColor3bvEXT, _gloffset_SecondaryColor3bvEXT)
 	GL_STUB(glSecondaryColor3dEXT, _gloffset_SecondaryColor3dEXT)
@@ -829,8 +831,8 @@ gl_dispatch_functions_start:
 	GL_STUB(glFogCoorddvEXT, _gloffset_FogCoorddvEXT)
 	GL_STUB(glFogCoordfEXT, _gloffset_FogCoordfEXT)
 	GL_STUB(glFogCoordfvEXT, _gloffset_FogCoordfvEXT)
-	GL_STUB(gl_dispatch_stub_622, _gloffset_PixelTexGenSGIX)
-	HIDDEN(gl_dispatch_stub_622)
+	GL_STUB(gl_dispatch_stub_624, _gloffset_PixelTexGenSGIX)
+	HIDDEN(gl_dispatch_stub_624)
 	GL_STUB(glBlendFuncSeparateEXT, _gloffset_BlendFuncSeparateEXT)
 	GL_STUB(glFlushVertexArrayRangeNV, _gloffset_FlushVertexArrayRangeNV)
 	GL_STUB(glVertexArrayRangeNV, _gloffset_VertexArrayRangeNV)
@@ -872,24 +874,24 @@ gl_dispatch_functions_start:
 	GL_STUB(glWindowPos4ivMESA, _gloffset_WindowPos4ivMESA)
 	GL_STUB(glWindowPos4sMESA, _gloffset_WindowPos4sMESA)
 	GL_STUB(glWindowPos4svMESA, _gloffset_WindowPos4svMESA)
-	GL_STUB(gl_dispatch_stub_664, _gloffset_MultiModeDrawArraysIBM)
-	HIDDEN(gl_dispatch_stub_664)
-	GL_STUB(gl_dispatch_stub_665, _gloffset_MultiModeDrawElementsIBM)
-	HIDDEN(gl_dispatch_stub_665)
-	GL_STUB(gl_dispatch_stub_666, _gloffset_DeleteFencesNV)
+	GL_STUB(gl_dispatch_stub_666, _gloffset_MultiModeDrawArraysIBM)
 	HIDDEN(gl_dispatch_stub_666)
-	GL_STUB(gl_dispatch_stub_667, _gloffset_FinishFenceNV)
+	GL_STUB(gl_dispatch_stub_667, _gloffset_MultiModeDrawElementsIBM)
 	HIDDEN(gl_dispatch_stub_667)
-	GL_STUB(gl_dispatch_stub_668, _gloffset_GenFencesNV)
+	GL_STUB(gl_dispatch_stub_668, _gloffset_DeleteFencesNV)
 	HIDDEN(gl_dispatch_stub_668)
-	GL_STUB(gl_dispatch_stub_669, _gloffset_GetFenceivNV)
+	GL_STUB(gl_dispatch_stub_669, _gloffset_FinishFenceNV)
 	HIDDEN(gl_dispatch_stub_669)
-	GL_STUB(gl_dispatch_stub_670, _gloffset_IsFenceNV)
+	GL_STUB(gl_dispatch_stub_670, _gloffset_GenFencesNV)
 	HIDDEN(gl_dispatch_stub_670)
-	GL_STUB(gl_dispatch_stub_671, _gloffset_SetFenceNV)
+	GL_STUB(gl_dispatch_stub_671, _gloffset_GetFenceivNV)
 	HIDDEN(gl_dispatch_stub_671)
-	GL_STUB(gl_dispatch_stub_672, _gloffset_TestFenceNV)
+	GL_STUB(gl_dispatch_stub_672, _gloffset_IsFenceNV)
 	HIDDEN(gl_dispatch_stub_672)
+	GL_STUB(gl_dispatch_stub_673, _gloffset_SetFenceNV)
+	HIDDEN(gl_dispatch_stub_673)
+	GL_STUB(gl_dispatch_stub_674, _gloffset_TestFenceNV)
+	HIDDEN(gl_dispatch_stub_674)
 	GL_STUB(glAreProgramsResidentNV, _gloffset_AreProgramsResidentNV)
 	GL_STUB(glBindProgramNV, _gloffset_BindProgramNV)
 	GL_STUB(glDeleteProgramsNV, _gloffset_DeleteProgramsNV)
@@ -970,26 +972,26 @@ gl_dispatch_functions_start:
 	GL_STUB(glSetFragmentShaderConstantATI, _gloffset_SetFragmentShaderConstantATI)
 	GL_STUB(glPointParameteriNV, _gloffset_PointParameteriNV)
 	GL_STUB(glPointParameterivNV, _gloffset_PointParameterivNV)
-	GL_STUB(gl_dispatch_stub_753, _gloffset_ActiveStencilFaceEXT)
-	HIDDEN(gl_dispatch_stub_753)
-	GL_STUB(gl_dispatch_stub_754, _gloffset_BindVertexArrayAPPLE)
-	HIDDEN(gl_dispatch_stub_754)
-	GL_STUB(gl_dispatch_stub_755, _gloffset_DeleteVertexArraysAPPLE)
+	GL_STUB(gl_dispatch_stub_755, _gloffset_ActiveStencilFaceEXT)
 	HIDDEN(gl_dispatch_stub_755)
-	GL_STUB(gl_dispatch_stub_756, _gloffset_GenVertexArraysAPPLE)
+	GL_STUB(gl_dispatch_stub_756, _gloffset_BindVertexArrayAPPLE)
 	HIDDEN(gl_dispatch_stub_756)
-	GL_STUB(gl_dispatch_stub_757, _gloffset_IsVertexArrayAPPLE)
+	GL_STUB(gl_dispatch_stub_757, _gloffset_DeleteVertexArraysAPPLE)
 	HIDDEN(gl_dispatch_stub_757)
+	GL_STUB(gl_dispatch_stub_758, _gloffset_GenVertexArraysAPPLE)
+	HIDDEN(gl_dispatch_stub_758)
+	GL_STUB(gl_dispatch_stub_759, _gloffset_IsVertexArrayAPPLE)
+	HIDDEN(gl_dispatch_stub_759)
 	GL_STUB(glGetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV)
 	GL_STUB(glGetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV)
 	GL_STUB(glProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV)
 	GL_STUB(glProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV)
 	GL_STUB(glProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV)
 	GL_STUB(glProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV)
-	GL_STUB(gl_dispatch_stub_764, _gloffset_DepthBoundsEXT)
-	HIDDEN(gl_dispatch_stub_764)
-	GL_STUB(gl_dispatch_stub_765, _gloffset_BlendEquationSeparateEXT)
-	HIDDEN(gl_dispatch_stub_765)
+	GL_STUB(gl_dispatch_stub_766, _gloffset_DepthBoundsEXT)
+	HIDDEN(gl_dispatch_stub_766)
+	GL_STUB(gl_dispatch_stub_767, _gloffset_BlendEquationSeparateEXT)
+	HIDDEN(gl_dispatch_stub_767)
 	GL_STUB(glBindFramebufferEXT, _gloffset_BindFramebufferEXT)
 	GL_STUB(glBindRenderbufferEXT, _gloffset_BindRenderbufferEXT)
 	GL_STUB(glCheckFramebufferStatusEXT, _gloffset_CheckFramebufferStatusEXT)
@@ -1007,12 +1009,12 @@ gl_dispatch_functions_start:
 	GL_STUB(glIsFramebufferEXT, _gloffset_IsFramebufferEXT)
 	GL_STUB(glIsRenderbufferEXT, _gloffset_IsRenderbufferEXT)
 	GL_STUB(glRenderbufferStorageEXT, _gloffset_RenderbufferStorageEXT)
-	GL_STUB(gl_dispatch_stub_783, _gloffset_BlitFramebufferEXT)
-	HIDDEN(gl_dispatch_stub_783)
-	GL_STUB(gl_dispatch_stub_784, _gloffset_BufferParameteriAPPLE)
-	HIDDEN(gl_dispatch_stub_784)
-	GL_STUB(gl_dispatch_stub_785, _gloffset_FlushMappedBufferRangeAPPLE)
+	GL_STUB(gl_dispatch_stub_785, _gloffset_BlitFramebufferEXT)
 	HIDDEN(gl_dispatch_stub_785)
+	GL_STUB(gl_dispatch_stub_786, _gloffset_BufferParameteriAPPLE)
+	HIDDEN(gl_dispatch_stub_786)
+	GL_STUB(gl_dispatch_stub_787, _gloffset_FlushMappedBufferRangeAPPLE)
+	HIDDEN(gl_dispatch_stub_787)
 	GL_STUB(glFramebufferTextureLayerEXT, _gloffset_FramebufferTextureLayerEXT)
 	GL_STUB(glColorMaskIndexedEXT, _gloffset_ColorMaskIndexedEXT)
 	GL_STUB(glDisableIndexedEXT, _gloffset_DisableIndexedEXT)
@@ -1022,24 +1024,31 @@ gl_dispatch_functions_start:
 	GL_STUB(glIsEnabledIndexedEXT, _gloffset_IsEnabledIndexedEXT)
 	GL_STUB(glBeginConditionalRenderNV, _gloffset_BeginConditionalRenderNV)
 	GL_STUB(glEndConditionalRenderNV, _gloffset_EndConditionalRenderNV)
+	GL_STUB(glBeginTransformFeedbackEXT, _gloffset_BeginTransformFeedbackEXT)
+	GL_STUB(glBindBufferBaseEXT, _gloffset_BindBufferBaseEXT)
+	GL_STUB(glBindBufferOffsetEXT, _gloffset_BindBufferOffsetEXT)
+	GL_STUB(glBindBufferRangeEXT, _gloffset_BindBufferRangeEXT)
+	GL_STUB(glEndTransformFeedbackEXT, _gloffset_EndTransformFeedbackEXT)
+	GL_STUB(glGetTransformFeedbackVaryingEXT, _gloffset_GetTransformFeedbackVaryingEXT)
+	GL_STUB(glTransformFeedbackVaryingsEXT, _gloffset_TransformFeedbackVaryingsEXT)
 	GL_STUB(glProvokingVertexEXT, _gloffset_ProvokingVertexEXT)
-	GL_STUB(gl_dispatch_stub_796, _gloffset_GetTexParameterPointervAPPLE)
-	HIDDEN(gl_dispatch_stub_796)
-	GL_STUB(gl_dispatch_stub_797, _gloffset_TextureRangeAPPLE)
-	HIDDEN(gl_dispatch_stub_797)
+	GL_STUB(gl_dispatch_stub_805, _gloffset_GetTexParameterPointervAPPLE)
+	HIDDEN(gl_dispatch_stub_805)
+	GL_STUB(gl_dispatch_stub_806, _gloffset_TextureRangeAPPLE)
+	HIDDEN(gl_dispatch_stub_806)
 	GL_STUB(glGetObjectParameterivAPPLE, _gloffset_GetObjectParameterivAPPLE)
 	GL_STUB(glObjectPurgeableAPPLE, _gloffset_ObjectPurgeableAPPLE)
 	GL_STUB(glObjectUnpurgeableAPPLE, _gloffset_ObjectUnpurgeableAPPLE)
-	GL_STUB(gl_dispatch_stub_801, _gloffset_StencilFuncSeparateATI)
-	HIDDEN(gl_dispatch_stub_801)
-	GL_STUB(gl_dispatch_stub_802, _gloffset_ProgramEnvParameters4fvEXT)
-	HIDDEN(gl_dispatch_stub_802)
-	GL_STUB(gl_dispatch_stub_803, _gloffset_ProgramLocalParameters4fvEXT)
-	HIDDEN(gl_dispatch_stub_803)
-	GL_STUB(gl_dispatch_stub_804, _gloffset_GetQueryObjecti64vEXT)
-	HIDDEN(gl_dispatch_stub_804)
-	GL_STUB(gl_dispatch_stub_805, _gloffset_GetQueryObjectui64vEXT)
-	HIDDEN(gl_dispatch_stub_805)
+	GL_STUB(gl_dispatch_stub_810, _gloffset_StencilFuncSeparateATI)
+	HIDDEN(gl_dispatch_stub_810)
+	GL_STUB(gl_dispatch_stub_811, _gloffset_ProgramEnvParameters4fvEXT)
+	HIDDEN(gl_dispatch_stub_811)
+	GL_STUB(gl_dispatch_stub_812, _gloffset_ProgramLocalParameters4fvEXT)
+	HIDDEN(gl_dispatch_stub_812)
+	GL_STUB(gl_dispatch_stub_813, _gloffset_GetQueryObjecti64vEXT)
+	HIDDEN(gl_dispatch_stub_813)
+	GL_STUB(gl_dispatch_stub_814, _gloffset_GetQueryObjectui64vEXT)
+	HIDDEN(gl_dispatch_stub_814)
 	GL_STUB(glEGLImageTargetRenderbufferStorageOES, _gloffset_EGLImageTargetRenderbufferStorageOES)
 	GL_STUB(glEGLImageTargetTexture2DOES, _gloffset_EGLImageTargetTexture2DOES)
 	GL_STUB_ALIAS(glArrayElementEXT, glArrayElement)
@@ -1174,6 +1183,10 @@ gl_dispatch_functions_start:
 	GL_STUB_ALIAS(glMultiTexCoord4s, glMultiTexCoord4sARB)
 	GL_STUB_ALIAS(glMultiTexCoord4sv, glMultiTexCoord4svARB)
 	GL_STUB_ALIAS(glStencilOpSeparateATI, glStencilOpSeparate)
+	GL_STUB_ALIAS(glDrawArraysInstancedARB, glDrawArraysInstanced)
+	GL_STUB_ALIAS(glDrawArraysInstancedEXT, glDrawArraysInstanced)
+	GL_STUB_ALIAS(glDrawElementsInstancedARB, glDrawElementsInstanced)
+	GL_STUB_ALIAS(glDrawElementsInstancedEXT, glDrawElementsInstanced)
 	GL_STUB_ALIAS(glLoadTransposeMatrixd, glLoadTransposeMatrixdARB)
 	GL_STUB_ALIAS(glLoadTransposeMatrixf, glLoadTransposeMatrixfARB)
 	GL_STUB_ALIAS(glMultTransposeMatrixd, glMultTransposeMatrixdARB)
@@ -1376,6 +1389,12 @@ gl_dispatch_functions_start:
 	GL_STUB_ALIAS(glIsRenderbuffer, glIsRenderbufferEXT)
 	GL_STUB_ALIAS(glRenderbufferStorage, glRenderbufferStorageEXT)
 	GL_STUB_ALIAS(glFramebufferTextureLayer, glFramebufferTextureLayerEXT)
+	GL_STUB_ALIAS(glBeginTransformFeedback, glBeginTransformFeedbackEXT)
+	GL_STUB_ALIAS(glBindBufferBase, glBindBufferBaseEXT)
+	GL_STUB_ALIAS(glBindBufferRange, glBindBufferRangeEXT)
+	GL_STUB_ALIAS(glEndTransformFeedback, glEndTransformFeedbackEXT)
+	GL_STUB_ALIAS(glGetTransformFeedbackVarying, glGetTransformFeedbackVaryingEXT)
+	GL_STUB_ALIAS(glTransformFeedbackVaryings, glTransformFeedbackVaryingsEXT)
 	GL_STUB_ALIAS(glProvokingVertex, glProvokingVertexEXT)
 
 	.globl	gl_dispatch_functions_end
diff --git a/src/mesa/state_tracker/st_atom_constbuf.c b/src/mesa/state_tracker/st_atom_constbuf.c
index d975cd66f7d..5ac81bd4ee2 100644
--- a/src/mesa/state_tracker/st_atom_constbuf.c
+++ b/src/mesa/state_tracker/st_atom_constbuf.c
@@ -57,7 +57,7 @@ void st_upload_constants( struct st_context *st,
                           unsigned shader_type)
 {
    struct pipe_context *pipe = st->pipe;
-   struct pipe_buffer **cbuf = &st->state.constants[shader_type];
+   struct pipe_resource **cbuf = &st->state.constants[shader_type];
 
    assert(shader_type == PIPE_SHADER_VERTEX ||
           shader_type == PIPE_SHADER_FRAGMENT);
@@ -71,10 +71,10 @@ void st_upload_constants( struct st_context *st,
       /* We always need to get a new buffer, to keep the drivers simple and
        * avoid gratuitous rendering synchronization.
        */
-      pipe_buffer_reference(cbuf, NULL );
-      *cbuf = pipe_buffer_create(pipe->screen, 16,
-                                        PIPE_BUFFER_USAGE_CONSTANT,
-					paramBytes );
+      pipe_resource_reference(cbuf, NULL );
+      *cbuf = pipe_buffer_create(pipe->screen,
+				 PIPE_BIND_CONSTANT_BUFFER,
+				 paramBytes );
 
       if (ST_DEBUG & DEBUG_CONSTANTS) {
 	 debug_printf("%s(shader=%d, numParams=%d, stateFlags=0x%x)\n", 
diff --git a/src/mesa/state_tracker/st_atom_framebuffer.c b/src/mesa/state_tracker/st_atom_framebuffer.c
index 79ad70909a9..1cd55463379 100644
--- a/src/mesa/state_tracker/st_atom_framebuffer.c
+++ b/src/mesa/state_tracker/st_atom_framebuffer.c
@@ -34,7 +34,6 @@
 #include "st_context.h"
 #include "st_atom.h"
 #include "st_cb_fbo.h"
-#include "st_public.h"
 #include "st_texture.h"
 #include "pipe/p_context.h"
 #include "cso_cache/cso_context.h"
@@ -45,7 +44,7 @@
 
 /**
  * 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.
+ * didn't yank out the pipe_resource that we earlier created a surface for.
  * Check for that here and create a new surface if needed.
  */
 static void
@@ -53,29 +52,30 @@ update_renderbuffer_surface(struct st_context *st,
                             struct st_renderbuffer *strb)
 {
    struct pipe_screen *screen = st->pipe->screen;
-   struct pipe_texture *texture = strb->rtt->pt;
+   struct pipe_resource *resource = strb->rtt->pt;
    int rtt_width = strb->Base.Width;
    int rtt_height = strb->Base.Height;
 
    if (!strb->surface ||
-       strb->surface->texture != texture ||
+       strb->surface->texture != resource ||
        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 (u_minify(texture->width0, level) == rtt_width &&
-             u_minify(texture->height0, level) == rtt_height) {
+      for (level = 0; level <= resource->last_level; level++) {
+         if (u_minify(resource->width0, level) == rtt_width &&
+             u_minify(resource->height0, 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);
+						    resource,
+						    strb->rtt_face,
+						    level,
+						    strb->rtt_slice,
+						    PIPE_BIND_RENDER_TARGET |
+						    PIPE_BIND_BLIT_SOURCE |
+						    PIPE_BIND_BLIT_DESTINATION );
 #if 0
             printf("-- alloc new surface %d x %d into tex %p\n",
                    strb->surface->width, strb->surface->height,
@@ -154,23 +154,6 @@ update_framebuffer_state( struct st_context *st )
    }
 
    cso_set_framebuffer(st->cso_context, framebuffer);
-
-   if (fb->_ColorDrawBufferIndexes[0] == BUFFER_FRONT_LEFT) {
-      if (st->frontbuffer_status == FRONT_STATUS_COPY_OF_BACK) {
-         /* copy back color buffer to front color buffer */
-         struct st_framebuffer *stfb = (struct st_framebuffer *) fb;
-	 struct pipe_surface *surf_front, *surf_back;
-         (void) st_get_framebuffer_surface(stfb, ST_SURFACE_FRONT_LEFT, &surf_front);
-         (void) st_get_framebuffer_surface(stfb, ST_SURFACE_BACK_LEFT, &surf_back);
-
-         st->pipe->surface_copy(st->pipe,
-                                surf_front, 0, 0,  /* dest */
-                                surf_back, 0, 0,   /* src */
-                                fb->Width, fb->Height);
-      }
-      /* we're assuming we'll really draw to the front buffer */
-      st->frontbuffer_status = FRONT_STATUS_DIRTY;
-   }
 }
 
 
diff --git a/src/mesa/state_tracker/st_atom_pixeltransfer.c b/src/mesa/state_tracker/st_atom_pixeltransfer.c
index 03e33361448..4aac5bd97fe 100644
--- a/src/mesa/state_tracker/st_atom_pixeltransfer.c
+++ b/src/mesa/state_tracker/st_atom_pixeltransfer.c
@@ -112,21 +112,21 @@ make_state_key(GLcontext *ctx,  struct state_key *key)
 }
 
 
-static struct pipe_texture *
+static struct pipe_resource *
 create_color_map_texture(GLcontext *ctx)
 {
    struct pipe_context *pipe = ctx->st->pipe;
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
    enum pipe_format format;
    const uint texSize = 256; /* simple, and usually perfect */
 
    /* find an RGBA texture format */
    format = st_choose_format(pipe->screen, GL_RGBA,
-                             PIPE_TEXTURE_2D, PIPE_TEXTURE_USAGE_SAMPLER);
+                             PIPE_TEXTURE_2D, PIPE_BIND_SAMPLER_VIEW);
 
    /* create texture for color map/table */
    pt = st_texture_create(ctx->st, PIPE_TEXTURE_2D, format, 0,
-                          texSize, texSize, 1, PIPE_TEXTURE_USAGE_SAMPLER);
+                          texSize, texSize, 1, PIPE_BIND_SAMPLER_VIEW);
    return pt;
 }
 
@@ -135,7 +135,7 @@ create_color_map_texture(GLcontext *ctx)
  * Update the pixelmap texture with the contents of the R/G/B/A pixel maps.
  */
 static void
-load_color_map_texture(GLcontext *ctx, struct pipe_texture *pt)
+load_color_map_texture(GLcontext *ctx, struct pipe_resource *pt)
 {
    struct pipe_context *pipe = ctx->st->pipe;
    struct pipe_transfer *transfer;
@@ -150,7 +150,7 @@ load_color_map_texture(GLcontext *ctx, struct pipe_texture *pt)
    transfer = st_cond_flush_get_tex_transfer(st_context(ctx),
 					     pt, 0, 0, 0, PIPE_TRANSFER_WRITE,
 					     0, 0, texSize, texSize);
-   dest = (uint *) pipe->transfer_map(pipe, transfer);
+   dest = (uint *) pipe_transfer_map(pipe, transfer);
 
    /* Pack four 1D maps into a 2D texture:
     * R map is placed horizontally, indexed by S, in channel 0
@@ -171,8 +171,8 @@ load_color_map_texture(GLcontext *ctx, struct pipe_texture *pt)
       }
    }
 
-   pipe->transfer_unmap(pipe, transfer);
-   pipe->tex_transfer_destroy(pipe, transfer);
+   pipe_transfer_unmap(pipe, transfer);
+   pipe->transfer_destroy(pipe, transfer);
 }
 
 
diff --git a/src/mesa/state_tracker/st_cb_accum.c b/src/mesa/state_tracker/st_cb_accum.c
index 01aba3e3dd4..2732969d956 100644
--- a/src/mesa/state_tracker/st_cb_accum.c
+++ b/src/mesa/state_tracker/st_cb_accum.c
@@ -38,7 +38,6 @@
 #include "st_context.h"
 #include "st_cb_accum.h"
 #include "st_cb_fbo.h"
-#include "st_public.h"
 #include "st_texture.h"
 #include "st_inlines.h"
 #include "pipe/p_context.h"
@@ -137,7 +136,8 @@ accum_accum(struct st_context *st, GLfloat value,
    if (ST_DEBUG & DEBUG_FALLBACK)
       debug_printf("%s: fallback processing\n", __FUNCTION__);
 
-   color_trans = st_cond_flush_get_tex_transfer(st, color_strb->texture,
+   color_trans = st_cond_flush_get_tex_transfer(st,
+						color_strb->texture,
 						0, 0, 0,
 						PIPE_TRANSFER_READ, xpos, ypos,
 						width, height);
@@ -165,7 +165,7 @@ accum_accum(struct st_context *st, GLfloat value,
    }
 
    free(buf);
-   pipe->tex_transfer_destroy(pipe, color_trans);
+   pipe->transfer_destroy(pipe, color_trans);
 }
 
 
@@ -213,7 +213,7 @@ accum_load(struct st_context *st, GLfloat value,
    }
 
    free(buf);
-   pipe->tex_transfer_destroy(pipe, color_trans);
+   pipe->transfer_destroy(pipe, color_trans);
 }
 
 
@@ -280,7 +280,7 @@ accum_return(GLcontext *ctx, GLfloat value,
    pipe_put_tile_rgba(pipe, color_trans, 0, 0, width, height, buf);
 
    free(buf);
-   pipe->tex_transfer_destroy(pipe, color_trans);
+   pipe->transfer_destroy(pipe, color_trans);
 }
 
 
diff --git a/src/mesa/state_tracker/st_cb_bitmap.c b/src/mesa/state_tracker/st_cb_bitmap.c
index 9a0446bb710..074fc277110 100644
--- a/src/mesa/state_tracker/st_cb_bitmap.c
+++ b/src/mesa/state_tracker/st_cb_bitmap.c
@@ -92,7 +92,7 @@ struct bitmap_cache
    /** Bitmap's Z position */
    GLfloat zpos;
 
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct pipe_transfer *trans;
 
    GLboolean empty;
@@ -253,7 +253,7 @@ unpack_bitmap(struct st_context *st,
 /**
  * Create a texture which represents a bitmap image.
  */
-static struct pipe_texture *
+static struct pipe_resource *
 make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
                     const struct gl_pixelstore_attrib *unpack,
                     const GLubyte *bitmap)
@@ -261,7 +261,7 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
    struct pipe_context *pipe = ctx->st->pipe;
    struct pipe_transfer *transfer;
    ubyte *dest;
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
 
    /* PBO source... */
    bitmap = _mesa_map_pbo_source(ctx, unpack, bitmap);
@@ -274,7 +274,7 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
     */
    pt = st_texture_create(ctx->st, PIPE_TEXTURE_2D, ctx->st->bitmap.tex_format,
                           0, width, height, 1,
-                          PIPE_TEXTURE_USAGE_SAMPLER);
+                          PIPE_BIND_SAMPLER_VIEW);
    if (!pt) {
       _mesa_unmap_pbo_source(ctx, unpack);
       return NULL;
@@ -284,7 +284,7 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
 					   PIPE_TRANSFER_WRITE,
 					   0, 0, width, height);
 
-   dest = pipe->transfer_map(pipe, transfer);
+   dest = pipe_transfer_map(pipe, transfer);
 
    /* Put image into texture transfer */
    memset(dest, 0xff, height * transfer->stride);
@@ -294,8 +294,8 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
    _mesa_unmap_pbo_source(ctx, unpack);
 
    /* Release transfer */
-   pipe->transfer_unmap(pipe, transfer);
-   pipe->tex_transfer_destroy(pipe, transfer);
+   pipe_transfer_unmap(pipe, transfer);
+   pipe->transfer_destroy(pipe, transfer);
 
    return pt;
 }
@@ -334,13 +334,13 @@ setup_bitmap_vertex_data(struct st_context *st,
    GLuint i;
 
    if (st->bitmap.vbuf_slot >= max_slots) {
-      pipe_buffer_reference(&st->bitmap.vbuf, NULL);
+      pipe_resource_reference(&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,
+      st->bitmap.vbuf = pipe_buffer_create(pipe->screen, 
+                                           PIPE_BIND_VERTEX_BUFFER,
                                            max_slots * sizeof(st->bitmap.vertices));
    }
 
@@ -530,7 +530,7 @@ reset_cache(struct st_context *st)
    cache->ymax = -1000000;
 
    if (cache->trans) {
-      pipe->tex_transfer_destroy(pipe, cache->trans);
+      pipe->transfer_destroy(pipe, cache->trans);
       cache->trans = NULL;
    }
 
@@ -540,7 +540,8 @@ reset_cache(struct st_context *st)
    cache->texture = st_texture_create(st, PIPE_TEXTURE_2D,
                                       st->bitmap.tex_format, 0,
                                       BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,
-                                      1, PIPE_TEXTURE_USAGE_SAMPLER);
+                                      1,
+				      PIPE_BIND_SAMPLER_VIEW);
 }
 
 
@@ -580,7 +581,7 @@ create_cache_trans(struct st_context *st)
 					       PIPE_TRANSFER_WRITE, 0, 0,
 					       BITMAP_CACHE_WIDTH,
 					       BITMAP_CACHE_HEIGHT);
-   cache->buffer = pipe->transfer_map(pipe, cache->trans);
+   cache->buffer = pipe_transfer_map(pipe, cache->trans);
 
    /* init image to all 0xff */
    memset(cache->buffer, 0xff, cache->trans->stride * BITMAP_CACHE_HEIGHT);
@@ -614,10 +615,10 @@ st_flush_bitmap_cache(struct st_context *st)
          if (cache->trans) {
             if (0)
                print_cache(cache);
-            pipe->transfer_unmap(pipe, cache->trans);
+            pipe_transfer_unmap(pipe, cache->trans);
             cache->buffer = NULL;
 
-            pipe->tex_transfer_destroy(pipe, cache->trans);
+            pipe->transfer_destroy(pipe, cache->trans);
             cache->trans = NULL;
          }
 
@@ -636,7 +637,7 @@ st_flush_bitmap_cache(struct st_context *st)
       }
 
       /* release/free the texture */
-      pipe_texture_reference(&cache->texture, NULL);
+      pipe_resource_reference(&cache->texture, NULL);
 
       reset_cache(st);
    }
@@ -652,7 +653,7 @@ st_flush_bitmap( 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->bitmap.vbuf, NULL);
+   pipe_resource_reference(&st->bitmap.vbuf, NULL);
    st->bitmap.vbuf_slot = 0;
 }
 
@@ -732,7 +733,7 @@ st_Bitmap(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
           const struct gl_pixelstore_attrib *unpack, const GLubyte *bitmap )
 {
    struct st_context *st = ctx->st;
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
 
    if (width == 0 || height == 0)
       return;
@@ -768,7 +769,7 @@ st_Bitmap(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
       }
 
       /* release/free the texture */
-      pipe_texture_reference(&pt, NULL);
+      pipe_resource_reference(&pt, NULL);
    }
 }
 
@@ -805,15 +806,15 @@ st_init_bitmap(struct st_context *st)
 
    /* find a usable texture format */
    if (screen->is_format_supported(screen, PIPE_FORMAT_I8_UNORM, PIPE_TEXTURE_2D, 
-                                   PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
       st->bitmap.tex_format = PIPE_FORMAT_I8_UNORM;
    }
    else if (screen->is_format_supported(screen, PIPE_FORMAT_A8_UNORM, PIPE_TEXTURE_2D, 
-                                        PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                        PIPE_BIND_SAMPLER_VIEW, 0)) {
       st->bitmap.tex_format = PIPE_FORMAT_A8_UNORM;
    }
    else if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM, PIPE_TEXTURE_2D, 
-                                        PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                        PIPE_BIND_SAMPLER_VIEW, 0)) {
       st->bitmap.tex_format = PIPE_FORMAT_L8_UNORM;
    }
    else {
@@ -843,16 +844,16 @@ st_destroy_bitmap(struct st_context *st)
    }
 
    if (st->bitmap.vbuf) {
-      pipe_buffer_reference(&st->bitmap.vbuf, NULL);
+      pipe_resource_reference(&st->bitmap.vbuf, NULL);
       st->bitmap.vbuf = NULL;
    }
 
    if (cache) {
       if (cache->trans) {
-         pipe->transfer_unmap(pipe, cache->trans);
-         pipe->tex_transfer_destroy(pipe, cache->trans);
+         pipe_transfer_unmap(pipe, cache->trans);
+         pipe->transfer_destroy(pipe, cache->trans);
       }
-      pipe_texture_reference(&st->bitmap.cache->texture, NULL);
+      pipe_resource_reference(&st->bitmap.cache->texture, NULL);
       free(st->bitmap.cache);
       st->bitmap.cache = NULL;
    }
diff --git a/src/mesa/state_tracker/st_cb_blit.c b/src/mesa/state_tracker/st_cb_blit.c
index 06b0a18fd22..0498080ccfc 100644
--- a/src/mesa/state_tracker/st_cb_blit.c
+++ b/src/mesa/state_tracker/st_cb_blit.c
@@ -128,7 +128,7 @@ st_BlitFramebuffer(GLcontext *ctx,
                                            srcAtt->CubeMapFace,
                                            srcAtt->TextureLevel,
                                            srcAtt->Zoffset,
-                                           PIPE_BUFFER_USAGE_GPU_READ);
+                                           PIPE_BIND_BLIT_SOURCE);
          if(!srcSurf)
             return;
 
diff --git a/src/mesa/state_tracker/st_cb_bufferobjects.c b/src/mesa/state_tracker/st_cb_bufferobjects.c
index b55a085cc7c..f24145844b9 100644
--- a/src/mesa/state_tracker/st_cb_bufferobjects.c
+++ b/src/mesa/state_tracker/st_cb_bufferobjects.c
@@ -76,9 +76,10 @@ st_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj)
    struct st_buffer_object *st_obj = st_buffer_object(obj);
 
    assert(obj->RefCount == 0);
+   assert(st_obj->transfer == NULL);
 
    if (st_obj->buffer) 
-      pipe_buffer_reference(&st_obj->buffer, NULL);
+      pipe_resource_reference(&st_obj->buffer, NULL);
 
    free(st_obj);
 }
@@ -116,8 +117,15 @@ st_bufferobj_subdata(GLcontext *ctx,
    if (!data)
       return;
 
-   st_cond_flush_pipe_buffer_write(st_context(ctx), st_obj->buffer,
-				   offset, size, data);
+   /* Now that transfers are per-context, we don't have to figure out
+    * flushing here.  Usually drivers won't need to flush in this case
+    * even if the buffer is currently referenced by hardware - they
+    * just queue the upload as dma rather than mapping the underlying
+    * buffer directly.
+    */
+   pipe_buffer_write(st_context(ctx)->pipe,
+		     st_obj->buffer,
+		     offset, size, data);
 }
 
 
@@ -141,8 +149,8 @@ st_bufferobj_get_subdata(GLcontext *ctx,
    if (!size)
       return;
 
-   st_cond_flush_pipe_buffer_read(st_context(ctx), st_obj->buffer,
-				  offset, size, data);
+   pipe_buffer_read(st_context(ctx)->pipe, st_obj->buffer,
+                    offset, size, data);
 }
 
 
@@ -172,22 +180,24 @@ st_bufferobj_data(GLcontext *ctx,
    switch(target) {
    case GL_PIXEL_PACK_BUFFER_ARB:
    case GL_PIXEL_UNPACK_BUFFER_ARB:
-      buffer_usage = PIPE_BUFFER_USAGE_PIXEL;
+      buffer_usage = (PIPE_BIND_RENDER_TARGET |
+		      PIPE_BIND_BLIT_SOURCE |
+		      PIPE_BIND_BLIT_DESTINATION);
       break;
    case GL_ARRAY_BUFFER_ARB:
-      buffer_usage = PIPE_BUFFER_USAGE_VERTEX;
+      buffer_usage = PIPE_BIND_VERTEX_BUFFER;
       break;
    case GL_ELEMENT_ARRAY_BUFFER_ARB:
-      buffer_usage = PIPE_BUFFER_USAGE_INDEX;
+      buffer_usage = PIPE_BIND_INDEX_BUFFER;
       break;
    default:
       buffer_usage = 0;
    }
 
-   pipe_buffer_reference( &st_obj->buffer, NULL );
+   pipe_resource_reference( &st_obj->buffer, NULL );
 
    if (size != 0) {
-      st_obj->buffer = pipe_buffer_create(pipe->screen, 32, buffer_usage, size);
+      st_obj->buffer = pipe_buffer_create(pipe->screen, buffer_usage, size);
 
       if (!st_obj->buffer) {
          return GL_FALSE;
@@ -215,21 +225,22 @@ st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access,
 
    switch (access) {
    case GL_WRITE_ONLY:
-      flags = PIPE_BUFFER_USAGE_CPU_WRITE;
+      flags = PIPE_TRANSFER_WRITE;
       break;
    case GL_READ_ONLY:
-      flags = PIPE_BUFFER_USAGE_CPU_READ;
+      flags = PIPE_TRANSFER_READ;
       break;
    case GL_READ_WRITE:
-      /* fall-through */
    default:
-      flags = PIPE_BUFFER_USAGE_CPU_READ | PIPE_BUFFER_USAGE_CPU_WRITE;
+      flags = PIPE_TRANSFER_READ_WRITE;
       break;      
    }
 
-   obj->Pointer = st_cond_flush_pipe_buffer_map(st_context(ctx),
-						st_obj->buffer,
-						flags);
+   obj->Pointer = pipe_buffer_map(st_context(ctx)->pipe,
+                                  st_obj->buffer,
+                                  flags,
+                                  &st_obj->transfer);
+
    if (obj->Pointer) {
       obj->Offset = 0;
       obj->Length = obj->Size;
@@ -255,25 +266,25 @@ st_bufferobj_map_range(GLcontext *ctx, GLenum target,
 {
    struct pipe_context *pipe = st_context(ctx)->pipe;
    struct st_buffer_object *st_obj = st_buffer_object(obj);
-   uint flags = 0x0;
+   enum pipe_transfer_usage flags = 0x0;
 
    if (access & GL_MAP_WRITE_BIT)
-      flags |= PIPE_BUFFER_USAGE_CPU_WRITE;
+      flags |= PIPE_TRANSFER_WRITE;
 
    if (access & GL_MAP_READ_BIT)
-      flags |= PIPE_BUFFER_USAGE_CPU_READ;
+      flags |= PIPE_TRANSFER_READ;
 
    if (access & GL_MAP_FLUSH_EXPLICIT_BIT)
-      flags |= PIPE_BUFFER_USAGE_FLUSH_EXPLICIT;
+      flags |= PIPE_TRANSFER_FLUSH_EXPLICIT;
    
    if (access & GL_MAP_UNSYNCHRONIZED_BIT)
-      flags |= PIPE_BUFFER_USAGE_UNSYNCHRONIZED;
+      flags |= PIPE_TRANSFER_UNSYNCHRONIZED;
 
    /* ... other flags ...
     */
 
    if (access & MESA_MAP_NOWAIT_BIT)
-      flags |= PIPE_BUFFER_USAGE_DONTBLOCK;
+      flags |= PIPE_TRANSFER_DONTBLOCK;
 
    assert(offset >= 0);
    assert(length >= 0);
@@ -288,7 +299,11 @@ st_bufferobj_map_range(GLcontext *ctx, GLenum target,
       obj->Pointer = &st_bufferobj_zero_length_range;
    }
    else {
-      obj->Pointer = pipe_buffer_map_range(pipe->screen, st_obj->buffer, offset, length, flags);
+      obj->Pointer = pipe_buffer_map_range(pipe, 
+                                           st_obj->buffer,
+                                           offset, length,
+                                           flags,
+                                           &st_obj->transfer);
       if (obj->Pointer) {
          obj->Pointer = (ubyte *) obj->Pointer + offset;
       }
@@ -316,11 +331,12 @@ st_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target,
    assert(offset >= 0);
    assert(length >= 0);
    assert(offset + length <= obj->Length);
+   assert(obj->Pointer);
    
    if (!length)
       return;
 
-   pipe_buffer_flush_mapped_range(pipe->screen, st_obj->buffer, 
+   pipe_buffer_flush_mapped_range(pipe, st_obj->transfer, 
                                   obj->Offset + offset, length);
 }
 
@@ -334,9 +350,10 @@ st_bufferobj_unmap(GLcontext *ctx, GLenum target, struct gl_buffer_object *obj)
    struct pipe_context *pipe = st_context(ctx)->pipe;
    struct st_buffer_object *st_obj = st_buffer_object(obj);
 
-   if(obj->Length)
-      pipe_buffer_unmap(pipe->screen, st_obj->buffer);
+   if (obj->Length)
+      pipe_buffer_unmap(pipe, st_obj->buffer, st_obj->transfer);
 
+   st_obj->transfer = NULL;
    obj->Pointer = NULL;
    obj->Offset = 0;
    obj->Length = 0;
@@ -357,6 +374,8 @@ st_copy_buffer_subdata(GLcontext *ctx,
    struct pipe_context *pipe = st_context(ctx)->pipe;
    struct st_buffer_object *srcObj = st_buffer_object(src);
    struct st_buffer_object *dstObj = st_buffer_object(dst);
+   struct pipe_transfer *src_transfer;
+   struct pipe_transfer *dst_transfer;
    ubyte *srcPtr, *dstPtr;
 
    if(!size)
@@ -366,21 +385,36 @@ st_copy_buffer_subdata(GLcontext *ctx,
    assert(!src->Pointer);
    assert(!dst->Pointer);
 
-   srcPtr = (ubyte *) pipe_buffer_map_range(pipe->screen,
+   srcPtr = (ubyte *) pipe_buffer_map_range(pipe,
                                             srcObj->buffer,
                                             readOffset, size,
-                                            PIPE_BUFFER_USAGE_CPU_READ);
+                                            PIPE_TRANSFER_READ,
+					    &src_transfer);
 
-   dstPtr = (ubyte *) pipe_buffer_map_range(pipe->screen,
+   dstPtr = (ubyte *) pipe_buffer_map_range(pipe,
                                             dstObj->buffer,
                                             writeOffset, size,
-                                            PIPE_BUFFER_USAGE_CPU_WRITE);
+                                            PIPE_TRANSFER_WRITE,
+					    &dst_transfer);
 
    if (srcPtr && dstPtr)
       memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);
 
-   pipe_buffer_unmap(pipe->screen, srcObj->buffer);
-   pipe_buffer_unmap(pipe->screen, dstObj->buffer);
+   pipe_buffer_unmap(pipe, srcObj->buffer, src_transfer);
+   pipe_buffer_unmap(pipe, dstObj->buffer, dst_transfer);
+}
+
+
+/* TODO: if buffer wasn't created with appropriate usage flags, need
+ * to recreate it now and copy contents -- or possibly create a
+ * gallium entrypoint to extend the usage flags and let the driver
+ * decide if a copy is necessary.
+ */
+void
+st_bufferobj_validate_usage(struct st_context *st,
+			    struct st_buffer_object *obj,
+			    unsigned usage)
+{
 }
 
 
diff --git a/src/mesa/state_tracker/st_cb_bufferobjects.h b/src/mesa/state_tracker/st_cb_bufferobjects.h
index fda6d05dd34..955673ceb66 100644
--- a/src/mesa/state_tracker/st_cb_bufferobjects.h
+++ b/src/mesa/state_tracker/st_cb_bufferobjects.h
@@ -30,7 +30,7 @@
 
 struct st_context;
 struct gl_buffer_object;
-struct pipe_buffer;
+struct pipe_resource;
 
 /**
  * State_tracker vertex/pixel buffer object, derived from Mesa's
@@ -39,7 +39,8 @@ struct pipe_buffer;
 struct st_buffer_object
 {
    struct gl_buffer_object Base;
-   struct pipe_buffer *buffer;  
+   struct pipe_resource *buffer;     /* GPU storage */
+   struct pipe_transfer *transfer; /* In-progress map information */
 };
 
 
diff --git a/src/mesa/state_tracker/st_cb_clear.c b/src/mesa/state_tracker/st_cb_clear.c
index 6007c767182..2f77aff7a6c 100644
--- a/src/mesa/state_tracker/st_cb_clear.c
+++ b/src/mesa/state_tracker/st_cb_clear.c
@@ -43,7 +43,6 @@
 #include "st_cb_clear.h"
 #include "st_cb_fbo.h"
 #include "st_program.h"
-#include "st_public.h"
 #include "st_inlines.h"
 
 #include "pipe/p_context.h"
@@ -99,7 +98,7 @@ st_destroy_clear(struct st_context *st)
       st->clear.vs = NULL;
    }
    if (st->clear.vbuf) {
-      pipe_buffer_reference(&st->clear.vbuf, NULL);
+      pipe_resource_reference(&st->clear.vbuf, NULL);
       st->clear.vbuf = NULL;
    }
 }
@@ -131,13 +130,13 @@ draw_quad(GLcontext *ctx,
    GLuint i;
 
    if (st->clear.vbuf_slot >= max_slots) {
-      pipe_buffer_reference(&st->clear.vbuf, NULL);
+      pipe_resource_reference(&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,
+      st->clear.vbuf = pipe_buffer_create(pipe->screen,
+                                          PIPE_BIND_VERTEX_BUFFER,
                                           max_slots * sizeof(st->clear.vertices));
    }
 
@@ -435,7 +434,7 @@ 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->clear.vbuf, NULL);
+   pipe_resource_reference(&st->clear.vbuf, NULL);
    st->clear.vbuf_slot = 0;
 }
  
diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c
index 85570541ef0..955e371398d 100644
--- a/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -249,13 +249,13 @@ make_passthrough_vertex_shader(struct st_context *st,
                ureg_DECL_output( ureg, TGSI_SEMANTIC_POSITION, 0 ),
                ureg_DECL_vs_input( ureg, 0 ));
       
-      /* MOV result.texcoord0, vertex.texcoord0; */
+      /* MOV result.texcoord0, vertex.attr[1]; */
       ureg_MOV(ureg, 
                ureg_DECL_output( ureg, TGSI_SEMANTIC_GENERIC, 0 ),
                ureg_DECL_vs_input( ureg, 1 ));
       
       if (passColor) {
-         /* MOV result.color0, vertex.color0; */
+         /* MOV result.color0, vertex.attr[2]; */
          ureg_MOV(ureg, 
                   ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, 0 ),
                   ureg_DECL_vs_input( ureg, 2 ));
@@ -296,13 +296,13 @@ base_format(GLenum format)
  * If width, height are not POT and the driver only handles POT textures,
  * allocate the next larger size of texture that is POT.
  */
-static struct pipe_texture *
+static struct pipe_resource *
 alloc_texture(struct st_context *st, GLsizei width, GLsizei height,
               enum pipe_format texFormat)
 {
    struct pipe_context *pipe = st->pipe;
    struct pipe_screen *screen = pipe->screen;
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
    int ptw, pth;
 
    ptw = width;
@@ -330,7 +330,7 @@ alloc_texture(struct st_context *st, GLsizei width, GLsizei height,
    }
 
    pt = st_texture_create(st, PIPE_TEXTURE_2D, texFormat, 0,
-                          ptw, pth, 1, PIPE_TEXTURE_USAGE_SAMPLER);
+                          ptw, pth, 1, PIPE_BIND_SAMPLER_VIEW);
 
    return pt;
 }
@@ -340,7 +340,7 @@ alloc_texture(struct st_context *st, GLsizei width, GLsizei height,
  * Make texture containing an image for glDrawPixels image.
  * If 'pixels' is NULL, leave the texture image data undefined.
  */
-static struct pipe_texture *
+static struct pipe_resource *
 make_texture(struct st_context *st,
 	     GLsizei width, GLsizei height, GLenum format, GLenum type,
 	     const struct gl_pixelstore_attrib *unpack,
@@ -349,7 +349,7 @@ make_texture(struct st_context *st,
    GLcontext *ctx = st->ctx;
    struct pipe_context *pipe = st->pipe;
    gl_format mformat;
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
    enum pipe_format pipeFormat;
    GLuint cpp;
    GLenum baseFormat;
@@ -389,7 +389,7 @@ make_texture(struct st_context *st,
 					      width, height);
 
       /* map texture transfer */
-      dest = pipe->transfer_map(pipe, transfer);
+      dest = pipe_transfer_map(pipe, transfer);
 
 
       /* Put image into texture transfer.
@@ -409,8 +409,8 @@ make_texture(struct st_context *st,
                                unpack);
 
       /* unmap */
-      pipe->transfer_unmap(pipe, transfer);
-      pipe->tex_transfer_destroy(pipe, transfer);
+      pipe_transfer_unmap(pipe, transfer);
+      pipe->transfer_destroy(pipe, transfer);
 
       assert(success);
 
@@ -451,7 +451,7 @@ draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
       const GLfloat sLeft = 0.0f, sRight = maxXcoord;
       const GLfloat tTop = invertTex ? maxYcoord : 0.0f;
       const GLfloat tBot = invertTex ? 0.0f : maxYcoord;
-      GLuint tex, i;
+      GLuint i;
 
       /* upper-left */
       verts[0][0][0] = clip_x0;    /* v[0].attr[0].x */
@@ -469,32 +469,31 @@ draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
       verts[3][0][0] = clip_x0;
       verts[3][0][1] = clip_y1;
 
-      tex = color ? 2 : 1;
-      verts[0][tex][0] = sLeft; /* v[0].attr[tex].s */
-      verts[0][tex][1] = tTop;  /* v[0].attr[tex].t */
-      verts[1][tex][0] = sRight;
-      verts[1][tex][1] = tTop;
-      verts[2][tex][0] = sRight;
-      verts[2][tex][1] = tBot;
-      verts[3][tex][0] = sLeft;
-      verts[3][tex][1] = tBot;
+      verts[0][1][0] = sLeft; /* v[0].attr[1].S */
+      verts[0][1][1] = tTop;  /* v[0].attr[1].T */
+      verts[1][1][0] = sRight;
+      verts[1][1][1] = tTop;
+      verts[2][1][0] = sRight;
+      verts[2][1][1] = tBot;
+      verts[3][1][0] = sLeft;
+      verts[3][1][1] = tBot;
 
       /* same for all verts: */
       if (color) {
          for (i = 0; i < 4; i++) {
-            verts[i][0][2] = z;   /*Z*/
-            verts[i][0][3] = 1.0f; /*W*/
-            verts[i][1][0] = color[0];
-            verts[i][1][1] = color[1];
-            verts[i][1][2] = color[2];
-            verts[i][1][3] = color[3];
-            verts[i][2][2] = 0.0f; /*R*/
-            verts[i][2][3] = 1.0f; /*Q*/
+            verts[i][0][2] = z;         /* v[i].attr[0].z */
+            verts[i][0][3] = 1.0f;      /* v[i].attr[0].w */
+            verts[i][2][0] = color[0];  /* v[i].attr[2].r */
+            verts[i][2][1] = color[1];  /* v[i].attr[2].g */
+            verts[i][2][2] = color[2];  /* v[i].attr[2].b */
+            verts[i][2][3] = color[3];  /* v[i].attr[2].a */
+            verts[i][1][2] = 0.0f;      /* v[i].attr[1].R */
+            verts[i][1][3] = 1.0f;      /* v[i].attr[1].Q */
          }
       }
       else {
          for (i = 0; i < 4; i++) {
-            verts[i][0][2] = z;   /*Z*/
+            verts[i][0][2] = z;    /*Z*/
             verts[i][0][3] = 1.0f; /*W*/
             verts[i][1][2] = 0.0f; /*R*/
             verts[i][1][3] = 1.0f; /*Q*/
@@ -503,10 +502,11 @@ draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
    }
 
    {
-      struct pipe_buffer *buf;
+      struct pipe_resource *buf;
 
       /* allocate/load buffer object with vertex data */
-      buf = pipe_buffer_create(pipe->screen, 32, PIPE_BUFFER_USAGE_VERTEX,
+      buf = pipe_buffer_create(pipe->screen,
+			       PIPE_BIND_VERTEX_BUFFER,
                                sizeof(verts));
       st_no_flush_pipe_buffer_write(st, buf, 0, sizeof(verts), verts);
 
@@ -514,7 +514,7 @@ draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
                               PIPE_PRIM_QUADS,
                               4,  /* verts */
                               3); /* attribs/vert */
-      pipe_buffer_reference(&buf, NULL);
+      pipe_resource_reference(&buf, NULL);
    }
 }
 
@@ -689,7 +689,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
 				       usage, x, y,
 				       width, height);
 
-   stmap = pipe->transfer_map(pipe, pt);
+   stmap = pipe_transfer_map(pipe, pt);
 
    pixels = _mesa_map_pbo_source(ctx, &clippedUnpack, pixels);
    assert(pixels);
@@ -734,7 +734,7 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
             }
 
             /* now pack the stencil (and Z) values in the dest format */
-            switch (pt->texture->format) {
+            switch (pt->resource->format) {
             case PIPE_FORMAT_S8_USCALED:
                {
                   ubyte *dest = stmap + spanY * pt->stride + spanX;
@@ -789,8 +789,8 @@ draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
    _mesa_unmap_pbo_source(ctx, &clippedUnpack);
 
    /* unmap the stencil buffer */
-   pipe->transfer_unmap(pipe, pt);
-   pipe->tex_transfer_destroy(pipe, pt);
+   pipe_transfer_unmap(pipe, pt);
+   pipe->transfer_destroy(pipe, pt);
 }
 
 
@@ -831,7 +831,7 @@ st_DrawPixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
 
    /* draw with textured quad */
    {
-      struct pipe_texture *pt
+      struct pipe_resource *pt
          = make_texture(st, width, height, format, type, unpack, pixels);
       if (pt) {
          struct pipe_sampler_view *sv = st_sampler_view_from_texture(st->pipe, pt);
@@ -845,7 +845,7 @@ st_DrawPixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
                                color, GL_FALSE);
             pipe_sampler_view_reference(&sv, NULL);
          }
-         pipe_texture_reference(&pt, NULL);
+         pipe_resource_reference(&pt, NULL);
       }
    }
 }
@@ -890,11 +890,11 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
 					   usage, dstx, dsty,
 					   width, height);
 
-   assert(util_format_get_blockwidth(ptDraw->texture->format) == 1);
-   assert(util_format_get_blockheight(ptDraw->texture->format) == 1);
+   assert(util_format_get_blockwidth(ptDraw->resource->format) == 1);
+   assert(util_format_get_blockheight(ptDraw->resource->format) == 1);
 
    /* map the stencil buffer */
-   drawMap = pipe->transfer_map(pipe, ptDraw);
+   drawMap = pipe_transfer_map(pipe, ptDraw);
 
    /* draw */
    /* XXX PixelZoom not handled yet */
@@ -912,7 +912,7 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
       dst = drawMap + y * ptDraw->stride;
       src = buffer + i * width;
 
-      switch (ptDraw->texture->format) {
+      switch (ptDraw->resource->format) {
       case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
          {
             uint *dst4 = (uint *) dst;
@@ -947,8 +947,8 @@ copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
    free(buffer);
 
    /* unmap the stencil buffer */
-   pipe->transfer_unmap(pipe, ptDraw);
-   pipe->tex_transfer_destroy(pipe, ptDraw);
+   pipe_transfer_unmap(pipe, ptDraw);
+   pipe->transfer_destroy(pipe, ptDraw);
 }
 
 
@@ -962,7 +962,7 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
    struct pipe_screen *screen = pipe->screen;
    struct st_renderbuffer *rbRead;
    void *driver_vp, *driver_fp;
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
    struct pipe_sampler_view *sv;
    GLfloat *color;
    enum pipe_format srcFormat, texFormat;
@@ -997,7 +997,7 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
    srcFormat = rbRead->texture->format;
 
    if (screen->is_format_supported(screen, srcFormat, PIPE_TEXTURE_2D, 
-                                   PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
       texFormat = srcFormat;
    }
    else {
@@ -1005,13 +1005,13 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
       if (type == GL_DEPTH) {
          texFormat = st_choose_format(screen, GL_DEPTH_COMPONENT,
                                       PIPE_TEXTURE_2D, 
-                                      PIPE_TEXTURE_USAGE_DEPTH_STENCIL);
+                                      PIPE_BIND_DEPTH_STENCIL);
          assert(texFormat != PIPE_FORMAT_NONE);
       }
       else {
          /* default color format */
          texFormat = st_choose_format(screen, GL_RGBA, PIPE_TEXTURE_2D, 
-                                      PIPE_TEXTURE_USAGE_SAMPLER);
+                                      PIPE_BIND_SAMPLER_VIEW);
          assert(texFormat != PIPE_FORMAT_NONE);
       }
    }
@@ -1043,7 +1043,7 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
 
    sv = st_sampler_view_from_texture(st->pipe, pt);
    if (!sv) {
-      pipe_texture_reference(&pt, NULL);
+      pipe_resource_reference(&pt, NULL);
       return;
    }
 
@@ -1053,10 +1053,10 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
       /* copy source framebuffer surface into mipmap/texture */
       struct pipe_surface *psRead = screen->get_tex_surface(screen,
                                        rbRead->texture, 0, 0, 0,
-                                       PIPE_BUFFER_USAGE_GPU_READ);
+                                       PIPE_BIND_BLIT_SOURCE);
       struct pipe_surface *psTex = screen->get_tex_surface(screen, pt, 0, 0, 0, 
-                                      PIPE_BUFFER_USAGE_GPU_WRITE );
-
+                                       PIPE_BIND_RENDER_TARGET |
+                                       PIPE_BIND_BLIT_DESTINATION);
       pipe->surface_copy(pipe,
                          psTex,                               /* dest surf */
                          pack.SkipPixels, pack.SkipRows,      /* dest pos */
@@ -1110,8 +1110,8 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
          free(buf);
       }
 
-      pipe->tex_transfer_destroy(pipe, ptRead);
-      pipe->tex_transfer_destroy(pipe, ptTex);
+      pipe->transfer_destroy(pipe, ptRead);
+      pipe->transfer_destroy(pipe, ptTex);
    }
 
    /* OK, the texture 'pt' contains the src image/pixels.  Now draw a
@@ -1124,7 +1124,7 @@ st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
                       driver_fp,
                       color, invertTex);
 
-   pipe_texture_reference(&pt, NULL);
+   pipe_resource_reference(&pt, NULL);
    pipe_sampler_view_reference(&sv, NULL);
 }
 
diff --git a/src/mesa/state_tracker/st_cb_eglimage.c b/src/mesa/state_tracker/st_cb_eglimage.c
new file mode 100644
index 00000000000..3c4fe32090b
--- /dev/null
+++ b/src/mesa/state_tracker/st_cb_eglimage.c
@@ -0,0 +1,161 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.9
+ *
+ * Copyright (C) 2010 LunarG Inc.
+ *
+ * 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, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ *
+ * Authors:
+ *    Chia-I Wu <olv@lunarg.com>
+ */
+
+#include "main/texobj.h"
+#include "main/texfetch.h"
+#include "main/teximage.h"
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "st_cb_eglimage.h"
+#include "st_cb_fbo.h"
+#include "st_texture.h"
+#include "st_format.h"
+#include "st_manager.h"
+
+#if FEATURE_OES_EGL_image
+
+/**
+ * Return the base format just like _mesa_base_fbo_format does.
+ */
+static GLenum
+st_pipe_format_to_base_format(enum pipe_format format)
+{
+   GLenum base_format;
+
+   if (util_format_is_depth_or_stencil(format)) {
+      if (util_format_is_depth_and_stencil(format)) {
+         base_format = GL_DEPTH_STENCIL;
+      }
+      else {
+         if (format == PIPE_FORMAT_S8_USCALED)
+            base_format = GL_STENCIL_INDEX;
+         else
+            base_format = GL_DEPTH_COMPONENT;
+      }
+   }
+   else {
+      /* is this enough? */
+      if (util_format_has_alpha(format))
+         base_format = GL_RGBA;
+      else
+         base_format = GL_RGB;
+   }
+
+   return base_format;
+}
+
+static void
+st_egl_image_target_renderbuffer_storage(GLcontext *ctx,
+					 struct gl_renderbuffer *rb,
+					 GLeglImageOES image_handle)
+{
+   struct st_context *st = ctx->st;
+   struct st_renderbuffer *strb = st_renderbuffer(rb);
+   struct pipe_surface *ps;
+   unsigned usage;
+
+   usage = PIPE_BIND_RENDER_TARGET | PIPE_BIND_BLIT_SOURCE | PIPE_BIND_BLIT_DESTINATION;
+   ps = st_manager_get_egl_image_surface(st, (void *) image_handle, usage);
+   if (ps) {
+      strb->Base.Width = ps->width;
+      strb->Base.Height = ps->height;
+      strb->Base.Format = st_pipe_format_to_mesa_format(ps->format);
+      strb->Base.DataType = st_format_datatype(ps->format);
+      strb->Base._BaseFormat = st_pipe_format_to_base_format(ps->format);
+      strb->Base.InternalFormat = strb->Base._BaseFormat;
+
+      pipe_surface_reference(&strb->surface, ps);
+      pipe_resource_reference(&strb->texture, ps->texture);
+
+      pipe_surface_reference(&ps, NULL);
+   }
+}
+
+static void
+st_bind_surface(GLcontext *ctx, GLenum target,
+                struct gl_texture_object *texObj,
+                struct gl_texture_image *texImage,
+                struct pipe_surface *ps)
+{
+   struct st_texture_object *stObj;
+   struct st_texture_image *stImage;
+   GLenum internalFormat;
+
+   /* map pipe format to base format */
+   if (util_format_get_component_bits(ps->format, UTIL_FORMAT_COLORSPACE_RGB, 3) > 0)
+      internalFormat = GL_RGBA;
+   else
+      internalFormat = GL_RGB;
+
+   stObj = st_texture_object(texObj);
+   stImage = st_texture_image(texImage);
+
+   /* switch to surface based */
+   if (!stObj->surface_based) {
+      _mesa_clear_texture_object(ctx, texObj);
+      stObj->surface_based = GL_TRUE;
+   }
+
+   _mesa_init_teximage_fields(ctx, target, texImage,
+                              ps->width, ps->height, 1, 0, internalFormat);
+   texImage->TexFormat = st_pipe_format_to_mesa_format(ps->format);
+   _mesa_set_fetch_functions(texImage, 2);
+
+   stObj->pipe = ctx->st->pipe;
+   /* FIXME create a non-default sampler view from the pipe_surface? */
+   pipe_resource_reference(&stImage->pt, ps->texture);
+
+   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
+}
+
+static void
+st_egl_image_target_texture_2d(GLcontext *ctx, GLenum target,
+			       struct gl_texture_object *texObj,
+			       struct gl_texture_image *texImage,
+			       GLeglImageOES image_handle)
+{
+   struct st_context *st = ctx->st;
+   struct pipe_surface *ps;
+   unsigned usage;
+
+   usage = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_BLIT_DESTINATION | PIPE_BIND_BLIT_SOURCE;
+   ps = st_manager_get_egl_image_surface(st, (void *) image_handle, usage);
+   if (ps) {
+      st_bind_surface(ctx, target, texObj, texImage, ps);
+      pipe_surface_reference(&ps, NULL);
+   }
+}
+
+void
+st_init_eglimage_functions(struct dd_function_table *functions)
+{
+   functions->EGLImageTargetTexture2D = st_egl_image_target_texture_2d;
+   functions->EGLImageTargetRenderbufferStorage = st_egl_image_target_renderbuffer_storage;
+}
+
+#endif /* FEATURE_OES_EGL_image */
diff --git a/src/mesa/state_tracker/st_cb_eglimage.h b/src/mesa/state_tracker/st_cb_eglimage.h
new file mode 100644
index 00000000000..d6953e99f69
--- /dev/null
+++ b/src/mesa/state_tracker/st_cb_eglimage.h
@@ -0,0 +1,49 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  7.9
+ *
+ * Copyright (C) 2010 LunarG Inc.
+ *
+ * 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, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ *
+ * Authors:
+ *    Chia-I Wu <olv@lunarg.com>
+ */
+
+#ifndef ST_CB_EGLIMAGE_H
+#define ST_CB_EGLIMAGE_H
+
+#include "main/mtypes.h"
+#include "main/dd.h"
+
+#if FEATURE_OES_EGL_image
+
+extern void
+st_init_eglimage_functions(struct dd_function_table *functions);
+
+#else
+
+static INLINE void
+st_init_eglimage_functions(struct dd_function_table *functions)
+{
+}
+
+#endif
+
+#endif /* ST_CB_EGLIMAGE_H */
diff --git a/src/mesa/state_tracker/st_cb_fbo.c b/src/mesa/state_tracker/st_cb_fbo.c
index 542ab38a50e..aec487b001b 100644
--- a/src/mesa/state_tracker/st_cb_fbo.c
+++ b/src/mesa/state_tracker/st_cb_fbo.c
@@ -45,8 +45,8 @@
 #include "pipe/p_screen.h"
 #include "st_context.h"
 #include "st_cb_fbo.h"
+#include "st_cb_flush.h"
 #include "st_format.h"
-#include "st_public.h"
 #include "st_texture.h"
 #include "st_manager.h"
 
@@ -96,13 +96,12 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
       return strb->data != NULL;
    }
    else {
-      struct pipe_texture template;
-      unsigned surface_usage;
+      struct pipe_resource template;
     
       /* Free the old surface and texture
        */
       pipe_surface_reference( &strb->surface, NULL );
-      pipe_texture_reference( &strb->texture, NULL );
+      pipe_resource_reference( &strb->texture, NULL );
       pipe_sampler_view_reference(&strb->sampler_view, NULL);
 
       /* Setup new texture template.
@@ -116,23 +115,14 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
       template.last_level = 0;
       template.nr_samples = rb->NumSamples;
       if (util_format_is_depth_or_stencil(format)) {
-         template.tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
+         template.bind = PIPE_BIND_DEPTH_STENCIL;
       }
       else {
-         template.tex_usage = (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
-                               PIPE_TEXTURE_USAGE_RENDER_TARGET);
+         template.bind = (PIPE_BIND_DISPLAY_TARGET |
+			  PIPE_BIND_RENDER_TARGET);
       }
 
-      /* Probably need dedicated flags for surface usage too: 
-       */
-      surface_usage = (PIPE_BUFFER_USAGE_GPU_READ |
-                       PIPE_BUFFER_USAGE_GPU_WRITE);
-#if 0
-                       PIPE_BUFFER_USAGE_CPU_READ |
-                       PIPE_BUFFER_USAGE_CPU_WRITE);
-#endif
-
-      strb->texture = screen->texture_create(screen, &template);
+      strb->texture = screen->resource_create(screen, &template);
 
       if (!strb->texture) 
          return FALSE;
@@ -140,7 +130,7 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
       strb->surface = screen->get_tex_surface(screen,
                                               strb->texture,
                                               0, 0, 0,
-                                              surface_usage);
+                                              template.bind);
       if (strb->surface) {
          assert(strb->surface->texture);
          assert(strb->surface->format);
@@ -162,7 +152,7 @@ st_renderbuffer_delete(struct gl_renderbuffer *rb)
    struct st_renderbuffer *strb = st_renderbuffer(rb);
    ASSERT(strb);
    pipe_surface_reference(&strb->surface, NULL);
-   pipe_texture_reference(&strb->texture, NULL);
+   pipe_resource_reference(&strb->texture, NULL);
    pipe_sampler_view_reference(&strb->sampler_view, NULL);
    free(strb->data);
    free(strb);
@@ -323,7 +313,7 @@ st_render_texture(GLcontext *ctx,
    struct pipe_screen *screen = ctx->st->pipe->screen;
    struct st_renderbuffer *strb;
    struct gl_renderbuffer *rb;
-   struct pipe_texture *pt = st_get_texobj_texture(att->Texture);
+   struct pipe_resource *pt = st_get_texobj_texture(att->Texture);
    struct st_texture_object *stObj;
    const struct gl_texture_image *texImage;
    GLint pt_level;
@@ -366,7 +356,7 @@ st_render_texture(GLcontext *ctx,
 
    /*printf("***** pipe texture %d x %d\n", pt->width0, pt->height0);*/
 
-   pipe_texture_reference( &strb->texture, pt );
+   pipe_resource_reference( &strb->texture, pt );
 
    pipe_surface_reference(&strb->surface, NULL);
 
@@ -380,8 +370,7 @@ st_render_texture(GLcontext *ctx,
                                            strb->rtt_face,
                                            strb->rtt_level,
                                            strb->rtt_slice,
-                                           PIPE_BUFFER_USAGE_GPU_READ |
-                                           PIPE_BUFFER_USAGE_GPU_WRITE);
+                                           PIPE_BIND_RENDER_TARGET);
 
    strb->format = pt->format;
 
@@ -479,20 +468,20 @@ st_validate_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb)
 
    if (!st_validate_attachment(screen,
 			       &fb->Attachment[BUFFER_DEPTH],
-			       PIPE_TEXTURE_USAGE_DEPTH_STENCIL)) {
+			       PIPE_BIND_DEPTH_STENCIL)) {
       fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
       return;
    }
    if (!st_validate_attachment(screen,
 			       &fb->Attachment[BUFFER_STENCIL],
-			       PIPE_TEXTURE_USAGE_DEPTH_STENCIL)) {
+			       PIPE_BIND_DEPTH_STENCIL)) {
       fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
       return;
    }
    for (i = 0; i < ctx->Const.MaxColorAttachments; i++) {
       if (!st_validate_attachment(screen,
 				  &fb->Attachment[BUFFER_COLOR0 + i],
-				  PIPE_TEXTURE_USAGE_RENDER_TARGET)) {
+				  PIPE_BIND_RENDER_TARGET)) {
 	 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
 	 return;
       }
@@ -501,111 +490,6 @@ st_validate_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb)
 
 
 /**
- * Copy back color buffer to front color buffer.
- */
-static void
-copy_back_to_front(struct st_context *st,
-                   struct gl_framebuffer *fb,
-                   gl_buffer_index frontIndex,
-                   gl_buffer_index backIndex)
-
-{
-   struct st_framebuffer *stfb = (struct st_framebuffer *) fb;
-   struct pipe_surface *surf_front, *surf_back;
-
-   (void) st_get_framebuffer_surface(stfb, frontIndex, &surf_front);
-   (void) st_get_framebuffer_surface(stfb, backIndex, &surf_back);
-
-   if (surf_front && surf_back) {
-      st->pipe->surface_copy(st->pipe,
-                             surf_front, 0, 0,  /* dest */
-                             surf_back, 0, 0,   /* src */
-                             fb->Width, fb->Height);
-   }
-}
-
-
-/**
- * Check if we're drawing into, or read from, a front color buffer.  If the
- * front buffer is missing, create it now.
- *
- * The back color buffer must exist since we'll use its format/samples info
- * for creating the front buffer.
- *
- * \param frontIndex  either BUFFER_FRONT_LEFT or BUFFER_FRONT_RIGHT
- * \param backIndex  either BUFFER_BACK_LEFT or BUFFER_BACK_RIGHT
- */
-static void
-check_create_front_buffer(GLcontext *ctx, struct gl_framebuffer *fb,
-                          gl_buffer_index frontIndex,
-                          gl_buffer_index backIndex)
-{
-   if (fb->Attachment[frontIndex].Renderbuffer == NULL) {
-      GLboolean create = GL_FALSE;
-
-      /* check if drawing to or reading from front buffer */
-      if (fb->_ColorReadBufferIndex == frontIndex) {
-         create = GL_TRUE;
-      }
-      else {
-         GLuint b;
-         for (b = 0; b < fb->_NumColorDrawBuffers; b++) {
-            if (fb->_ColorDrawBufferIndexes[b] == frontIndex) {
-               create = GL_TRUE;
-               break;
-            }
-         }
-      }
-
-      if (create) {
-         struct st_renderbuffer *back;
-         struct gl_renderbuffer *front;
-         enum pipe_format colorFormat;
-         uint samples;
-
-         if (0)
-            _mesa_debug(ctx, "Allocate new front buffer\n");
-
-         /* get back renderbuffer info */
-         back = st_renderbuffer(fb->Attachment[backIndex].Renderbuffer);
-         colorFormat = back->format;
-         samples = back->Base.NumSamples;
-
-         /* create front renderbuffer */
-         front = st_new_renderbuffer_fb(colorFormat, samples, FALSE);
-         _mesa_add_renderbuffer(fb, frontIndex, front);
-
-         /* alloc texture/surface for new front buffer */
-         front->AllocStorage(ctx, front, front->InternalFormat,
-                             fb->Width, fb->Height);
-
-         /* initialize the front color buffer contents by copying
-          * the back buffer.
-          */
-         copy_back_to_front(ctx->st, fb, frontIndex, backIndex);
-      }
-   }
-}
-
-
-/**
- * If front left/right color buffers are missing, create them now.
- */
-static void
-check_create_front_buffers(GLcontext *ctx, struct gl_framebuffer *fb)
-{
-   /* check if we need to create the front left buffer now */
-   check_create_front_buffer(ctx, fb, BUFFER_FRONT_LEFT, BUFFER_BACK_LEFT);
-
-   if (fb->Visual.stereoMode) {
-      check_create_front_buffer(ctx, fb, BUFFER_FRONT_RIGHT, BUFFER_BACK_RIGHT);
-   }
-
-   st_invalidate_state(ctx, _NEW_BUFFERS);
-}
-
-
-/**
  * Called via glDrawBuffer.
  */
 static void
@@ -622,8 +506,6 @@ st_DrawBuffers(GLcontext *ctx, GLsizei count, const GLenum *buffers)
       gl_buffer_index idx = fb->_ColorDrawBufferIndexes[i];
       st_manager_add_color_renderbuffer(ctx->st, fb, idx);
    }
-
-   check_create_front_buffers(ctx, ctx->DrawBuffer);
 }
 
 
@@ -639,7 +521,6 @@ st_ReadBuffer(GLcontext *ctx, GLenum buffer)
 
    /* add the renderbuffer on demand */
    st_manager_add_color_renderbuffer(ctx->st, fb, fb->_ColorReadBufferIndex);
-   check_create_front_buffers(ctx, fb);
 }
 
 
diff --git a/src/mesa/state_tracker/st_cb_fbo.h b/src/mesa/state_tracker/st_cb_fbo.h
index 7a45a608fe1..5f11a7cd8ab 100644
--- a/src/mesa/state_tracker/st_cb_fbo.h
+++ b/src/mesa/state_tracker/st_cb_fbo.h
@@ -37,7 +37,7 @@
 struct st_renderbuffer
 {
    struct gl_renderbuffer Base;
-   struct pipe_texture *texture;
+   struct pipe_resource *texture;
    struct pipe_surface *surface; /* temporary view into texture */
    struct pipe_sampler_view *sampler_view;
    enum pipe_format format;  /** preferred format, or PIPE_FORMAT_NONE */
@@ -54,7 +54,7 @@ struct st_renderbuffer
    int rtt_level, rtt_face, rtt_slice;
 
    /** Render to texture state */
-   struct pipe_texture *texture_save;
+   struct pipe_resource *texture_save;
    struct pipe_surface *surface_save;
    struct pipe_sampler_view *sampler_view_save;
 };
diff --git a/src/mesa/state_tracker/st_cb_flush.c b/src/mesa/state_tracker/st_cb_flush.c
index 30e7afcf2a3..415e8f3d2a2 100644
--- a/src/mesa/state_tracker/st_cb_flush.c
+++ b/src/mesa/state_tracker/st_cb_flush.c
@@ -39,7 +39,6 @@
 #include "st_cb_flush.h"
 #include "st_cb_clear.h"
 #include "st_cb_fbo.h"
-#include "st_public.h"
 #include "st_manager.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
@@ -52,15 +51,10 @@
 static INLINE GLboolean
 is_front_buffer_dirty(struct st_context *st)
 {
-   if (st->frontbuffer_status == FRONT_STATUS_DIRTY) {
-      return GL_TRUE;
-   }
-   else {
-      GLframebuffer *fb = st->ctx->DrawBuffer;
-      struct st_renderbuffer *strb
-         = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-      return strb && strb->defined;
-   }
+   GLframebuffer *fb = st->ctx->DrawBuffer;
+   struct st_renderbuffer *strb
+      = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
+   return strb && strb->defined;
 }
 
 
@@ -78,10 +72,6 @@ display_front_buffer(struct st_context *st)
       /* Hook for copying "fake" frontbuffer if necessary:
        */
       st_manager_flush_frontbuffer(st);
-
-      /*
-        st->frontbuffer_status = FRONT_STATUS_UNDEFINED;
-      */
    }
 }
 
diff --git a/src/mesa/state_tracker/st_cb_flush.h b/src/mesa/state_tracker/st_cb_flush.h
index c26f7792259..7fca0176a30 100644
--- a/src/mesa/state_tracker/st_cb_flush.h
+++ b/src/mesa/state_tracker/st_cb_flush.h
@@ -33,6 +33,13 @@
 extern void
 st_init_flush_functions(struct dd_function_table *functions);
 
+extern void
+st_flush(struct st_context *st, uint pipeFlushFlags,
+         struct pipe_fence_handle **fence);
+
+extern void
+st_finish(struct st_context *st);
+
 
 #endif /* ST_CB_FLUSH_H */
 
diff --git a/src/mesa/state_tracker/st_cb_readpixels.c b/src/mesa/state_tracker/st_cb_readpixels.c
index 10795ee9e4a..67c3b9adbb9 100644
--- a/src/mesa/state_tracker/st_cb_readpixels.c
+++ b/src/mesa/state_tracker/st_cb_readpixels.c
@@ -48,7 +48,6 @@
 #include "st_atom.h"
 #include "st_cb_readpixels.h"
 #include "st_cb_fbo.h"
-#include "st_public.h"
 #include "st_texture.h"
 #include "st_inlines.h"
 
@@ -82,7 +81,7 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
 				       width, height);
 
    /* map the stencil buffer */
-   stmap = pipe->transfer_map(pipe, pt);
+   stmap = pipe_transfer_map(pipe, pt);
 
    /* width should never be > MAX_WIDTH since we did clipping earlier */
    ASSERT(width <= MAX_WIDTH);
@@ -102,7 +101,7 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
       }
 
       /* get stencil (and Z) values */
-      switch (pt->texture->format) {
+      switch (pt->resource->format) {
       case PIPE_FORMAT_S8_USCALED:
          {
             const ubyte *src = stmap + srcY * pt->stride;
@@ -162,15 +161,14 @@ st_read_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
    }
 
    /* unmap the stencil buffer */
-   pipe->transfer_unmap(pipe, pt);
-   pipe->tex_transfer_destroy(pipe, pt);
+   pipe_transfer_unmap(pipe, pt);
+   pipe->transfer_destroy(pipe, pt);
 }
 
 
 /**
  * Return renderbuffer to use for reading color pixels for glRead/CopyPixel
  * commands.
- * Special care is needed for the front buffer.
  */
 struct st_renderbuffer *
 st_get_color_read_renderbuffer(GLcontext *ctx)
@@ -178,18 +176,6 @@ st_get_color_read_renderbuffer(GLcontext *ctx)
    struct gl_framebuffer *fb = ctx->ReadBuffer;
    struct st_renderbuffer *strb =
       st_renderbuffer(fb->_ColorReadBuffer);
-   struct st_renderbuffer *front = 
-      st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-
-   if (strb == front
-       && ctx->st->frontbuffer_status == FRONT_STATUS_COPY_OF_BACK) {
-      /* reading from front color buffer, which is a logical copy of the
-       * back color buffer.
-       */
-      struct st_renderbuffer *back = 
-         st_renderbuffer(fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer);
-      strb = back;
-   }
 
    return strb;
 }
@@ -253,9 +239,9 @@ st_fast_readpixels(GLcontext *ctx, struct st_renderbuffer *strb,
          return GL_FALSE;
       }
 
-      map = pipe->transfer_map(pipe, trans);
+      map = pipe_transfer_map(pipe, trans);
       if (!map) {
-         pipe->tex_transfer_destroy(pipe, trans);
+         pipe->transfer_destroy(pipe, trans);
          return GL_FALSE;
       }
 
@@ -317,8 +303,8 @@ st_fast_readpixels(GLcontext *ctx, struct st_renderbuffer *strb,
          ; /* nothing */
       }
 
-      pipe->transfer_unmap(pipe, trans);
-      pipe->tex_transfer_destroy(pipe, trans);
+      pipe_transfer_unmap(pipe, trans);
+      pipe->transfer_destroy(pipe, trans);
    }
 
    return GL_TRUE;
@@ -437,8 +423,8 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
       const GLint dstStride = _mesa_image_row_stride(&clippedPacking, width,
                                                      format, type);
 
-      if (trans->texture->format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
-          trans->texture->format == PIPE_FORMAT_Z24X8_UNORM) {
+      if (trans->resource->format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
+          trans->resource->format == PIPE_FORMAT_Z24X8_UNORM) {
          if (format == GL_DEPTH_COMPONENT) {
             for (i = 0; i < height; i++) {
                GLuint ztemp[MAX_WIDTH];
@@ -469,8 +455,8 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
             }
          }
       }
-      else if (trans->texture->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
-               trans->texture->format == PIPE_FORMAT_X8Z24_UNORM) {
+      else if (trans->resource->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
+               trans->resource->format == PIPE_FORMAT_X8Z24_UNORM) {
          if (format == GL_DEPTH_COMPONENT) {
             for (i = 0; i < height; i++) {
                GLuint ztemp[MAX_WIDTH];
@@ -496,7 +482,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
             }
          }
       }
-      else if (trans->texture->format == PIPE_FORMAT_Z16_UNORM) {
+      else if (trans->resource->format == PIPE_FORMAT_Z16_UNORM) {
          for (i = 0; i < height; i++) {
             GLushort ztemp[MAX_WIDTH];
             GLfloat zfloat[MAX_WIDTH];
@@ -511,7 +497,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
             dst += dstStride;
          }
       }
-      else if (trans->texture->format == PIPE_FORMAT_Z32_UNORM) {
+      else if (trans->resource->format == PIPE_FORMAT_Z32_UNORM) {
          for (i = 0; i < height; i++) {
             GLuint ztemp[MAX_WIDTH];
             GLfloat zfloat[MAX_WIDTH];
@@ -542,7 +528,7 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
       }
    }
 
-   pipe->tex_transfer_destroy(pipe, trans);
+   pipe->transfer_destroy(pipe, trans);
 
    _mesa_unmap_pbo_dest(ctx, &clippedPacking);
 }
diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c
index 390ada5489c..196bf1325fb 100644
--- a/src/mesa/state_tracker/st_cb_texture.c
+++ b/src/mesa/state_tracker/st_cb_texture.c
@@ -49,7 +49,6 @@
 #include "state_tracker/st_cb_fbo.h"
 #include "state_tracker/st_cb_texture.h"
 #include "state_tracker/st_format.h"
-#include "state_tracker/st_public.h"
 #include "state_tracker/st_texture.h"
 #include "state_tracker/st_gen_mipmap.h"
 #include "state_tracker/st_inlines.h"
@@ -123,7 +122,7 @@ st_DeleteTextureObject(GLcontext *ctx,
 {
    struct st_texture_object *stObj = st_texture_object(texObj);
    if (stObj->pt)
-      pipe_texture_reference(&stObj->pt, NULL);
+      pipe_resource_reference(&stObj->pt, NULL);
    if (stObj->sampler_view) {
       if (stObj->sampler_view->context != ctx->st->pipe) {
          /* Take "ownership" of this texture sampler view by setting
@@ -148,7 +147,7 @@ st_FreeTextureImageData(GLcontext * ctx, struct gl_texture_image *texImage)
    DBG("%s\n", __FUNCTION__);
 
    if (stImage->pt) {
-      pipe_texture_reference(&stImage->pt, NULL);
+      pipe_resource_reference(&stImage->pt, NULL);
    }
 
    if (texImage->Data) {
@@ -214,17 +213,17 @@ do_memcpy(void *dest, const void *src, size_t n)
 static GLuint
 default_usage(enum pipe_format fmt)
 {
-   GLuint usage = PIPE_TEXTURE_USAGE_SAMPLER;
+   GLuint usage = PIPE_BIND_SAMPLER_VIEW;
    if (util_format_is_depth_or_stencil(fmt))
-      usage |= PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
+      usage |= PIPE_BIND_DEPTH_STENCIL;
    else
-      usage |= PIPE_TEXTURE_USAGE_RENDER_TARGET;
+      usage |= PIPE_BIND_RENDER_TARGET;
    return usage;
 }
 
 
 /**
- * Allocate a pipe_texture object for the given st_texture_object using
+ * Allocate a pipe_resource object for the given st_texture_object using
  * the given st_texture_image to guess the mipmap size/levels.
  *
  * [comments...]
@@ -387,8 +386,8 @@ compress_with_blit(GLcontext * ctx,
    struct pipe_context *pipe = ctx->st->pipe;
    struct pipe_screen *screen = pipe->screen;
    gl_format mesa_format;
-   struct pipe_texture templ;
-   struct pipe_texture *src_tex;
+   struct pipe_resource templ;
+   struct pipe_resource *src_tex;
    struct pipe_sampler_view view_templ;
    struct pipe_sampler_view *src_view;
    struct pipe_surface *dst_surface;
@@ -403,7 +402,7 @@ compress_with_blit(GLcontext * ctx,
    /* get destination surface (in the compressed texture) */
    dst_surface = screen->get_tex_surface(screen, stImage->pt,
                                          stImage->face, stImage->level, 0,
-                                         PIPE_BUFFER_USAGE_GPU_WRITE);
+                                         PIPE_BIND_BLIT_DESTINATION);
    if (!dst_surface) {
       /* can't render into this format (or other problem) */
       return GL_FALSE;
@@ -425,8 +424,9 @@ compress_with_blit(GLcontext * ctx,
    templ.height0 = height;
    templ.depth0 = 1;
    templ.last_level = 0;
-   templ.tex_usage = PIPE_TEXTURE_USAGE_SAMPLER;
-   src_tex = screen->texture_create(screen, &templ);
+   templ._usage = PIPE_USAGE_DEFAULT;
+   templ.bind = PIPE_BIND_SAMPLER_VIEW;
+   src_tex = screen->resource_create(screen, &templ);
 
    if (!src_tex)
       return GL_FALSE;
@@ -437,7 +437,7 @@ compress_with_blit(GLcontext * ctx,
 					     0, 0, 0, /* face, level are zero */
 					     PIPE_TRANSFER_WRITE,
 					     0, 0, width, height); /* x, y, w, h */
-   map = pipe->transfer_map(pipe, tex_xfer);
+   map = pipe_transfer_map(pipe, tex_xfer);
 
    _mesa_texstore(ctx, 2, GL_RGBA, mesa_format,
                   map,              /* dest ptr */
@@ -449,8 +449,8 @@ compress_with_blit(GLcontext * ctx,
                   pixels,           /* source data */
                   unpack);          /* source data packing */
 
-   pipe->transfer_unmap(pipe, tex_xfer);
-   pipe->tex_transfer_destroy(pipe, tex_xfer);
+   pipe_transfer_unmap(pipe, tex_xfer);
+   pipe->transfer_destroy(pipe, tex_xfer);
 
    /* Create temporary sampler view */
    u_sampler_view_default_template(&view_templ,
@@ -472,7 +472,7 @@ compress_with_blit(GLcontext * ctx,
                         PIPE_TEX_MIPFILTER_NEAREST);
 
    pipe_surface_reference(&dst_surface, NULL);
-   pipe_texture_reference(&src_tex, NULL);
+   pipe_resource_reference(&src_tex, NULL);
    pipe_sampler_view_reference(&src_view, NULL);
 
    return GL_TRUE;
@@ -560,7 +560,7 @@ st_TexImage(GLcontext * ctx,
     * Release any old malloced memory.
     */
    if (stImage->pt) {
-      pipe_texture_reference(&stImage->pt, NULL);
+      pipe_resource_reference(&stImage->pt, NULL);
       assert(!texImage->Data);
    }
    else if (texImage->Data) {
@@ -577,7 +577,7 @@ st_TexImage(GLcontext * ctx,
           !st_texture_match_image(stObj->pt, &stImage->base,
                                   stImage->face, stImage->level)) {
          DBG("release it\n");
-         pipe_texture_reference(&stObj->pt, NULL);
+         pipe_resource_reference(&stObj->pt, NULL);
          assert(!stObj->pt);
          pipe_sampler_view_reference(&stObj->sampler_view, NULL);
          stObj->teximage_realloc = FALSE;
@@ -610,7 +610,7 @@ st_TexImage(GLcontext * ctx,
        st_texture_match_image(stObj->pt, &stImage->base,
                                  stImage->face, stImage->level)) {
 
-      pipe_texture_reference(&stImage->pt, stObj->pt);
+      pipe_resource_reference(&stImage->pt, stObj->pt);
       assert(stImage->pt);
    }
 
@@ -644,7 +644,7 @@ st_TexImage(GLcontext * ctx,
        screen->is_format_supported(screen,
                                    stImage->pt->format,
                                    stImage->pt->target,
-                                   PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
+                                   PIPE_BIND_RENDER_TARGET, 0)) {
       if (!pixels)
          goto done;
 
@@ -842,11 +842,14 @@ decompress_with_blit(GLcontext * ctx, GLenum target, GLint level,
    const GLuint width = texImage->Width;
    const GLuint height = texImage->Height;
    struct pipe_surface *dst_surface;
-   struct pipe_texture *dst_texture;
+   struct pipe_resource *dst_texture;
    struct pipe_transfer *tex_xfer;
+   unsigned bind = (PIPE_BIND_BLIT_DESTINATION |
+		    PIPE_BIND_RENDER_TARGET | /* util_blit may choose to render */
+		    PIPE_BIND_TRANSFER_READ);
 
    /* create temp / dest surface */
-   if (!util_create_rgba_surface(screen, width, height,
+   if (!util_create_rgba_surface(screen, width, height, bind,
                                  &dst_texture, &dst_surface)) {
       _mesa_problem(ctx, "util_create_rgba_surface() failed "
                     "in decompress_with_blit()");
@@ -855,7 +858,7 @@ decompress_with_blit(GLcontext * ctx, GLenum target, GLint level,
 
    /* blit/render/decompress */
    util_blit_pixels_tex(ctx->st->blit,
-                        src_view,      /* pipe_texture (src) */
+                        src_view,      /* pipe_resource (src) */
                         0, 0,             /* src x0, y0 */
                         width, height,    /* src x1, y1 */
                         dst_surface,      /* pipe_surface (dst) */
@@ -876,7 +879,7 @@ decompress_with_blit(GLcontext * ctx, GLenum target, GLint level,
    if (st_equal_formats(stImage->pt->format, format, type)) {
       /* memcpy */
       const uint bytesPerRow = width * util_format_get_blocksize(stImage->pt->format);
-      ubyte *map = pipe->transfer_map(pipe, tex_xfer);
+      ubyte *map = pipe_transfer_map(pipe, tex_xfer);
       GLuint row;
       for (row = 0; row < height; row++) {
          GLvoid *dest = _mesa_image_address2d(&ctx->Pack, pixels, width,
@@ -884,7 +887,7 @@ decompress_with_blit(GLcontext * ctx, GLenum target, GLint level,
          memcpy(dest, map, bytesPerRow);
          map += tex_xfer->stride;
       }
-      pipe->transfer_unmap(pipe, tex_xfer);
+      pipe_transfer_unmap(pipe, tex_xfer);
    }
    else {
       /* format translation via floats */
@@ -908,7 +911,7 @@ decompress_with_blit(GLcontext * ctx, GLenum target, GLint level,
 
    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 
-   pipe->tex_transfer_destroy(pipe, tex_xfer);
+   pipe->transfer_destroy(pipe, tex_xfer);
 
    /* destroy the temp / dest surface */
    util_destroy_rgba_surface(dst_texture, dst_surface);
@@ -1069,7 +1072,7 @@ st_TexSubimage(GLcontext *ctx, GLint dims, GLenum target, GLint level,
        screen->is_format_supported(screen,
                                    stImage->pt->format,
                                    stImage->pt->target,
-                                   PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
+                                   PIPE_BIND_RENDER_TARGET, 0)) {
       if (compress_with_blit(ctx, target, level,
                              xoffset, yoffset, zoffset,
                              width, height, depth,
@@ -1392,7 +1395,7 @@ fallback_copy_texsubimage(GLcontext *ctx, GLenum target, GLint level,
    }
 
    st_texture_image_unmap(ctx->st, stImage);
-   pipe->tex_transfer_destroy(pipe, src_trans);
+   pipe->transfer_destroy(pipe, src_trans);
 }
 
 
@@ -1577,7 +1580,7 @@ st_copy_texsubimage(GLcontext *ctx,
          dest_surface = screen->get_tex_surface(screen, stImage->pt,
                                                 stImage->face, stImage->level,
                                                 destZ,
-                                                PIPE_BUFFER_USAGE_GPU_WRITE);
+                                                PIPE_BIND_BLIT_DESTINATION);
 
          /* for surface_copy(), y=0=top, always */
          pipe->surface_copy(pipe,
@@ -1596,11 +1599,11 @@ st_copy_texsubimage(GLcontext *ctx,
                texBaseFormat != GL_DEPTH_STENCIL &&
                screen->is_format_supported(screen, src_format,
                                            PIPE_TEXTURE_2D, 
-                                           PIPE_TEXTURE_USAGE_SAMPLER,
+                                           PIPE_BIND_SAMPLER_VIEW,
                                            0) &&
                screen->is_format_supported(screen, dest_format,
                                            PIPE_TEXTURE_2D, 
-                                           PIPE_TEXTURE_USAGE_RENDER_TARGET,
+                                           PIPE_BIND_RENDER_TARGET,
                                            0)) {
          /* draw textured quad to do the copy */
          GLint srcY0, srcY1;
@@ -1608,7 +1611,7 @@ st_copy_texsubimage(GLcontext *ctx,
          dest_surface = screen->get_tex_surface(screen, stImage->pt,
                                                 stImage->face, stImage->level,
                                                 destZ,
-                                                PIPE_BUFFER_USAGE_GPU_WRITE);
+                                                PIPE_BIND_BLIT_DESTINATION);
 
          if (do_flip) {
             srcY1 = strb->Base.Height - srcY - height;
@@ -1748,7 +1751,7 @@ copy_image_data_to_texture(struct st_context *st,
                             stImage->pt, /* src texture */
                             stImage->face);
 
-      pipe_texture_reference(&stImage->pt, NULL);
+      pipe_resource_reference(&stImage->pt, NULL);
    }
    else if (stImage->base.Data) {
       /* More straightforward upload.  
@@ -1770,7 +1773,7 @@ copy_image_data_to_texture(struct st_context *st,
       stImage->base.Data = NULL;
    }
 
-   pipe_texture_reference(&stImage->pt, stObj->pt);
+   pipe_resource_reference(&stImage->pt, stObj->pt);
 }
 
 
@@ -1816,7 +1819,7 @@ st_finalize_texture(GLcontext *ctx,
    if (firstImage->pt &&
        firstImage->pt != stObj->pt &&
        firstImage->pt->last_level >= stObj->lastLevel) {
-      pipe_texture_reference(&stObj->pt, firstImage->pt);
+      pipe_resource_reference(&stObj->pt, firstImage->pt);
       pipe_sampler_view_reference(&stObj->sampler_view, NULL);
    }
 
@@ -1836,7 +1839,7 @@ st_finalize_texture(GLcontext *ctx,
           stObj->pt->height0 != firstImage->base.Height2 ||
           stObj->pt->depth0 != firstImage->base.Depth2)
       {
-         pipe_texture_reference(&stObj->pt, NULL);
+         pipe_resource_reference(&stObj->pt, NULL);
          pipe_sampler_view_reference(&stObj->sampler_view, NULL);
          ctx->st->dirty.st |= ST_NEW_FRAMEBUFFER;
       }
diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c
index 72f5a9c1e0b..c753fdca34c 100644
--- a/src/mesa/state_tracker/st_context.c
+++ b/src/mesa/state_tracker/st_context.c
@@ -31,7 +31,6 @@
 #include "shader/shader_api.h"
 #include "glapi/glapi.h"
 #include "st_context.h"
-#include "st_public.h"
 #include "st_debug.h"
 #include "st_cb_accum.h"
 #include "st_cb_bitmap.h"
@@ -46,6 +45,7 @@
 #if FEATURE_OES_draw_texture
 #include "st_cb_drawtex.h"
 #endif
+#include "st_cb_eglimage.h"
 #include "st_cb_fbo.h"
 #if FEATURE_feedback
 #include "st_cb_feedback.h"
@@ -239,7 +239,7 @@ static void st_destroy_context_priv( struct st_context *st )
 
    for (i = 0; i < Elements(st->state.constants); i++) {
       if (st->state.constants[i]) {
-         pipe_buffer_reference(&st->state.constants[i], NULL);
+         pipe_resource_reference(&st->state.constants[i], NULL);
       }
    }
 
@@ -287,56 +287,6 @@ void st_destroy_context( struct st_context *st )
 }
 
 
-GLboolean
-st_make_current(struct st_context *st,
-                struct st_framebuffer *draw,
-                struct st_framebuffer *read,
-                void *winsys_drawable_handle )
-{
-   /* Call this periodically to detect when the user has begun using
-    * GL rendering from multiple threads.
-    */
-   _glapi_check_multithread();
-
-   if (st) {
-      if (!_mesa_make_current(st->ctx, &draw->Base, &read->Base)) {
-         st->pipe->priv = NULL;
-         return GL_FALSE;
-      }
-
-      _mesa_check_init_viewport(st->ctx, draw->InitWidth, draw->InitHeight);
-      st->winsys_drawable_handle = winsys_drawable_handle;
-
-      return GL_TRUE;
-   }
-   else {
-      return _mesa_make_current(NULL, NULL, NULL);
-   }
-}
-
-struct st_context *st_get_current(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   return (ctx == NULL) ? NULL : ctx->st;
-}
-
-void st_copy_context_state(struct st_context *dst,
-                           struct st_context *src,
-                           uint mask)
-{
-   _mesa_copy_context(dst->ctx, src->ctx, mask);
-}
-
-
-
-st_proc st_get_proc_address(const char *procname)
-{
-   return (st_proc) _glapi_get_proc_address(procname);
-}
-
-
-
 void st_init_driver_functions(struct dd_function_table *functions)
 {
    _mesa_init_glsl_driver_functions(functions);
@@ -359,6 +309,8 @@ void st_init_driver_functions(struct dd_function_table *functions)
    st_init_drawtex_functions(functions);
 #endif
 
+   st_init_eglimage_functions(functions);
+
    st_init_fbo_functions(functions);
 #if FEATURE_feedback
    st_init_feedback_functions(functions);
diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h
index 786beaec08b..dfee490b54a 100644
--- a/src/mesa/state_tracker/st_context.h
+++ b/src/mesa/state_tracker/st_context.h
@@ -46,12 +46,6 @@ struct blit_state;
 struct bitmap_cache;
 
 
-/** XXX we'd like to get rid of these */
-#define FRONT_STATUS_UNDEFINED    0
-#define FRONT_STATUS_DIRTY        1
-#define FRONT_STATUS_COPY_OF_BACK 2
-
-
 #define ST_NEW_MESA                    0x1 /* Mesa state has changed */
 #define ST_NEW_FRAGMENT_PROGRAM        0x2
 #define ST_NEW_VERTEX_PROGRAM          0x4
@@ -95,7 +89,7 @@ struct st_context
       struct pipe_sampler_state             samplers[PIPE_MAX_SAMPLERS];
       struct pipe_sampler_state             *sampler_list[PIPE_MAX_SAMPLERS];
       struct pipe_clip_state clip;
-      struct pipe_buffer *constants[2];
+      struct pipe_resource *constants[2];
       struct pipe_framebuffer_state framebuffer;
       struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
       struct pipe_scissor_state scissor;
@@ -116,8 +110,6 @@ struct st_context
       struct gl_fragment_program *fragment_program;
    } cb;
 
-   GLuint frontbuffer_status;  /**< one of FRONT_STATUS_ (XXX to be removed) */
-
    char vendor[100];
    char renderer[100];
 
@@ -143,7 +135,7 @@ struct st_context
       GLuint user_prog_sn;  /**< user fragment program serial no. */
       struct st_fragment_program *combined_prog;
       GLuint combined_prog_sn;
-      struct pipe_texture *pixelmap_texture;
+      struct pipe_resource *pixelmap_texture;
       struct pipe_sampler_view *pixelmap_sampler_view;
       boolean pixelmap_enabled;  /**< use the pixelmap texture? */
    } pixel_xfer;
@@ -155,7 +147,7 @@ struct st_context
       enum pipe_format tex_format;
       void *vs;
       float vertices[4][3][4];  /**< vertex pos + color + texcoord */
-      struct pipe_buffer *vbuf;
+      struct pipe_resource *vbuf;
       unsigned vbuf_slot;       /* next free slot in vbuf */
       struct bitmap_cache *cache;
    } bitmap;
@@ -174,7 +166,7 @@ struct st_context
       void *vs;
       void *fs;
       float vertices[4][2][4];  /**< vertex pos + color */
-      struct pipe_buffer *vbuf;
+      struct pipe_resource *vbuf;
       unsigned vbuf_slot;
    } clear;
 
@@ -259,5 +251,12 @@ st_fb_orientation(const struct gl_framebuffer *fb)
 extern int
 st_get_msaa(void);
 
+extern struct st_context *
+st_create_context(struct pipe_context *pipe, const __GLcontextModes *visual,
+                  struct st_context *share);
+
+extern void
+st_destroy_context(struct st_context *st);
+
 
 #endif
diff --git a/src/mesa/state_tracker/st_draw.c b/src/mesa/state_tracker/st_draw.c
index 7f45e3f5484..4f4368ac9e4 100644
--- a/src/mesa/state_tracker/st_draw.c
+++ b/src/mesa/state_tracker/st_draw.c
@@ -74,6 +74,13 @@ static GLuint float_types[4] = {
    PIPE_FORMAT_R32G32B32A32_FLOAT
 };
 
+static GLuint half_float_types[4] = {
+   PIPE_FORMAT_R16_FLOAT,
+   PIPE_FORMAT_R16G16_FLOAT,
+   PIPE_FORMAT_R16G16B16_FLOAT,
+   PIPE_FORMAT_R16G16B16A16_FLOAT
+};
+
 static GLuint uint_types_norm[4] = {
    PIPE_FORMAT_R32_UNORM,
    PIPE_FORMAT_R32G32_UNORM,
@@ -175,7 +182,7 @@ st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
                       GLboolean normalized)
 {
    assert((type >= GL_BYTE && type <= GL_DOUBLE) ||
-          type == GL_FIXED);
+          type == GL_FIXED || type == GL_HALF_FLOAT);
    assert(size >= 1);
    assert(size <= 4);
    assert(format == GL_RGBA || format == GL_BGRA);
@@ -191,6 +198,7 @@ st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
       switch (type) {
       case GL_DOUBLE: return double_types[size-1];
       case GL_FLOAT: return float_types[size-1];
+      case GL_HALF_FLOAT: return half_float_types[size-1];
       case GL_INT: return int_types_norm[size-1];
       case GL_SHORT: return short_types_norm[size-1];
       case GL_BYTE: return byte_types_norm[size-1];
@@ -205,6 +213,7 @@ st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
       switch (type) {
       case GL_DOUBLE: return double_types[size-1];
       case GL_FLOAT: return float_types[size-1];
+      case GL_HALF_FLOAT: return half_float_types[size-1];
       case GL_INT: return int_types_scale[size-1];
       case GL_SHORT: return short_types_scale[size-1];
       case GL_BYTE: return byte_types_scale[size-1];
@@ -360,12 +369,13 @@ setup_interleaved_attribs(GLcontext *ctx,
          offset0 = low;
          if (userSpace) {
             vbuffer->buffer =
-               pipe_user_buffer_create(pipe->screen, (void *) low, high - low);
+               pipe_user_buffer_create(pipe->screen, (void *) low, high - low,
+				       PIPE_BIND_VERTEX_BUFFER);
             vbuffer->buffer_offset = 0;
          }
          else {
             vbuffer->buffer = NULL;
-            pipe_buffer_reference(&vbuffer->buffer, stobj->buffer);
+            pipe_resource_reference(&vbuffer->buffer, stobj->buffer);
             vbuffer->buffer_offset = pointer_to_offset(low);
          }
          vbuffer->stride = stride; /* in bytes */
@@ -422,7 +432,7 @@ setup_non_interleaved_attribs(GLcontext *ctx,
          /*printf("stobj %u = %p\n", attr, (void*) stobj);*/
 
          vbuffer[attr].buffer = NULL;
-         pipe_buffer_reference(&vbuffer[attr].buffer, stobj->buffer);
+         pipe_resource_reference(&vbuffer[attr].buffer, stobj->buffer);
          vbuffer[attr].buffer_offset = pointer_to_offset(arrays[mesaAttr]->Ptr);
          velements[attr].src_offset = 0;
       }
@@ -443,14 +453,19 @@ setup_non_interleaved_attribs(GLcontext *ctx,
                bytes = arrays[mesaAttr]->Size
                   * _mesa_sizeof_type(arrays[mesaAttr]->Type);
             }
-            vbuffer[attr].buffer = pipe_user_buffer_create(pipe->screen,
-                           (void *) arrays[mesaAttr]->Ptr, bytes);
+            vbuffer[attr].buffer = 
+	       pipe_user_buffer_create(pipe->screen,
+				       (void *) arrays[mesaAttr]->Ptr, bytes,
+				       PIPE_BIND_VERTEX_BUFFER);
          }
          else {
             /* no array, use ctx->Current.Attrib[] value */
             bytes = sizeof(ctx->Current.Attrib[0]);
-            vbuffer[attr].buffer = pipe_user_buffer_create(pipe->screen,
-                           (void *) ctx->Current.Attrib[mesaAttr], bytes);
+            vbuffer[attr].buffer = 
+	       pipe_user_buffer_create(pipe->screen,
+				       (void *) ctx->Current.Attrib[mesaAttr],
+				       bytes,
+				       PIPE_BIND_VERTEX_BUFFER);
             stride = 0;
          }
 
@@ -618,7 +633,7 @@ st_draw_vbo(GLcontext *ctx,
    if (ib) {
       /* indexed primitive */
       struct gl_buffer_object *bufobj = ib->obj;
-      struct pipe_buffer *indexBuf = NULL;
+      struct pipe_resource *indexBuf = NULL;
       unsigned indexSize, indexOffset, i;
       unsigned prim;
 
@@ -641,13 +656,14 @@ st_draw_vbo(GLcontext *ctx,
       if (bufobj && bufobj->Name) {
          /* elements/indexes are in a real VBO */
          struct st_buffer_object *stobj = st_buffer_object(bufobj);
-         pipe_buffer_reference(&indexBuf, stobj->buffer);
+         pipe_resource_reference(&indexBuf, stobj->buffer);
          indexOffset = pointer_to_offset(ib->ptr) / indexSize;
       }
       else {
          /* element/indicies are in user space memory */
          indexBuf = pipe_user_buffer_create(pipe->screen, (void *) ib->ptr,
-                                            ib->count * indexSize);
+                                            ib->count * indexSize,
+					    PIPE_BIND_INDEX_BUFFER);
          indexOffset = 0;
       }
 
@@ -669,13 +685,21 @@ st_draw_vbo(GLcontext *ctx,
          for (i = 0; i < nr_prims; i++) {
             prim = translate_prim( ctx, prims[i].mode );
             
-            pipe->draw_elements(pipe, indexBuf, indexSize,
-                                prim,
-                                prims[i].start + indexOffset, prims[i].count);
+            if (prims[i].num_instances == 1) {
+               pipe->draw_elements(pipe, indexBuf, indexSize, prim,
+                                   prims[i].start + indexOffset,
+                                   prims[i].count);
+            }
+            else {
+               pipe->draw_elements_instanced(pipe, indexBuf, indexSize, prim,
+                                             prims[i].start + indexOffset,
+                                             prims[i].count,
+                                             0, prims[i].num_instances);
+            }
          }
       }
 
-      pipe_buffer_reference(&indexBuf, NULL);
+      pipe_resource_reference(&indexBuf, NULL);
    }
    else {
       /* non-indexed */
@@ -685,13 +709,20 @@ st_draw_vbo(GLcontext *ctx,
       for (i = 0; i < nr_prims; i++) {
          prim = translate_prim( ctx, prims[i].mode );
 
-         pipe->draw_arrays(pipe, prim, prims[i].start, prims[i].count);
+         if (prims[i].num_instances == 1) {
+            pipe->draw_arrays(pipe, prim, prims[i].start, prims[i].count);
+         }
+         else {
+            pipe->draw_arrays_instanced(pipe, prim, prims[i].start,
+                                        prims[i].count,
+                                        0, prims[i].num_instances);
+         }
       }
    }
 
    /* unreference buffers (frees wrapped user-space buffer objects) */
    for (attr = 0; attr < num_vbuffers; attr++) {
-      pipe_buffer_reference(&vbuffer[attr].buffer, NULL);
+      pipe_resource_reference(&vbuffer[attr].buffer, NULL);
       assert(!vbuffer[attr].buffer);
    }
 
diff --git a/src/mesa/state_tracker/st_draw_feedback.c b/src/mesa/state_tracker/st_draw_feedback.c
index 26a5b3fcd63..04730464e52 100644
--- a/src/mesa/state_tracker/st_draw_feedback.c
+++ b/src/mesa/state_tracker/st_draw_feedback.c
@@ -104,9 +104,12 @@ st_feedback_draw_vbo(GLcontext *ctx,
    struct draw_context *draw = st->draw;
    const struct st_vertex_program *vp;
    const struct pipe_shader_state *vs;
-   struct pipe_buffer *index_buffer_handle = 0;
+   struct pipe_resource *index_buffer_handle = 0;
    struct pipe_vertex_buffer vbuffers[PIPE_MAX_SHADER_INPUTS];
    struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
+   struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS];
+   struct pipe_transfer *ib_transfer = NULL;
+   struct pipe_transfer *cb_transfer;
    GLuint attr, i;
    ubyte *mapped_constants;
 
@@ -155,7 +158,7 @@ st_feedback_draw_vbo(GLcontext *ctx,
          assert(stobj->buffer);
 
          vbuffers[attr].buffer = NULL;
-         pipe_buffer_reference(&vbuffers[attr].buffer, stobj->buffer);
+         pipe_resource_reference(&vbuffers[attr].buffer, stobj->buffer);
          vbuffers[attr].buffer_offset = pointer_to_offset(arrays[0]->Ptr);
          velements[attr].src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
       }
@@ -168,7 +171,8 @@ st_feedback_draw_vbo(GLcontext *ctx,
          /* wrap user data */
          vbuffers[attr].buffer
             = pipe_user_buffer_create(pipe->screen, (void *) arrays[mesaAttr]->Ptr,
-                                      bytes);
+                                      bytes,
+				      PIPE_BIND_VERTEX_BUFFER);
          vbuffers[attr].buffer_offset = 0;
          velements[attr].src_offset = 0;
       }
@@ -191,8 +195,9 @@ st_feedback_draw_vbo(GLcontext *ctx,
 #endif
 
       /* map the attrib buffer */
-      map = pipe_buffer_map(pipe->screen, vbuffers[attr].buffer,
-                            PIPE_BUFFER_USAGE_CPU_READ);
+      map = pipe_buffer_map(pipe, vbuffers[attr].buffer,
+                            PIPE_TRANSFER_READ,
+			    &vb_transfer[attr]);
       draw_set_mapped_vertex_buffer(draw, attr, map);
    }
 
@@ -221,13 +226,14 @@ st_feedback_draw_vbo(GLcontext *ctx,
 
          index_buffer_handle = stobj->buffer;
 
-         map = pipe_buffer_map(pipe->screen, index_buffer_handle,
-                               PIPE_BUFFER_USAGE_CPU_READ);
+         map = pipe_buffer_map(pipe, index_buffer_handle,
+                               PIPE_TRANSFER_READ, &ib_transfer);
 
          draw_set_mapped_element_buffer(draw, indexSize, map);
       }
       else {
          draw_set_mapped_element_buffer(draw, indexSize, (void *) ib->ptr);
+	 ib_transfer = NULL;
       }
    }
    else {
@@ -237,12 +243,13 @@ st_feedback_draw_vbo(GLcontext *ctx,
 
 
    /* map constant buffers */
-   mapped_constants = pipe_buffer_map(pipe->screen,
+   mapped_constants = pipe_buffer_map(pipe,
                                       st->state.constants[PIPE_SHADER_VERTEX],
-                                      PIPE_BUFFER_USAGE_CPU_READ);
+                                      PIPE_TRANSFER_READ,
+				      &cb_transfer);
    draw_set_mapped_constant_buffer(st->draw, PIPE_SHADER_VERTEX, 0,
                                    mapped_constants,
-                                   st->state.constants[PIPE_SHADER_VERTEX]->size);
+                                   st->state.constants[PIPE_SHADER_VERTEX]->width0);
 
 
    /* draw here */
@@ -252,20 +259,22 @@ st_feedback_draw_vbo(GLcontext *ctx,
 
 
    /* unmap constant buffers */
-   pipe_buffer_unmap(pipe->screen, st->state.constants[PIPE_SHADER_VERTEX]);
+   pipe_buffer_unmap(pipe, st->state.constants[PIPE_SHADER_VERTEX],
+		     cb_transfer);
 
    /*
     * unmap vertex/index buffers
     */
    for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
       if (draw->pt.vertex_buffer[i].buffer) {
-         pipe_buffer_unmap(pipe->screen, draw->pt.vertex_buffer[i].buffer);
-         pipe_buffer_reference(&draw->pt.vertex_buffer[i].buffer, NULL);
+         pipe_buffer_unmap(pipe, draw->pt.vertex_buffer[i].buffer, 
+			   vb_transfer[i]);
+         pipe_resource_reference(&draw->pt.vertex_buffer[i].buffer, NULL);
          draw_set_mapped_vertex_buffer(draw, i, NULL);
       }
    }
    if (index_buffer_handle) {
-      pipe_buffer_unmap(pipe->screen, index_buffer_handle);
+      pipe_buffer_unmap(pipe, index_buffer_handle, ib_transfer);
       draw_set_mapped_element_buffer(draw, 0, NULL);
    }
 }
diff --git a/src/mesa/state_tracker/st_extensions.c b/src/mesa/state_tracker/st_extensions.c
index 0118c600f09..b2045cf3fcb 100644
--- a/src/mesa/state_tracker/st_extensions.c
+++ b/src/mesa/state_tracker/st_extensions.c
@@ -183,6 +183,7 @@ void st_init_extensions(struct st_context *st)
    ctx->Extensions.EXT_framebuffer_object = GL_TRUE;
    ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;
    ctx->Extensions.EXT_fog_coord = GL_TRUE;
+   ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
    ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;
    ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
    ctx->Extensions.EXT_point_parameters = GL_TRUE;
@@ -209,6 +210,9 @@ void st_init_extensions(struct st_context *st)
    ctx->Extensions.NV_vertex_program1_1 = GL_TRUE;
 #endif
 
+#if FEATURE_OES_EGL_image
+   ctx->Extensions.OES_EGL_image = GL_TRUE;
+#endif
 #if FEATURE_OES_draw_texture
    ctx->Extensions.OES_draw_texture = GL_TRUE;
 #endif
@@ -241,6 +245,7 @@ void st_init_extensions(struct st_context *st)
 
    if (screen->get_param(screen, PIPE_CAP_TEXTURE_MIRROR_CLAMP) > 0) {
       ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;
+      ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;
    }
 
    if (screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES)) {
@@ -283,39 +288,39 @@ void st_init_extensions(struct st_context *st)
     */
    if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
                                    PIPE_TEXTURE_2D, 
-                                   PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0) &&
+                                   PIPE_BIND_DEPTH_STENCIL, 0) &&
        screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
                                    PIPE_TEXTURE_2D, 
-                                   PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
       ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
    }
    else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
                                         PIPE_TEXTURE_2D, 
-                                        PIPE_TEXTURE_USAGE_DEPTH_STENCIL, 0) &&
+                                        PIPE_BIND_DEPTH_STENCIL, 0) &&
             screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
                                         PIPE_TEXTURE_2D, 
-                                        PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                        PIPE_BIND_SAMPLER_VIEW, 0)) {
       ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
    }
 
    /* sRGB support */
    if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,
                                    PIPE_TEXTURE_2D, 
-                                   PIPE_TEXTURE_USAGE_SAMPLER, 0) ||
+                                   PIPE_BIND_SAMPLER_VIEW, 0) ||
       screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
                                    PIPE_TEXTURE_2D, 
-                                   PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
       ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
    }
 
    /* s3tc support */
    if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
                                    PIPE_TEXTURE_2D,
-                                   PIPE_TEXTURE_USAGE_SAMPLER, 0) &&
+                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
        (ctx->Mesa_DXTn ||
         screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
                                     PIPE_TEXTURE_2D,
-                                    PIPE_TEXTURE_USAGE_RENDER_TARGET, 0))) {
+                                    PIPE_BIND_RENDER_TARGET, 0))) {
       ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
       ctx->Extensions.S3_s3tc = GL_TRUE;
    }
@@ -323,10 +328,10 @@ void st_init_extensions(struct st_context *st)
    /* ycbcr support */
    if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, 
                                    PIPE_TEXTURE_2D, 
-                                   PIPE_TEXTURE_USAGE_SAMPLER, 0) ||
+                                   PIPE_BIND_SAMPLER_VIEW, 0) ||
        screen->is_format_supported(screen, PIPE_FORMAT_YUYV, 
                                    PIPE_TEXTURE_2D, 
-                                   PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
+                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
       ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
    }
 
diff --git a/src/mesa/state_tracker/st_format.c b/src/mesa/state_tracker/st_format.c
index ecc08762bb2..731ec64c139 100644
--- a/src/mesa/state_tracker/st_format.c
+++ b/src/mesa/state_tracker/st_format.c
@@ -374,7 +374,7 @@ default_deep_rgba_format(struct pipe_screen *screen,
    if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SNORM, target, tex_usage, geom_flags)) {
       return PIPE_FORMAT_R16G16B16A16_SNORM;
    }
-   if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
+   if (tex_usage & PIPE_BIND_RENDER_TARGET)
       return default_rgba_format(screen, target, tex_usage, geom_flags);
    else
       return PIPE_FORMAT_NONE;
@@ -410,8 +410,8 @@ default_depth_format(struct pipe_screen *screen,
  * Given an OpenGL internalFormat value for a texture or surface, return
  * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
  * \param target  one of PIPE_TEXTURE_x
- * \param tex_usage  either PIPE_TEXTURE_USAGE_RENDER_TARGET
- *                   or PIPE_TEXTURE_USAGE_SAMPLER
+ * \param tex_usage  either PIPE_BIND_RENDER_TARGET
+ *                   or PIPE_BIND_SAMPLER_VIEW
  */
 enum pipe_format
 st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
@@ -432,7 +432,7 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
    case GL_COMPRESSED_RGB:
       return default_rgb_format( screen, target, tex_usage, geom_flags );
    case GL_RGBA16:
-      if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
+      if (tex_usage & PIPE_BIND_RENDER_TARGET)
          return default_deep_rgba_format( screen, target, tex_usage, geom_flags );
       else
          return default_rgba_format( screen, target, tex_usage, geom_flags );
@@ -645,9 +645,9 @@ st_choose_renderbuffer_format(struct pipe_screen *screen,
 {
    uint usage;
    if (is_depth_or_stencil_format(internalFormat))
-      usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
+      usage = PIPE_BIND_DEPTH_STENCIL;
    else
-      usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
+      usage = PIPE_BIND_RENDER_TARGET;
    return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D, usage);
 }
 
@@ -665,7 +665,7 @@ st_ChooseTextureFormat(GLcontext *ctx, GLint internalFormat,
    (void) type;
 
    pFormat = st_choose_format(ctx->st->pipe->screen, internalFormat,
-                              PIPE_TEXTURE_2D, PIPE_TEXTURE_USAGE_SAMPLER);
+                              PIPE_TEXTURE_2D, PIPE_BIND_SAMPLER_VIEW);
    if (pFormat == PIPE_FORMAT_NONE)
       return MESA_FORMAT_NONE;
 
diff --git a/src/mesa/state_tracker/st_framebuffer.c b/src/mesa/state_tracker/st_framebuffer.c
deleted file mode 100644
index d3c43bbc68a..00000000000
--- a/src/mesa/state_tracker/st_framebuffer.c
+++ /dev/null
@@ -1,408 +0,0 @@
-/**************************************************************************
- * 
- * Copyright 2003 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.
- * 
- **************************************************************************/
-
-
-#include "main/imports.h"
-#include "main/buffers.h"
-#include "main/context.h"
-#include "main/framebuffer.h"
-#include "main/renderbuffer.h"
-#include "st_context.h"
-#include "st_cb_fbo.h"
-#include "st_public.h"
-#include "pipe/p_defines.h"
-#include "util/u_inlines.h"
-
-
-struct st_framebuffer *
-st_create_framebuffer( const __GLcontextModes *visual,
-                       enum pipe_format colorFormat,
-                       enum pipe_format depthFormat,
-                       enum pipe_format stencilFormat,
-                       uint width, uint height,
-                       void *private)
-{
-   struct st_framebuffer *stfb = ST_CALLOC_STRUCT(st_framebuffer);
-   if (stfb) {
-      int samples = st_get_msaa();
-      int i;
-
-      if (visual->sampleBuffers)
-         samples = visual->samples;
-
-      _mesa_initialize_window_framebuffer(&stfb->Base, visual);
-
-      if (visual->doubleBufferMode) {
-         struct gl_renderbuffer *rb
-            = st_new_renderbuffer_fb(colorFormat, samples, FALSE);
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_BACK_LEFT, rb);
-      }
-      else {
-         /* Only allocate front buffer right now if we're single buffered.
-          * If double-buffered, allocate front buffer on demand later.
-          * See check_create_front_buffers() and st_set_framebuffer_surface().
-          */
-         struct gl_renderbuffer *rb
-            = st_new_renderbuffer_fb(colorFormat, samples, FALSE);
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_FRONT_LEFT, rb);
-      }
-
-      if (depthFormat == stencilFormat && depthFormat != PIPE_FORMAT_NONE) {
-         /* combined depth/stencil buffer */
-         struct gl_renderbuffer *depthStencilRb
-            = st_new_renderbuffer_fb(depthFormat, samples, FALSE);
-         /* note: bind RB to two attachment points */
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthStencilRb);
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, depthStencilRb);
-      }
-      else {
-         /* separate depth and/or stencil */
-
-         if (visual->depthBits == 32) {
-            /* 32-bit depth buffer */
-            struct gl_renderbuffer *depthRb
-               = st_new_renderbuffer_fb(depthFormat, samples, FALSE);
-            _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
-         }
-         else if (visual->depthBits == 24) {
-            /* 24-bit depth buffer, ignore stencil bits */
-            struct gl_renderbuffer *depthRb
-               = st_new_renderbuffer_fb(depthFormat, samples, FALSE);
-            _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
-         }
-         else if (visual->depthBits > 0) {
-            /* 16-bit depth buffer */
-            struct gl_renderbuffer *depthRb
-               = st_new_renderbuffer_fb(depthFormat, samples, FALSE);
-            _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
-         }
-
-         if (visual->stencilBits > 0) {
-            /* 8-bit stencil */
-            struct gl_renderbuffer *stencilRb
-               = st_new_renderbuffer_fb(stencilFormat, samples, FALSE);
-            _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, stencilRb);
-         }
-      }
-
-      if (visual->accumRedBits > 0) {
-         /* 16-bit/channel accum */
-         /* TODO: query the pipe screen for accumulation buffer format support */
-         struct gl_renderbuffer *accumRb
-            = st_new_renderbuffer_fb(PIPE_FORMAT_R16G16B16A16_SNORM, 0, TRUE);
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_ACCUM, accumRb);
-      }
-
-      for (i = 0; i < visual->numAuxBuffers; i++) {
-         struct gl_renderbuffer *aux
-            = st_new_renderbuffer_fb(colorFormat, 0, FALSE);
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_AUX0 + i, aux);
-      }
-
-      stfb->Base.Initialized = GL_TRUE;
-      stfb->InitWidth = width;
-      stfb->InitHeight = height;
-      stfb->Private = private;
-   }
-   return stfb;
-}
-
-
-void st_resize_framebuffer( struct st_framebuffer *stfb,
-                            uint width, uint height )
-{
-   if (stfb->Base.Width != width || stfb->Base.Height != height) {
-      GET_CURRENT_CONTEXT(ctx);
-      if (ctx) {
-         _mesa_check_init_viewport(ctx, width, height);
-
-         _mesa_resize_framebuffer(ctx, &stfb->Base, width, height);
-
-         assert(stfb->Base.Width == width);
-         assert(stfb->Base.Height == height);
-      }
-   }
-}
-
-
-void st_unreference_framebuffer( struct st_framebuffer *stfb )
-{
-   _mesa_reference_framebuffer((struct gl_framebuffer **) &stfb, NULL);
-}
-
-
-
-/**
- * Set/replace a framebuffer surface.
- * The user of the state tracker can use this instead of
- * st_resize_framebuffer() to provide new surfaces when a window is resized.
- * \param surfIndex  an ST_SURFACE_x index
- */
-void
-st_set_framebuffer_surface(struct st_framebuffer *stfb,
-                           uint surfIndex, struct pipe_surface *surf)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct st_renderbuffer *strb;
-
-   /* sanity checks */
-   assert(ST_SURFACE_FRONT_LEFT == BUFFER_FRONT_LEFT);
-   assert(ST_SURFACE_BACK_LEFT == BUFFER_BACK_LEFT);
-   assert(ST_SURFACE_FRONT_RIGHT == BUFFER_FRONT_RIGHT);
-   assert(ST_SURFACE_BACK_RIGHT == BUFFER_BACK_RIGHT);
-   assert(ST_SURFACE_DEPTH == BUFFER_DEPTH);
-
-   assert(surfIndex < BUFFER_COUNT);
-
-   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
-
-   if (!strb) {
-      /* create new renderbuffer for this surface now */
-      const GLuint numSamples = stfb->Base.Visual.samples;
-      struct gl_renderbuffer *rb =
-         st_new_renderbuffer_fb(surf->format, numSamples, FALSE);
-      if (!rb) {
-         /* out of memory */
-         _mesa_warning(ctx, "Out of memory allocating renderbuffer");
-         return;
-      }
-      _mesa_add_renderbuffer(&stfb->Base, surfIndex, rb);
-      strb = st_renderbuffer(rb);
-   }
-
-   /* replace the renderbuffer's surface/texture pointers */
-   pipe_surface_reference( &strb->surface, surf );
-   pipe_texture_reference( &strb->texture, surf->texture );
-   pipe_sampler_view_reference(&strb->sampler_view, NULL);
-
-   if (ctx) {
-      /* If ctx isn't set, we've likely not made current yet.
-       * But when we do, we need to start setting this dirty bit
-       * to ensure the renderbuffer attachements are up-to-date
-       * via update_framebuffer.
-       * Core Mesa's state validation will update the parent framebuffer's
-       * size info, etc.
-       */
-      ctx->st->dirty.st |= ST_NEW_FRAMEBUFFER;
-      ctx->NewState |= _NEW_BUFFERS;
-   }
-
-   /* update renderbuffer's width/height */
-   strb->Base.Width = surf->width;
-   strb->Base.Height = surf->height;
-}
-
-
-
-/**
- * Return the pipe_surface for the given renderbuffer.
- */
-int
-st_get_framebuffer_surface(struct st_framebuffer *stfb, uint surfIndex, struct pipe_surface **surface)
-{
-   struct st_renderbuffer *strb;
-
-   assert(surfIndex <= ST_SURFACE_DEPTH);
-
-   /* sanity checks, ST tokens should match Mesa tokens */
-   assert(ST_SURFACE_FRONT_LEFT == BUFFER_FRONT_LEFT);
-   assert(ST_SURFACE_BACK_RIGHT == BUFFER_BACK_RIGHT);
-
-   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
-   if (strb) {
-      *surface = strb->surface;
-      return GL_TRUE;
-   }
-
-   *surface = NULL;
-   return GL_FALSE;
-}
-
-int
-st_get_framebuffer_texture(struct st_framebuffer *stfb, uint surfIndex, struct pipe_texture **texture)
-{
-   struct st_renderbuffer *strb;
-
-   assert(surfIndex <= ST_SURFACE_DEPTH);
-
-   /* sanity checks, ST tokens should match Mesa tokens */
-   assert(ST_SURFACE_FRONT_LEFT == BUFFER_FRONT_LEFT);
-   assert(ST_SURFACE_BACK_RIGHT == BUFFER_BACK_RIGHT);
-
-   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
-   if (strb) {
-      *texture = strb->texture;
-      return GL_TRUE;
-   }
-
-   *texture = NULL;
-   return GL_FALSE;
-}
-
-/**
- * This function is to be called prior to SwapBuffers on the given
- * framebuffer.  It checks if the current context is bound to the framebuffer
- * and flushes rendering if needed.
- */
-void
-st_notify_swapbuffers(struct st_framebuffer *stfb)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (ctx && ctx->DrawBuffer == &stfb->Base) {
-      st_flush( ctx->st, 
-		PIPE_FLUSH_RENDER_CACHE | 
-		PIPE_FLUSH_SWAPBUFFERS |
-		PIPE_FLUSH_FRAME,
-                NULL );
-      if (st_renderbuffer(stfb->Base.Attachment[BUFFER_BACK_LEFT].Renderbuffer))
-         ctx->st->frontbuffer_status = FRONT_STATUS_COPY_OF_BACK;
-   }
-}
-
-
-/**
- * Swap the front/back color buffers.  Exchange the front/back pointers
- * and update some derived state.
- * No need to call st_notify_swapbuffers() first.
- *
- * For a single-buffered framebuffer, no swap occurs, but we still return
- * the pointer(s) to the front color buffer(s).
- *
- * \param front_left  returns pointer to front-left renderbuffer after swap
- * \param front_right  returns pointer to front-right renderbuffer after swap
- */
-void
-st_swapbuffers(struct st_framebuffer *stfb,
-               struct pipe_surface **front_left,
-               struct pipe_surface **front_right)
-{
-   struct gl_framebuffer *fb = &stfb->Base;
-
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (ctx && ctx->DrawBuffer == &stfb->Base) {
-      st_flush( ctx->st, 
-		PIPE_FLUSH_RENDER_CACHE | 
-		PIPE_FLUSH_SWAPBUFFERS |
-		PIPE_FLUSH_FRAME,
-                NULL );
-   }
-
-   if (!fb->Visual.doubleBufferMode) {
-      /* single buffer mode - return pointers to front surfaces */
-      if (front_left) {
-         struct st_renderbuffer *strb =
-            st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-         *front_left = strb->surface;
-      }
-      if (front_right) {
-         struct st_renderbuffer *strb =
-            st_renderbuffer(fb->Attachment[BUFFER_FRONT_RIGHT].Renderbuffer);
-         *front_right = strb ? strb->surface : NULL;
-      }
-      return;
-   }
-
-   /* swap left buffers */
-   if (fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer &&
-       fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer) {
-      struct gl_renderbuffer *rbTemp;
-      rbTemp = fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer;
-      fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer =
-         fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer;
-      fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer = rbTemp;
-      if (front_left) {
-         struct st_renderbuffer *strb =
-            st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-         *front_left = strb->surface;
-      }
-      /* mark back buffer contents as undefined */
-      {
-         struct st_renderbuffer *back =
-            st_renderbuffer(fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer);
-         back->defined = GL_FALSE;
-      }
-   }
-   else {
-      /* no front buffer, display the back buffer */
-      if (front_left) {
-         struct st_renderbuffer *strb =
-            st_renderbuffer(fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer);
-         *front_left = strb->surface;
-      }
-   }
-
-   /* swap right buffers (for stereo) */
-   if (fb->Attachment[BUFFER_FRONT_RIGHT].Renderbuffer &&
-       fb->Attachment[BUFFER_BACK_RIGHT].Renderbuffer) {
-      struct gl_renderbuffer *rbTemp;
-      rbTemp = fb->Attachment[BUFFER_FRONT_RIGHT].Renderbuffer;
-      fb->Attachment[BUFFER_FRONT_RIGHT].Renderbuffer =
-         fb->Attachment[BUFFER_BACK_RIGHT].Renderbuffer;
-      fb->Attachment[BUFFER_BACK_RIGHT].Renderbuffer = rbTemp;
-      if (front_right) {
-         struct st_renderbuffer *strb =
-            st_renderbuffer(fb->Attachment[BUFFER_FRONT_RIGHT].Renderbuffer);
-         *front_right = strb->surface;
-      }
-      /* mark back buffer contents as undefined */
-      {
-         struct st_renderbuffer *back =
-            st_renderbuffer(fb->Attachment[BUFFER_BACK_RIGHT].Renderbuffer);
-         back->defined = GL_FALSE;
-      }
-   }
-   else {
-      /* no front right buffer, display back right buffer (if exists) */
-      if (front_right) {
-         struct st_renderbuffer *strb =
-            st_renderbuffer(fb->Attachment[BUFFER_BACK_RIGHT].Renderbuffer);
-         *front_right = strb ? strb->surface : NULL;
-      }
-   }
-
-   /* Update the _ColorDrawBuffers[] array and _ColorReadBuffer pointer */
-   _mesa_update_framebuffer(ctx);
-
-   /* Make sure we draw into the new back surface */
-   st_invalidate_state(ctx, _NEW_BUFFERS);
-}
-
-
-void *st_framebuffer_private( struct st_framebuffer *stfb )
-{
-   return stfb->Private;
-}
-
-void st_get_framebuffer_dimensions( struct st_framebuffer *stfb,
-				    uint *width,
-				    uint *height)
-{
-   *width = stfb->Base.Width;
-   *height = stfb->Base.Height;
-}
diff --git a/src/mesa/state_tracker/st_gen_mipmap.c b/src/mesa/state_tracker/st_gen_mipmap.c
index 030b0a0f065..f0fe31967c3 100644
--- a/src/mesa/state_tracker/st_gen_mipmap.c
+++ b/src/mesa/state_tracker/st_gen_mipmap.c
@@ -91,7 +91,7 @@ st_render_mipmap(struct st_context *st,
 
    /* check if we can render in the texture's format */
    if (!screen->is_format_supported(screen, psv->format, psv->texture->target,
-                                    PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
+                                    PIPE_BIND_RENDER_TARGET, 0)) {
       return FALSE;
    }
 
@@ -107,7 +107,7 @@ fallback_generate_mipmap(GLcontext *ctx, GLenum target,
                          struct gl_texture_object *texObj)
 {
    struct pipe_context *pipe = ctx->st->pipe;
-   struct pipe_texture *pt = st_get_texobj_texture(texObj);
+   struct pipe_resource *pt = st_get_texobj_texture(texObj);
    const uint baseLevel = texObj->BaseLevel;
    const uint lastLevel = pt->last_level;
    const uint face = _mesa_tex_target_to_face(target), zslice = 0;
@@ -142,11 +142,11 @@ fallback_generate_mipmap(GLcontext *ctx, GLenum target,
 						u_minify(pt->width0, dstLevel),
 						u_minify(pt->height0, dstLevel));
 
-      srcData = (ubyte *) pipe->transfer_map(pipe, srcTrans);
-      dstData = (ubyte *) pipe->transfer_map(pipe, dstTrans);
+      srcData = (ubyte *) pipe_transfer_map(pipe, srcTrans);
+      dstData = (ubyte *) pipe_transfer_map(pipe, dstTrans);
 
-      srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->texture->format);
-      dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->texture->format);
+      srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->resource->format);
+      dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->resource->format);
 
       _mesa_generate_mipmap_level(target, datatype, comps,
                                   0 /*border*/,
@@ -161,11 +161,11 @@ fallback_generate_mipmap(GLcontext *ctx, GLenum target,
                                   dstData,
                                   dstStride); /* stride in texels */
 
-      pipe->transfer_unmap(pipe, srcTrans);
-      pipe->transfer_unmap(pipe, dstTrans);
+      pipe_transfer_unmap(pipe, srcTrans);
+      pipe_transfer_unmap(pipe, dstTrans);
 
-      pipe->tex_transfer_destroy(pipe, srcTrans);
-      pipe->tex_transfer_destroy(pipe, dstTrans);
+      pipe->transfer_destroy(pipe, srcTrans);
+      pipe->transfer_destroy(pipe, dstTrans);
    }
 }
 
@@ -213,7 +213,7 @@ st_generate_mipmap(GLcontext *ctx, GLenum target,
 {
    struct st_context *st = ctx->st;
    struct st_texture_object *stObj = st_texture_object(texObj);
-   struct pipe_texture *pt = st_get_texobj_texture(texObj);
+   struct pipe_resource *pt = st_get_texobj_texture(texObj);
    const uint baseLevel = texObj->BaseLevel;
    uint lastLevel;
    uint dstLevel;
@@ -231,7 +231,7 @@ st_generate_mipmap(GLcontext *ctx, GLenum target,
       /* The current gallium texture doesn't have space for all the
        * mipmap levels we need to generate.  So allocate a new texture.
        */
-      struct pipe_texture *oldTex = stObj->pt;
+      struct pipe_resource *oldTex = stObj->pt;
       GLboolean needFlush;
 
       /* create new texture with space for more levels */
@@ -242,7 +242,7 @@ st_generate_mipmap(GLcontext *ctx, GLenum target,
                                     oldTex->width0,
                                     oldTex->height0,
                                     oldTex->depth0,
-                                    oldTex->tex_usage);
+                                    oldTex->bind);
 
       /* The texture isn't in a "complete" state yet so set the expected
        * lastLevel here, since it won't get done in st_finalize_texture().
@@ -255,7 +255,7 @@ st_generate_mipmap(GLcontext *ctx, GLenum target,
       st_finalize_texture(ctx, st->pipe, texObj, &needFlush);
 
       /* release the old tex (will likely be freed too) */
-      pipe_texture_reference(&oldTex, NULL);
+      pipe_resource_reference(&oldTex, NULL);
       pipe_sampler_view_reference(&stObj->sampler_view, NULL);
 
       pt = stObj->pt;
@@ -299,6 +299,6 @@ st_generate_mipmap(GLcontext *ctx, GLenum target,
       dstImage->TexFormat = srcImage->TexFormat;
 
       stImage = (struct st_texture_image *) dstImage;
-      pipe_texture_reference(&stImage->pt, pt);
+      pipe_resource_reference(&stImage->pt, pt);
    }
 }
diff --git a/src/mesa/state_tracker/st_inlines.h b/src/mesa/state_tracker/st_inlines.h
index 7fcde7b1a96..3bf7ba185e5 100644
--- a/src/mesa/state_tracker/st_inlines.h
+++ b/src/mesa/state_tracker/st_inlines.h
@@ -37,15 +37,16 @@
 #include "pipe/p_screen.h"
 #include "pipe/p_defines.h"
 #include "util/u_inlines.h"
+#include "util/u_box.h"
 #include "pipe/p_state.h"
 
 #include "st_context.h"
 #include "st_texture.h"
-#include "st_public.h"
+#include "st_cb_flush.h"
 
 static INLINE struct pipe_transfer *
 st_cond_flush_get_tex_transfer(struct st_context *st,
-			       struct pipe_texture *pt,
+			       struct pipe_resource *pt,
 			       unsigned int face,
 			       unsigned int level,
 			       unsigned int zslice,
@@ -54,15 +55,26 @@ st_cond_flush_get_tex_transfer(struct st_context *st,
 			       unsigned int w, unsigned int h)
 {
    struct pipe_context *context = st->pipe;
+   struct pipe_subresource subresource;
+   struct pipe_box box;
+
+   subresource.face = face;
+   subresource.level = level;
+
+   u_box_2d_zslice(x, y, zslice, w, h, &box);
 
    st_teximage_flush_before_map(st, pt, face, level, usage);
-   return context->get_tex_transfer(context, pt, face, level, zslice, usage,
-				    x, y, w, h);
+
+   return context->get_transfer(context, 
+				pt,
+				subresource,
+				usage,
+				&box);
 }
 
 static INLINE struct pipe_transfer *
 st_no_flush_get_tex_transfer(struct st_context *st,
-			     struct pipe_texture *pt,
+			     struct pipe_resource *pt,
 			     unsigned int face,
 			     unsigned int level,
 			     unsigned int zslice,
@@ -71,93 +83,76 @@ st_no_flush_get_tex_transfer(struct st_context *st,
 			     unsigned int w, unsigned int h)
 {
    struct pipe_context *context = st->pipe;
-
-   return context->get_tex_transfer(context, pt, face, level,
-				   zslice, usage, x, y, w, h);
-}
-
-static INLINE void *
-st_cond_flush_pipe_buffer_map(struct st_context *st,
-			      struct pipe_buffer *buf,
-			      unsigned int map_flags)
-{
-   struct pipe_context *pipe = st->pipe;
-   unsigned int referenced = pipe->is_buffer_referenced(pipe, buf);
-
-   if (referenced && ((referenced & PIPE_REFERENCED_FOR_WRITE) ||
-		      (map_flags & PIPE_BUFFER_USAGE_CPU_WRITE)))
-      st_flush(st, PIPE_FLUSH_RENDER_CACHE, NULL);
-
-   return pipe_buffer_map(pipe->screen, buf, map_flags);
-}
-
-static INLINE void *
-st_no_flush_pipe_buffer_map(struct st_context *st,
-			    struct pipe_buffer *buf,
-			    unsigned int map_flags)
-{
-   return pipe_buffer_map(st->pipe->screen, buf, map_flags);
+   struct pipe_box box;
+   struct pipe_subresource subresource = u_subresource( face, level );
+   
+   u_box_2d_zslice( x, y, zslice, 
+		    w, h,
+		    &box );
+
+   return context->get_transfer(context,
+				pt,
+				subresource,
+				usage,
+				&box);
 }
 
 
 static INLINE void
 st_cond_flush_pipe_buffer_write(struct st_context *st,
-				struct pipe_buffer *buf,
+				struct pipe_resource *buf,
 				unsigned int offset,
 				unsigned int size,
 				const void * data)
 {
    struct pipe_context *pipe = st->pipe;
 
-   if (pipe->is_buffer_referenced(pipe, buf))
-      st_flush(st, PIPE_FLUSH_RENDER_CACHE, NULL);
-
-   pipe_buffer_write(pipe->screen, buf, offset, size, data);
+   pipe_buffer_write(pipe, buf, offset, size, data);
 }
 
 static INLINE void
 st_no_flush_pipe_buffer_write(struct st_context *st,
-			      struct pipe_buffer *buf,
+			      struct pipe_resource *buf,
 			      unsigned int offset,
 			      unsigned int size,
 			      const void * data)
 {
-   pipe_buffer_write(st->pipe->screen, buf, offset, size, data);
+   pipe_buffer_write(st->pipe, buf, offset, size, data);
 }
 
 static INLINE void
 st_no_flush_pipe_buffer_write_nooverlap(struct st_context *st,
-                                        struct pipe_buffer *buf,
+                                        struct pipe_resource *buf,
                                         unsigned int offset,
                                         unsigned int size,
                                         const void * data)
 {
-   pipe_buffer_write_nooverlap(st->pipe->screen, buf, offset, size, data);
+   pipe_buffer_write_nooverlap(st->pipe, buf, offset, size, data);
 }
 
 static INLINE void
 st_cond_flush_pipe_buffer_read(struct st_context *st,
-			       struct pipe_buffer *buf,
+			       struct pipe_resource *buf,
 			       unsigned int offset,
 			       unsigned int size,
 			       void * data)
 {
    struct pipe_context *pipe = st->pipe;
 
-   if (pipe->is_buffer_referenced(pipe, buf) & PIPE_REFERENCED_FOR_WRITE)
+   if (pipe->is_resource_referenced(pipe, buf, 0, 0) & PIPE_REFERENCED_FOR_WRITE)
       st_flush(st, PIPE_FLUSH_RENDER_CACHE, NULL);
 
-   pipe_buffer_read(pipe->screen, buf, offset, size, data);
+   pipe_buffer_read(pipe, buf, offset, size, data);
 }
 
 static INLINE void
 st_no_flush_pipe_buffer_read(struct st_context *st,
-			     struct pipe_buffer *buf,
+			     struct pipe_resource *buf,
 			     unsigned int offset,
 			     unsigned int size,
 			     void * data)
 {
-   pipe_buffer_read(st->pipe->screen, buf, offset, size, data);
+   pipe_buffer_read(st->pipe, buf, offset, size, data);
 }
 
 #endif
diff --git a/src/mesa/state_tracker/st_manager.c b/src/mesa/state_tracker/st_manager.c
index cac62e4a14c..26f9554c9ec 100644
--- a/src/mesa/state_tracker/st_manager.c
+++ b/src/mesa/state_tracker/st_manager.c
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
@@ -149,7 +150,7 @@ static void
 st_framebuffer_validate(struct st_framebuffer *stfb, struct st_context *st)
 {
    struct pipe_screen *screen = st->pipe->screen;
-   struct pipe_texture *textures[ST_ATTACHMENT_COUNT];
+   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
    uint width, height;
    unsigned i;
    boolean changed = FALSE;
@@ -174,22 +175,22 @@ st_framebuffer_validate(struct st_framebuffer *stfb, struct st_context *st)
 
       idx = attachment_to_buffer_index(stfb->statts[i]);
       if (idx >= BUFFER_COUNT) {
-         pipe_texture_reference(&textures[i], NULL);
+         pipe_resource_reference(&textures[i], NULL);
          continue;
       }
 
       strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);
       assert(strb);
       if (strb->texture == textures[i]) {
-         pipe_texture_reference(&textures[i], NULL);
+         pipe_resource_reference(&textures[i], NULL);
          continue;
       }
 
       ps = screen->get_tex_surface(screen, textures[i], 0, 0, 0,
-            PIPE_BUFFER_USAGE_GPU_READ | PIPE_BUFFER_USAGE_GPU_WRITE);
+				   PIPE_BIND_RENDER_TARGET);
       if (ps) {
          pipe_surface_reference(&strb->surface, ps);
-         pipe_texture_reference(&strb->texture, ps->texture);
+         pipe_resource_reference(&strb->texture, ps->texture);
          /* ownership transfered */
          pipe_surface_reference(&ps, NULL);
 
@@ -202,7 +203,7 @@ st_framebuffer_validate(struct st_framebuffer *stfb, struct st_context *st)
          height = strb->Base.Height;
       }
 
-      pipe_texture_reference(&textures[i], NULL);
+      pipe_resource_reference(&textures[i], NULL);
    }
 
    if (changed) {
@@ -497,7 +498,7 @@ st_context_flush(struct st_context_iface *stctxi, unsigned flags,
 static boolean
 st_context_teximage(struct st_context_iface *stctxi, enum st_texture_type target,
                     int level, enum pipe_format internal_format,
-                    struct pipe_texture *tex, boolean mipmap)
+                    struct pipe_resource *tex, boolean mipmap)
 {
    struct st_context *st = (struct st_context *) stctxi;
    GLcontext *ctx = st->ctx;
@@ -556,7 +557,7 @@ st_context_teximage(struct st_context_iface *stctxi, enum st_texture_type target
    }
 
    stObj->pipe = st->pipe;
-   pipe_texture_reference(&stImage->pt, tex);
+   pipe_resource_reference(&stImage->pt, tex);
 
    _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
    _mesa_unlock_texture(ctx, texObj);
@@ -709,18 +710,38 @@ st_manager_flush_frontbuffer(struct st_context *st)
    if (!strb)
       return;
 
-   /* st_public.h */
-   if (!stfb->iface) {
-      struct pipe_surface *front_surf = strb->surface;
-      st->pipe->screen->flush_frontbuffer(st->pipe->screen,
-            front_surf, st->winsys_drawable_handle);
-      return;
-   }
-
    stfb->iface->flush_front(stfb->iface, ST_ATTACHMENT_FRONT_LEFT);
 }
 
 /**
+ * Return the surface of an EGLImage.
+ */
+struct pipe_surface *
+st_manager_get_egl_image_surface(struct st_context *st,
+                                 void *eglimg, unsigned usage)
+{
+   struct st_manager *smapi =
+      (struct st_manager *) st->iface.st_context_private;
+   struct st_egl_image stimg;
+   struct pipe_surface *ps;
+
+   if (!smapi || !smapi->get_egl_image)
+      return NULL;
+
+   memset(&stimg, 0, sizeof(stimg));
+   stimg.stctxi = &st->iface;
+   stimg.egl_image = eglimg;
+   if (!smapi->get_egl_image(smapi, &stimg))
+      return NULL;
+
+   ps = smapi->screen->get_tex_surface(smapi->screen,
+         stimg.texture, stimg.face, stimg.level, stimg.zslice, usage);
+   pipe_resource_reference(&stimg.texture, NULL);
+
+   return ps;
+}
+
+/**
  * Re-validate the framebuffers.
  */
 void
@@ -729,14 +750,6 @@ st_manager_validate_framebuffers(struct st_context *st)
    struct st_framebuffer *stdraw = st_ws_framebuffer(st->ctx->DrawBuffer);
    struct st_framebuffer *stread = st_ws_framebuffer(st->ctx->ReadBuffer);
 
-   /* st_public.h */
-   if ((stdraw && !stdraw->iface) || (stread && !stread->iface)) {
-      struct pipe_screen *screen = st->pipe->screen;
-      if (screen->update_buffer)
-         screen->update_buffer(screen, st->pipe->priv);
-      return;
-   }
-
    if (stdraw)
       st_framebuffer_validate(stdraw, st);
    if (stread && stread != stdraw)
@@ -752,8 +765,8 @@ st_manager_add_color_renderbuffer(struct st_context *st, GLframebuffer *fb,
 {
    struct st_framebuffer *stfb = st_ws_framebuffer(fb);
 
-   /* FBO or st_public.h */
-   if (!stfb || !stfb->iface)
+   /* FBO */
+   if (!stfb)
       return FALSE;
 
    if (stfb->Base.Attachment[idx].Renderbuffer)
diff --git a/src/mesa/state_tracker/st_manager.h b/src/mesa/state_tracker/st_manager.h
index a3f51992237..dabede4d64a 100644
--- a/src/mesa/state_tracker/st_manager.h
+++ b/src/mesa/state_tracker/st_manager.h
@@ -14,12 +14,13 @@
  * The above copyright notice and this permission notice 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,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * BRIAN PAUL 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.
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
  *
  * Authors:
  *    Chia-I Wu <olv@lunarg.com>
@@ -31,6 +32,10 @@
 #include "state_tracker/st_api.h"
 #include "st_context.h"
 
+struct pipe_surface *
+st_manager_get_egl_image_surface(struct st_context *st,
+                                 void *eglimg, unsigned usage);
+
 void
 st_manager_flush_frontbuffer(struct st_context *st);
 
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.c b/src/mesa/state_tracker/st_mesa_to_tgsi.c
index 807d21a7197..e8eb9ec3904 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.c
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.c
@@ -181,6 +181,7 @@ src_register( struct st_translate *t,
       ASSERT(index >= 0);
       if (ureg_dst_is_undef(t->temps[index]))
          t->temps[index] = ureg_DECL_temporary( t->ureg );
+      assert(index < Elements(t->temps));
       return ureg_src(t->temps[index]);
 
    case PROGRAM_NAMED_PARAM:
@@ -197,9 +198,11 @@ src_register( struct st_translate *t,
          return t->constants[index];
 
    case PROGRAM_INPUT:
+      assert(t->inputMapping[index] < Elements(t->inputs));
       return t->inputs[t->inputMapping[index]];
 
    case PROGRAM_OUTPUT:
+      assert(t->outputMapping[index] < Elements(t->outputs));
       return ureg_src(t->outputs[t->outputMapping[index]]); /* not needed? */
 
    case PROGRAM_ADDRESS:
@@ -739,6 +742,65 @@ emit_inverted_wpos( struct st_translate *t,
 
 
 /**
+ * Emit fragment position/ooordinate code.
+ */
+static void
+emit_wpos(struct st_context *st,
+          struct st_translate *t,
+          const struct gl_program *program,
+          struct ureg_program *ureg)
+{
+   const struct gl_fragment_program *fp =
+      (const struct gl_fragment_program *) program;
+   struct pipe_screen *pscreen = st->pipe->screen;
+   boolean invert = FALSE;
+
+   if (fp->OriginUpperLeft) {
+      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT)) {
+      }
+      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT)) {
+         ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);
+         invert = TRUE;
+      }
+      else
+         assert(0);
+   }
+   else {
+      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT))
+         ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);
+      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT))
+         invert = TRUE;
+      else
+         assert(0);
+   }
+   
+   if (fp->PixelCenterInteger) {
+      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER))
+         ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);
+      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER))
+         emit_adjusted_wpos(t, program, invert ? 0.5f : -0.5f);
+      else
+         assert(0);
+   }
+   else {
+      if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER)) {
+      }
+      else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) {
+         ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);
+         emit_adjusted_wpos(t, program, invert ? -0.5f : 0.5f);
+      }
+      else
+         assert(0);
+   }
+
+   /* we invert after adjustment so that we avoid the MOV to temporary,
+    * and reuse the adjustment ADD instead */
+   if (invert)
+      emit_inverted_wpos(t, program);
+}
+
+
+/**
  * OpenGL's fragment gl_FrontFace input is 1 for front-facing, 0 for back.
  * TGSI uses +1 for front, -1 for back.
  * This function converts the TGSI value to the GL value.  Simply clamping/
@@ -831,7 +893,6 @@ st_translate_mesa_program(
     * Declare input attributes.
     */
    if (procType == TGSI_PROCESSOR_FRAGMENT) {
-      struct gl_fragment_program* fp = (struct gl_fragment_program*)program;
       for (i = 0; i < numInputs; i++) {
          if (program->InputFlags[0] & PROG_PARAM_BIT_CYL_WRAP) {
             t->inputs[i] = ureg_DECL_fs_input_cyl(ureg,
@@ -852,51 +913,7 @@ st_translate_mesa_program(
          /* Must do this after setting up t->inputs, and before
           * emitting constant references, below:
           */
-         struct pipe_screen* pscreen = st_context(ctx)->pipe->screen;
-         boolean invert = FALSE;
-
-         if (fp->OriginUpperLeft) {
-            if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT)) {
-            }
-            else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT)) {
-               ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);
-               invert = TRUE;
-            }
-            else
-               assert(0);
-         }
-         else {
-            if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT))
-               ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);
-            else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT))
-               invert = TRUE;
-            else
-               assert(0);
-         }
-
-         if (fp->PixelCenterInteger) {
-            if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER))
-               ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);
-            else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER))
-               emit_adjusted_wpos(t, program, invert ? 0.5f : -0.5f);
-            else
-               assert(0);
-         }
-         else {
-            if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER)) {
-            }
-            else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) {
-               ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);
-               emit_adjusted_wpos(t, program, invert ? -0.5f : 0.5f);
-            }
-            else
-               assert(0);
-         }
-
-         /* we invert after adjustment so that we avoid the MOV to temporary,
-          * and reuse the adjustment ADD instead */
-         if (invert)
-            emit_inverted_wpos(t, program);
+         emit_wpos(st_context(ctx), t, program, ureg);
       }
 
       if (program->InputsRead & FRAG_BIT_FACE) {
@@ -943,8 +960,9 @@ st_translate_mesa_program(
                * do this before emitting the constant decls below, or this
                * will be missed:
                */
-            unsigned pointSizeClampConst = _mesa_add_state_reference(program->Parameters,
-                                                                     pointSizeClampState);
+            unsigned pointSizeClampConst =
+               _mesa_add_state_reference(program->Parameters,
+                                         pointSizeClampState);
             struct ureg_dst psizregtemp = ureg_DECL_temporary( ureg );
             t->pointSizeConst = ureg_DECL_constant( ureg, pointSizeClampConst );
             t->psizregreal = t->outputs[i];
@@ -963,12 +981,10 @@ st_translate_mesa_program(
       t->address[0] = ureg_DECL_address( ureg );
    }
 
-
    /* Emit constants and immediates.  Mesa uses a single index space
     * for these, so we put all the translated regs in t->constants.
     */
    if (program->Parameters) {
-      
       t->constants = CALLOC( program->Parameters->NumParameters,
                              sizeof t->constants[0] );
       if (t->constants == NULL) {
@@ -1023,7 +1039,8 @@ st_translate_mesa_program(
          possible early return */
       if (t->prevInstWrotePsiz && program->Id) {
          set_insn_start( t, ureg_get_instruction_number( ureg ));
-         ureg_MAX( t->ureg, ureg_writemask(t->outputs[t->psizoutindex], WRITEMASK_X),
+         ureg_MAX( t->ureg,
+                   ureg_writemask(t->outputs[t->psizoutindex], WRITEMASK_X),
                    ureg_src(t->outputs[t->psizoutindex]),
                    ureg_swizzle(t->pointSizeConst, 1,1,1,1));
          ureg_MIN( t->ureg, ureg_writemask(t->psizregreal, WRITEMASK_X),
diff --git a/src/mesa/state_tracker/st_public.h b/src/mesa/state_tracker/st_public.h
deleted file mode 100644
index 4b40d6d0448..00000000000
--- a/src/mesa/state_tracker/st_public.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/**************************************************************************
- * 
- * 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_PUBLIC_H
-#define ST_PUBLIC_H
-
-#include "GL/gl.h"
-#include "GL/internal/glcore.h"  /* for __GLcontextModes */
-
-#include "pipe/p_compiler.h"
-#include "pipe/p_format.h"
-
-/** Renderbuffer surfaces (should match Mesa names) */
-#define ST_SURFACE_FRONT_LEFT   0
-#define ST_SURFACE_BACK_LEFT    1
-#define ST_SURFACE_FRONT_RIGHT  2
-#define ST_SURFACE_BACK_RIGHT   3
-#define ST_SURFACE_DEPTH        4
-
-#define ST_TEXTURE_2D    0x2
-#define ST_TEXTURE_RECT  0x4
-
-#define ST_TEXTURE_RGB   0x1
-#define ST_TEXTURE_RGBA  0x2
-
-
-struct st_context;
-struct st_framebuffer;
-struct pipe_context;
-struct pipe_fence_handle;
-struct pipe_surface;
-struct pipe_texture;
-
-
-PUBLIC
-struct st_context *st_create_context(struct pipe_context *pipe,
-                                     const __GLcontextModes *visual,
-                                     struct st_context *share);
-
-PUBLIC
-void st_destroy_context( struct st_context *st );
-
-PUBLIC
-void st_copy_context_state(struct st_context *dst, struct st_context *src,
-                           uint mask);
-
-PUBLIC
-struct st_framebuffer *st_create_framebuffer( const __GLcontextModes *visual,
-                                              enum pipe_format colorFormat,
-                                              enum pipe_format depthFormat,
-                                              enum pipe_format stencilFormat,
-                                              uint width, uint height,
-                                              void *privateData);
-
-PUBLIC
-void st_resize_framebuffer( struct st_framebuffer *stfb,
-                            uint width, uint height );
-
-PUBLIC
-void st_set_framebuffer_surface(struct st_framebuffer *stfb,
-                                uint surfIndex, struct pipe_surface *surf);
-
-PUBLIC
-void st_get_framebuffer_dimensions( struct st_framebuffer *stfb,
-				    uint *width, uint *height);
-
-PUBLIC
-int st_get_framebuffer_surface(struct st_framebuffer *stfb,
-                               uint surfIndex, struct pipe_surface **surface);
-
-PUBLIC
-int st_get_framebuffer_texture(struct st_framebuffer *stfb,
-                               uint surfIndex, struct pipe_texture **texture);
-
-PUBLIC
-void *st_framebuffer_private( struct st_framebuffer *stfb );
-
-PUBLIC
-void st_unreference_framebuffer( struct st_framebuffer *stfb );
-
-PUBLIC
-GLboolean st_make_current(struct st_context *st,
-                          struct st_framebuffer *draw,
-                          struct st_framebuffer *read,
-                          void *winsys_drawable_handle);
-
-PUBLIC
-struct st_context *st_get_current(void);
-
-PUBLIC
-void st_flush( struct st_context *st, uint pipeFlushFlags,
-               struct pipe_fence_handle **fence );
-PUBLIC
-void st_finish( struct st_context *st );
-
-PUBLIC
-void st_notify_swapbuffers(struct st_framebuffer *stfb);
-
-PUBLIC
-void st_swapbuffers(struct st_framebuffer *stfb,
-                    struct pipe_surface **front_left,
-                    struct pipe_surface **front_right);
-
-PUBLIC
-int st_bind_texture_surface(struct pipe_surface *ps, int target, int level,
-                            enum pipe_format format);
-PUBLIC
-int st_unbind_texture_surface(struct pipe_surface *ps, int target, int level);
-
-/** Redirect rendering into stfb's surface to a texture image */
-PUBLIC
-int st_bind_teximage(struct st_framebuffer *stfb, uint surfIndex,
-                     int target, int format, int level);
-
-/** Undo surface-to-texture binding */
-PUBLIC
-int st_release_teximage(struct st_framebuffer *stfb, uint surfIndex,
-                        int target, int format, int level);
-
-
-/** Generic function type */
-typedef void (*st_proc)();
-
-PUBLIC
-st_proc st_get_proc_address(const char *procname);
-
-
-#endif
diff --git a/src/mesa/state_tracker/st_texture.c b/src/mesa/state_tracker/st_texture.c
index 5809927852d..2dcd9a879b9 100644
--- a/src/mesa/state_tracker/st_texture.c
+++ b/src/mesa/state_tracker/st_texture.c
@@ -27,14 +27,10 @@
 
 #include "st_context.h"
 #include "st_format.h"
-#include "st_public.h"
 #include "st_texture.h"
 #include "st_cb_fbo.h"
 #include "st_inlines.h"
 #include "main/enums.h"
-#include "main/texfetch.h"
-#include "main/teximage.h"
-#include "main/texobj.h"
 
 #undef Elements  /* fix re-defined macro warning */
 
@@ -69,12 +65,12 @@ target_to_target(GLenum target)
 
 
 /**
- * Allocate a new pipe_texture object
+ * Allocate a new pipe_resource object
  * width0, height0, depth0 are the dimensions of the level 0 image
  * (the highest resolution).  last_level indicates how many mipmap levels
  * to allocate storage for.  For non-mipmapped textures, this will be zero.
  */
-struct pipe_texture *
+struct pipe_resource *
 st_texture_create(struct st_context *st,
                   enum pipe_texture_target target,
 		  enum pipe_format format,
@@ -82,9 +78,9 @@ st_texture_create(struct st_context *st,
 		  GLuint width0,
 		  GLuint height0,
 		  GLuint depth0,
-                  GLuint usage )
+                  GLuint bind )
 {
-   struct pipe_texture pt, *newtex;
+   struct pipe_resource pt, *newtex;
    struct pipe_screen *screen = st->pipe->screen;
 
    assert(target <= PIPE_TEXTURE_CUBE);
@@ -95,7 +91,7 @@ st_texture_create(struct st_context *st,
 
    assert(format);
    assert(screen->is_format_supported(screen, format, target, 
-                                      PIPE_TEXTURE_USAGE_SAMPLER, 0));
+                                      PIPE_BIND_SAMPLER_VIEW, 0));
 
    memset(&pt, 0, sizeof(pt));
    pt.target = target;
@@ -104,9 +100,11 @@ st_texture_create(struct st_context *st,
    pt.width0 = width0;
    pt.height0 = height0;
    pt.depth0 = depth0;
-   pt.tex_usage = usage;
+   pt._usage = PIPE_USAGE_DEFAULT;
+   pt.bind = bind;
+   pt.flags = 0;
 
-   newtex = screen->texture_create(screen, &pt);
+   newtex = screen->resource_create(screen, &pt);
 
    assert(!newtex || pipe_is_referenced(&newtex->reference));
 
@@ -118,7 +116,7 @@ st_texture_create(struct st_context *st,
  * Check if a texture image can be pulled into a unified mipmap texture.
  */
 GLboolean
-st_texture_match_image(const struct pipe_texture *pt,
+st_texture_match_image(const struct pipe_resource *pt,
                        const struct gl_texture_image *image,
                        GLuint face, GLuint level)
 {
@@ -152,7 +150,7 @@ st_texture_match_image(const struct pipe_texture *pt,
  * These functions present that view to mesa:
  */
 const GLuint *
-st_texture_depth_offsets(struct pipe_texture *pt, GLuint level)
+st_texture_depth_offsets(struct pipe_resource *pt, GLuint level)
 {
    static const GLuint zero = 0;
 
@@ -168,7 +166,7 @@ st_texture_depth_offsets(struct pipe_texture *pt, GLuint level)
  * texture memory buffer, in bytes.
  */
 GLuint
-st_texture_image_offset(const struct pipe_texture * pt,
+st_texture_image_offset(const struct pipe_resource * pt,
                         GLuint face, GLuint level)
 {
    if (pt->target == PIPE_TEXTURE_CUBE)
@@ -192,7 +190,7 @@ st_texture_image_map(struct st_context *st, struct st_texture_image *stImage,
                      GLuint x, GLuint y, GLuint w, GLuint h)
 {
    struct pipe_context *pipe = st->pipe;
-   struct pipe_texture *pt = stImage->pt;
+   struct pipe_resource *pt = stImage->pt;
 
    DBG("%s \n", __FUNCTION__);
 
@@ -201,7 +199,7 @@ st_texture_image_map(struct st_context *st, struct st_texture_image *stImage,
 						    usage, x, y, w, h);
 
    if (stImage->transfer)
-      return pipe->transfer_map(pipe, stImage->transfer);
+      return pipe_transfer_map(pipe, stImage->transfer);
    else
       return NULL;
 }
@@ -215,9 +213,9 @@ st_texture_image_unmap(struct st_context *st,
 
    DBG("%s\n", __FUNCTION__);
 
-   pipe->transfer_unmap(pipe, stImage->transfer);
+   pipe_transfer_unmap(pipe, stImage->transfer);
 
-   pipe->tex_transfer_destroy(pipe, stImage->transfer);
+   pipe->transfer_destroy(pipe, stImage->transfer);
 }
 
 
@@ -237,18 +235,18 @@ st_surface_data(struct pipe_context *pipe,
 		const void *src, unsigned src_stride,
 		unsigned srcx, unsigned srcy, unsigned width, unsigned height)
 {
-   void *map = pipe->transfer_map(pipe, dst);
+   void *map = pipe_transfer_map(pipe, dst);
 
-   assert(dst->texture);
+   assert(dst->resource);
    util_copy_rect(map,
-                  dst->texture->format,
+                  dst->resource->format,
                   dst->stride,
                   dstx, dsty, 
                   width, height, 
                   src, src_stride, 
                   srcx, srcy);
 
-   pipe->transfer_unmap(pipe, dst);
+   pipe_transfer_unmap(pipe, dst);
 }
 
 
@@ -256,7 +254,7 @@ st_surface_data(struct pipe_context *pipe,
  */
 void
 st_texture_image_data(struct st_context *st,
-                      struct pipe_texture *dst,
+                      struct pipe_resource *dst,
                       GLuint face,
                       GLuint level,
                       void *src,
@@ -284,7 +282,7 @@ st_texture_image_data(struct st_context *st,
 		      u_minify(dst->width0, level),
                       u_minify(dst->height0, level));      /* width, height */
 
-      pipe->tex_transfer_destroy(pipe, dst_transfer);
+      pipe->transfer_destroy(pipe, dst_transfer);
 
       srcUB += src_image_stride;
    }
@@ -295,8 +293,8 @@ st_texture_image_data(struct st_context *st,
  */
 void
 st_texture_image_copy(struct pipe_context *pipe,
-                      struct pipe_texture *dst, GLuint dstLevel,
-                      struct pipe_texture *src,
+                      struct pipe_resource *dst, GLuint dstLevel,
+                      struct pipe_resource *src,
                       GLuint face)
 {
    struct pipe_screen *screen = pipe->screen;
@@ -337,10 +335,10 @@ st_texture_image_copy(struct pipe_context *pipe,
 #endif
 
       dst_surface = screen->get_tex_surface(screen, dst, face, dstLevel, i,
-                                            PIPE_BUFFER_USAGE_GPU_WRITE);
+                                            PIPE_BIND_BLIT_DESTINATION);
 
       src_surface = screen->get_tex_surface(screen, src, face, srcLevel, i,
-                                            PIPE_BUFFER_USAGE_GPU_READ);
+                                            PIPE_BIND_BLIT_SOURCE);
 
       pipe->surface_copy(pipe,
                          dst_surface,
@@ -355,235 +353,16 @@ st_texture_image_copy(struct pipe_context *pipe,
 }
 
 
-/**
- * Bind a pipe surface to a texture object.  After the call,
- * the texture object is marked dirty and will be (re-)validated.
- *
- * If this is the first surface bound, the texture object is said to
- * switch from normal to surface based.  It will be cleared first in
- * this case.
- *
- * \param ps      pipe surface to be unbound
- * \param target  texture target
- * \param level   image level
- * \param format  internal format of the texture
- */
-int
-st_bind_texture_surface(struct pipe_surface *ps, int target, int level,
-                        enum pipe_format format)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const GLuint unit = ctx->Texture.CurrentUnit;
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   struct st_texture_object *stObj;
-   struct st_texture_image *stImage;
-   GLenum internalFormat;
-
-   switch (target) {
-   case ST_TEXTURE_2D:
-      target = GL_TEXTURE_2D;
-      break;
-   case ST_TEXTURE_RECT:
-      target = GL_TEXTURE_RECTANGLE_ARB;
-      break;
-   default:
-      return 0;
-   }
-
-   /* map pipe format to base format for now */
-   if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3) > 0)
-      internalFormat = GL_RGBA;
-   else
-      internalFormat = GL_RGB;
-
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   _mesa_lock_texture(ctx, texObj);
-
-   stObj = st_texture_object(texObj);
-   /* switch to surface based */
-   if (!stObj->surface_based) {
-      _mesa_clear_texture_object(ctx, texObj);
-      stObj->surface_based = GL_TRUE;
-   }
-
-   texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-   stImage = st_texture_image(texImage);
-
-   _mesa_init_teximage_fields(ctx, target, texImage,
-                              ps->width, ps->height, 1, 0, internalFormat);
-   texImage->TexFormat = st_ChooseTextureFormat(ctx, internalFormat,
-                                                GL_RGBA, GL_UNSIGNED_BYTE);
-   _mesa_set_fetch_functions(texImage, 2);
-   pipe_texture_reference(&stImage->pt, ps->texture);
-
-   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
-   _mesa_unlock_texture(ctx, texObj);
-   
-   return 1;
-}
-
-
-/**
- * Unbind a pipe surface from a texture object.  After the call,
- * the texture object is marked dirty and will be (re-)validated.
- *
- * \param ps      pipe surface to be unbound
- * \param target  texture target
- * \param level   image level
- */
-int
-st_unbind_texture_surface(struct pipe_surface *ps, int target, int level)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const GLuint unit = ctx->Texture.CurrentUnit;
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   struct st_texture_object *stObj;
-   struct st_texture_image *stImage;
-
-   switch (target) {
-   case ST_TEXTURE_2D:
-      target = GL_TEXTURE_2D;
-      break;
-   case ST_TEXTURE_RECT:
-      target = GL_TEXTURE_RECTANGLE_ARB;
-      break;
-   default:
-      return 0;
-   }
-
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-
-   _mesa_lock_texture(ctx, texObj);
-
-   texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-   stObj = st_texture_object(texObj);
-   stImage = st_texture_image(texImage);
-
-   /* Make sure the pipe surface is still bound.  The texture object is still
-    * considered surface based even if this is the last bound surface. */
-   if (stImage->pt == ps->texture) {
-      pipe_texture_reference(&stImage->pt, NULL);
-      _mesa_clear_texture_image(ctx, texImage);
-
-      _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
-   }
-
-   _mesa_unlock_texture(ctx, texObj);
-   
-   return 1;
-}
-
-
-/** Redirect rendering into stfb's surface to a texture image */
-int
-st_bind_teximage(struct st_framebuffer *stfb, uint surfIndex,
-                 int target, int format, int level)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct st_context *st = ctx->st;
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *screen = pipe->screen;
-   const GLuint unit = ctx->Texture.CurrentUnit;
-   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   struct st_texture_image *stImage;
-   struct st_renderbuffer *strb;
-   GLint face = 0, slice = 0;
-
-   assert(surfIndex <= ST_SURFACE_DEPTH);
-
-   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
-
-   if (strb->texture_save || strb->surface_save) {
-      /* Error! */
-      return 0;
-   }
-
-   if (target == ST_TEXTURE_2D) {
-      texObj = texUnit->CurrentTex[TEXTURE_2D_INDEX];
-      texImage = _mesa_get_tex_image(ctx, texObj, GL_TEXTURE_2D, level);
-      stImage = st_texture_image(texImage);
-   }
-   else {
-      /* unsupported target */
-      return 0;
-   }
-
-   st_flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
-
-   /* save the renderbuffer's surface/texture info */
-   pipe_texture_reference(&strb->texture_save, strb->texture);
-   pipe_surface_reference(&strb->surface_save, strb->surface);
-   pipe_sampler_view_reference(&strb->sampler_view_save, strb->sampler_view);
-
-   /* plug in new surface/texture info */
-   pipe_texture_reference(&strb->texture, stImage->pt);
-
-   /* XXX: Shouldn't we release reference to old surface here?
-    */
-
-   strb->surface = screen->get_tex_surface(screen, strb->texture,
-                                           face, level, slice,
-                                           (PIPE_BUFFER_USAGE_GPU_READ |
-                                            PIPE_BUFFER_USAGE_GPU_WRITE));
-
-   pipe_sampler_view_reference(&strb->sampler_view, NULL);
-
-   st->dirty.st |= ST_NEW_FRAMEBUFFER;
-
-   return 1;
-}
-
-
-/** Undo surface-to-texture binding */
-int
-st_release_teximage(struct st_framebuffer *stfb, uint surfIndex,
-                    int target, int format, int level)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct st_context *st = ctx->st;
-   struct st_renderbuffer *strb;
-
-   assert(surfIndex <= ST_SURFACE_DEPTH);
-
-   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
-
-   if (!strb->texture_save || !strb->surface_save) {
-      /* Error! */
-      return 0;
-   }
-
-   st_flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
-
-   /* free tex surface, restore original */
-   pipe_surface_reference(&strb->surface, strb->surface_save);
-   pipe_texture_reference(&strb->texture, strb->texture_save);
-   pipe_sampler_view_reference(&strb->sampler_view, strb->sampler_view_save);
-
-   pipe_surface_reference(&strb->surface_save, NULL);
-   pipe_texture_reference(&strb->texture_save, NULL);
-   pipe_sampler_view_reference(&strb->sampler_view, NULL);
-
-   st->dirty.st |= ST_NEW_FRAMEBUFFER;
-
-   return 1;
-}
-
 void
 st_teximage_flush_before_map(struct st_context *st,
-			     struct pipe_texture *pt,
+			     struct pipe_resource *pt,
 			     unsigned int face,
 			     unsigned int level,
 			     enum pipe_transfer_usage usage)
 {
    struct pipe_context *pipe = st->pipe;
    unsigned referenced =
-      pipe->is_texture_referenced(pipe, pt, face, level);
+      pipe->is_resource_referenced(pipe, pt, face, level);
 
    if (referenced && ((referenced & PIPE_REFERENCED_FOR_WRITE) ||
 		      (usage & PIPE_TRANSFER_WRITE)))
diff --git a/src/mesa/state_tracker/st_texture.h b/src/mesa/state_tracker/st_texture.h
index c62f7f2cc0d..76ea7e6950a 100644
--- a/src/mesa/state_tracker/st_texture.h
+++ b/src/mesa/state_tracker/st_texture.h
@@ -35,7 +35,7 @@
 #include "main/mtypes.h"
 
 struct pipe_context;
-struct pipe_texture;
+struct pipe_resource;
 
 
 struct st_texture_image
@@ -51,7 +51,7 @@ struct st_texture_image
     * Else if stImage->base.Data != NULL, image is stored there.
     * Else there is no image data.
     */
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
 
    struct pipe_transfer *transfer;
 };
@@ -69,7 +69,7 @@ struct st_texture_object
    /* On validation any active images held in main memory or in other
     * textures will be copied to this texture and the old storage freed.
     */
-   struct pipe_texture *pt;
+   struct pipe_resource *pt;
 
    /* Default sampler view attached to this texture object. Created lazily
     * on first binding.
@@ -100,7 +100,7 @@ st_texture_object(struct gl_texture_object *obj)
 }
 
 
-static INLINE struct pipe_texture *
+static INLINE struct pipe_resource *
 st_get_texobj_texture(struct gl_texture_object *texObj)
 {
    struct st_texture_object *stObj = st_texture_object(texObj);
@@ -108,7 +108,7 @@ st_get_texobj_texture(struct gl_texture_object *texObj)
 }
 
 
-static INLINE struct pipe_texture *
+static INLINE struct pipe_resource *
 st_get_stobj_texture(struct st_texture_object *stObj)
 {
    return stObj ? stObj->pt : NULL;
@@ -117,7 +117,7 @@ st_get_stobj_texture(struct st_texture_object *stObj)
 
 static INLINE struct pipe_sampler_view *
 st_sampler_view_from_texture(struct pipe_context *pipe,
-                             struct pipe_texture *texture)
+                             struct pipe_resource *texture)
 {
    struct pipe_sampler_view templ;
 
@@ -144,7 +144,7 @@ st_get_stobj_sampler_view(struct st_texture_object *stObj)
 }
 
 
-extern struct pipe_texture *
+extern struct pipe_resource *
 st_texture_create(struct st_context *st,
                   enum pipe_texture_target target,
 		  enum pipe_format format,
@@ -158,7 +158,7 @@ st_texture_create(struct st_context *st,
 /* Check if an image fits into an existing texture object.
  */
 extern GLboolean
-st_texture_match_image(const struct pipe_texture *pt,
+st_texture_match_image(const struct pipe_resource *pt,
                        const struct gl_texture_image *image,
                        GLuint face, GLuint level);
 
@@ -182,17 +182,17 @@ st_texture_image_unmap(struct st_context *st,
  * value.
  */
 extern const GLuint *
-st_texture_depth_offsets(struct pipe_texture *pt, GLuint level);
+st_texture_depth_offsets(struct pipe_resource *pt, GLuint level);
 
 
 /* Return the linear offset of an image relative to the start of its region.
  */
 extern GLuint
-st_texture_image_offset(const struct pipe_texture *pt,
+st_texture_image_offset(const struct pipe_resource *pt,
                         GLuint face, GLuint level);
 
 extern GLuint
-st_texture_texel_offset(const struct pipe_texture * pt,
+st_texture_texel_offset(const struct pipe_resource * pt,
                         GLuint face, GLuint level,
                         GLuint col, GLuint row, GLuint img);
 
@@ -201,7 +201,7 @@ st_texture_texel_offset(const struct pipe_texture * pt,
  */
 extern void
 st_texture_image_data(struct st_context *st,
-                      struct pipe_texture *dst,
+                      struct pipe_resource *dst,
                       GLuint face, GLuint level, void *src,
                       GLuint src_row_pitch, GLuint src_image_pitch);
 
@@ -210,13 +210,13 @@ st_texture_image_data(struct st_context *st,
  */
 extern void
 st_texture_image_copy(struct pipe_context *pipe,
-                      struct pipe_texture *dst, GLuint dstLevel,
-                      struct pipe_texture *src,
+                      struct pipe_resource *dst, GLuint dstLevel,
+                      struct pipe_resource *src,
                       GLuint face);
 
 extern void
 st_teximage_flush_before_map(struct st_context *st,
-			     struct pipe_texture *pt,
+			     struct pipe_resource *pt,
 			     unsigned int face,
 			     unsigned int level,
 			     enum pipe_transfer_usage usage);
diff --git a/src/mesa/vbo/vbo.h b/src/mesa/vbo/vbo.h
index b24ecfd7cde..7a085f63c73 100644
--- a/src/mesa/vbo/vbo.h
+++ b/src/mesa/vbo/vbo.h
@@ -45,6 +45,7 @@ struct _mesa_prim {
    GLuint start;
    GLuint count;
    GLint basevertex;
+   GLsizei num_instances;
 };
 
 /* Would like to call this a "vbo_index_buffer", but this would be
diff --git a/src/mesa/vbo/vbo_exec_api.c b/src/mesa/vbo/vbo_exec_api.c
index e40f5f9dc44..e83bd9e4045 100644
--- a/src/mesa/vbo/vbo_exec_api.c
+++ b/src/mesa/vbo/vbo_exec_api.c
@@ -531,6 +531,7 @@ static void GLAPIENTRY vbo_exec_Begin( GLenum mode )
       exec->vtx.prim[i].pad = 0;
       exec->vtx.prim[i].start = exec->vtx.vert_count;
       exec->vtx.prim[i].count = 0;
+      exec->vtx.prim[i].num_instances = 1;
 
       ctx->Driver.CurrentExecPrimitive = mode;
    }
diff --git a/src/mesa/vbo/vbo_exec_array.c b/src/mesa/vbo/vbo_exec_array.c
index 90474da7c02..d4dbc8d2562 100644
--- a/src/mesa/vbo/vbo_exec_array.c
+++ b/src/mesa/vbo/vbo_exec_array.c
@@ -520,6 +520,7 @@ vbo_exec_DrawArrays(GLenum mode, GLint start, GLsizei count)
    prim[0].count = count;
    prim[0].indexed = 0;
    prim[0].basevertex = 0;
+   prim[0].num_instances = 1;
 
    vbo->draw_prims( ctx, exec->array.inputs, prim, 1, NULL,
                     GL_TRUE, start, start + count - 1 );
@@ -532,6 +533,62 @@ vbo_exec_DrawArrays(GLenum mode, GLint start, GLsizei count)
 }
 
 
+static void GLAPIENTRY
+vbo_exec_DrawArraysInstanced(GLenum mode, GLint start, GLsizei count,
+                             GLsizei primcount)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   struct vbo_context *vbo = vbo_context(ctx);
+   struct vbo_exec_context *exec = &vbo->exec;
+   struct _mesa_prim prim[1];
+
+   if (MESA_VERBOSE & VERBOSE_DRAW)
+      _mesa_debug(ctx, "glDrawArraysInstanced(%s, %d, %d, %d)\n",
+                  _mesa_lookup_enum_by_nr(mode), start, count, primcount);
+
+   if (!_mesa_validate_DrawArraysInstanced(ctx, mode, start, count, primcount))
+      return;
+
+   FLUSH_CURRENT( ctx, 0 );
+
+   if (!_mesa_valid_to_render(ctx, "glDrawArraysInstanced")) {
+      return;
+   }
+
+#if 0 /* debug */
+   check_draw_arrays_data(ctx, start, count);
+#endif
+
+   bind_arrays( ctx );
+
+   /* Again... because we may have changed the bitmask of per-vertex varying
+    * attributes.  If we regenerate the fixed-function vertex program now
+    * we may be able to prune down the number of vertex attributes which we
+    * need in the shader.
+    */
+   if (ctx->NewState)
+      _mesa_update_state( ctx );
+
+   prim[0].begin = 1;
+   prim[0].end = 1;
+   prim[0].weak = 0;
+   prim[0].pad = 0;
+   prim[0].mode = mode;
+   prim[0].start = start;
+   prim[0].count = count;
+   prim[0].indexed = 0;
+   prim[0].basevertex = 0;
+   prim[0].num_instances = primcount;
+
+   vbo->draw_prims( ctx, exec->array.inputs, prim, 1, NULL,
+                    GL_TRUE, start, start + count - 1 );
+
+#if 0 /* debug */
+   print_draw_arrays(ctx, exec, mode, start, count);
+#endif
+}
+
+
 /**
  * Map GL_ELEMENT_ARRAY_BUFFER and print contents.
  */
@@ -595,7 +652,7 @@ vbo_validated_drawrangeelements(GLcontext *ctx, GLenum mode,
 				GLuint start, GLuint end,
 				GLsizei count, GLenum type,
 				const GLvoid *indices,
-				GLint basevertex)
+				GLint basevertex, GLint primcount)
 {
    struct vbo_context *vbo = vbo_context(ctx);
    struct vbo_exec_context *exec = &vbo->exec;
@@ -628,6 +685,7 @@ vbo_validated_drawrangeelements(GLcontext *ctx, GLenum mode,
    prim[0].count = count;
    prim[0].indexed = 1;
    prim[0].basevertex = basevertex;
+   prim[0].num_instances = primcount;
 
    /* Need to give special consideration to rendering a range of
     * indices starting somewhere above zero.  Typically the
@@ -769,7 +827,7 @@ vbo_exec_DrawRangeElementsBaseVertex(GLenum mode,
 #endif
 
    vbo_validated_drawrangeelements(ctx, mode, GL_TRUE, start, end,
-				   count, type, indices, basevertex);
+				   count, type, indices, basevertex, 1);
 }
 
 
@@ -805,7 +863,7 @@ vbo_exec_DrawElements(GLenum mode, GLsizei count, GLenum type,
       return;
 
    vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
-				   count, type, indices, 0);
+				   count, type, indices, 0, 1);
 }
 
 
@@ -825,7 +883,27 @@ vbo_exec_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
       return;
 
    vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
-				   count, type, indices, basevertex);
+				   count, type, indices, basevertex, 1);
+}
+
+
+static void GLAPIENTRY
+vbo_exec_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
+                               const GLvoid *indices, GLsizei primcount)
+{
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (MESA_VERBOSE & VERBOSE_DRAW)
+      _mesa_debug(ctx, "glDrawElementsInstanced(%s, %d, %s, %p, %d)\n",
+                  _mesa_lookup_enum_by_nr(mode), count,
+                  _mesa_lookup_enum_by_nr(type), indices, primcount);
+
+   if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type, indices,
+                                             primcount))
+      return;
+
+   vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
+				   count, type, indices, 0, primcount);
 }
 
 
@@ -926,6 +1004,7 @@ vbo_validated_multidrawelements(GLcontext *ctx, GLenum mode,
 	 prim[i].start = ((uintptr_t)indices[i] - min_index_ptr) / index_type_size;
 	 prim[i].count = count[i];
 	 prim[i].indexed = 1;
+         prim[i].num_instances = 1;
 	 if (basevertex != NULL)
 	    prim[i].basevertex = basevertex[i];
 	 else
@@ -950,6 +1029,7 @@ vbo_validated_multidrawelements(GLcontext *ctx, GLenum mode,
 	 prim[0].start = 0;
 	 prim[0].count = count[i];
 	 prim[0].indexed = 1;
+         prim[0].num_instances = 1;
 	 if (basevertex != NULL)
 	    prim[0].basevertex = basevertex[i];
 	 else
@@ -1024,6 +1104,8 @@ vbo_exec_array_init( struct vbo_exec_context *exec )
    exec->vtxfmt.DrawElementsBaseVertex = vbo_exec_DrawElementsBaseVertex;
    exec->vtxfmt.DrawRangeElementsBaseVertex = vbo_exec_DrawRangeElementsBaseVertex;
    exec->vtxfmt.MultiDrawElementsBaseVertex = vbo_exec_MultiDrawElementsBaseVertex;
+   exec->vtxfmt.DrawArraysInstanced = vbo_exec_DrawArraysInstanced;
+   exec->vtxfmt.DrawElementsInstanced = vbo_exec_DrawElementsInstanced;
 #else
    exec->vtxfmt.DrawArrays = _mesa_noop_DrawArrays;
    exec->vtxfmt.DrawElements = _mesa_noop_DrawElements;
diff --git a/src/mesa/vbo/vbo_save_api.c b/src/mesa/vbo/vbo_save_api.c
index a5d027982f4..c867cb03f63 100644
--- a/src/mesa/vbo/vbo_save_api.c
+++ b/src/mesa/vbo/vbo_save_api.c
@@ -418,6 +418,7 @@ static void _save_wrap_buffers( GLcontext *ctx )
    save->prim[0].pad = 0;
    save->prim[0].start = 0;
    save->prim[0].count = 0;
+   save->prim[0].num_instances = 1;
    save->prim_count = 1;
 }
 
@@ -773,6 +774,7 @@ GLboolean vbo_save_NotifyBegin( GLcontext *ctx, GLenum mode )
    save->prim[i].pad = 0;
    save->prim[i].start = save->vert_count;
    save->prim[i].count = 0;   
+   save->prim[i].num_instances = 1;   
 
    _mesa_install_save_vtxfmt( ctx, &save->vtxfmt );      
    ctx->Driver.SaveNeedFlush = 1;
diff --git a/src/mesa/x86-64/glapi_x86-64.S b/src/mesa/x86-64/glapi_x86-64.S
index a76cbb07d5e..96930162175 100644
--- a/src/mesa/x86-64/glapi_x86-64.S
+++ b/src/mesa/x86-64/glapi_x86-64.S
@@ -16001,16 +16001,24 @@ GL_PREFIX(UniformMatrix4x3fv):
 	.size	GL_PREFIX(UniformMatrix4x3fv), .-GL_PREFIX(UniformMatrix4x3fv)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(LoadTransposeMatrixdARB)
-	.type	GL_PREFIX(LoadTransposeMatrixdARB), @function
-GL_PREFIX(LoadTransposeMatrixdARB):
+	.globl	GL_PREFIX(DrawArraysInstanced)
+	.type	GL_PREFIX(DrawArraysInstanced), @function
+GL_PREFIX(DrawArraysInstanced):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
 	movq	3440(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
+	popq	%rbp
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
 	popq	%rdi
 	movq	3440(%rax), %r11
 	jmp	*%r11
@@ -16022,24 +16030,40 @@ GL_PREFIX(LoadTransposeMatrixdARB):
 	jmp	*%r11
 1:
 	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%rbp
 	call	_glapi_get_dispatch
+	popq	%rbp
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
 	popq	%rdi
 	movq	3440(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(LoadTransposeMatrixdARB), .-GL_PREFIX(LoadTransposeMatrixdARB)
+	.size	GL_PREFIX(DrawArraysInstanced), .-GL_PREFIX(DrawArraysInstanced)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(LoadTransposeMatrixfARB)
-	.type	GL_PREFIX(LoadTransposeMatrixfARB), @function
-GL_PREFIX(LoadTransposeMatrixfARB):
+	.globl	GL_PREFIX(DrawElementsInstanced)
+	.type	GL_PREFIX(DrawElementsInstanced), @function
+GL_PREFIX(DrawElementsInstanced):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
 	movq	3448(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
 	call	_x86_64_get_dispatch@PLT
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
 	popq	%rdi
 	movq	3448(%rax), %r11
 	jmp	*%r11
@@ -16051,17 +16075,25 @@ GL_PREFIX(LoadTransposeMatrixfARB):
 	jmp	*%r11
 1:
 	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
 	call	_glapi_get_dispatch
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
 	popq	%rdi
 	movq	3448(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(LoadTransposeMatrixfARB), .-GL_PREFIX(LoadTransposeMatrixfARB)
+	.size	GL_PREFIX(DrawElementsInstanced), .-GL_PREFIX(DrawElementsInstanced)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(MultTransposeMatrixdARB)
-	.type	GL_PREFIX(MultTransposeMatrixdARB), @function
-GL_PREFIX(MultTransposeMatrixdARB):
+	.globl	GL_PREFIX(LoadTransposeMatrixdARB)
+	.type	GL_PREFIX(LoadTransposeMatrixdARB), @function
+GL_PREFIX(LoadTransposeMatrixdARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
 	movq	3456(%rax), %r11
@@ -16085,12 +16117,12 @@ GL_PREFIX(MultTransposeMatrixdARB):
 	movq	3456(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(MultTransposeMatrixdARB), .-GL_PREFIX(MultTransposeMatrixdARB)
+	.size	GL_PREFIX(LoadTransposeMatrixdARB), .-GL_PREFIX(LoadTransposeMatrixdARB)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(MultTransposeMatrixfARB)
-	.type	GL_PREFIX(MultTransposeMatrixfARB), @function
-GL_PREFIX(MultTransposeMatrixfARB):
+	.globl	GL_PREFIX(LoadTransposeMatrixfARB)
+	.type	GL_PREFIX(LoadTransposeMatrixfARB), @function
+GL_PREFIX(LoadTransposeMatrixfARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
 	movq	3464(%rax), %r11
@@ -16114,6 +16146,64 @@ GL_PREFIX(MultTransposeMatrixfARB):
 	movq	3464(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(LoadTransposeMatrixfARB), .-GL_PREFIX(LoadTransposeMatrixfARB)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(MultTransposeMatrixdARB)
+	.type	GL_PREFIX(MultTransposeMatrixdARB), @function
+GL_PREFIX(MultTransposeMatrixdARB):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	3472(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	call	_x86_64_get_dispatch@PLT
+	popq	%rdi
+	movq	3472(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	3472(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	call	_glapi_get_dispatch
+	popq	%rdi
+	movq	3472(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(MultTransposeMatrixdARB), .-GL_PREFIX(MultTransposeMatrixdARB)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(MultTransposeMatrixfARB)
+	.type	GL_PREFIX(MultTransposeMatrixfARB), @function
+GL_PREFIX(MultTransposeMatrixfARB):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	3480(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	call	_x86_64_get_dispatch@PLT
+	popq	%rdi
+	movq	3480(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	3480(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	call	_glapi_get_dispatch
+	popq	%rdi
+	movq	3480(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(MultTransposeMatrixfARB), .-GL_PREFIX(MultTransposeMatrixfARB)
 
 	.p2align	4,,15
@@ -16122,7 +16212,7 @@ GL_PREFIX(MultTransposeMatrixfARB):
 GL_PREFIX(SampleCoverageARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3472(%rax), %r11
+	movq	3488(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16132,13 +16222,13 @@ GL_PREFIX(SampleCoverageARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3472(%rax), %r11
+	movq	3488(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3472(%rax), %r11
+	movq	3488(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16148,7 +16238,7 @@ GL_PREFIX(SampleCoverageARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3472(%rax), %r11
+	movq	3488(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SampleCoverageARB), .-GL_PREFIX(SampleCoverageARB)
@@ -16159,7 +16249,7 @@ GL_PREFIX(SampleCoverageARB):
 GL_PREFIX(CompressedTexImage1DARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3480(%rax), %r11
+	movq	3496(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16177,13 +16267,13 @@ GL_PREFIX(CompressedTexImage1DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3480(%rax), %r11
+	movq	3496(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3480(%rax), %r11
+	movq	3496(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16201,7 +16291,7 @@ GL_PREFIX(CompressedTexImage1DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3480(%rax), %r11
+	movq	3496(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CompressedTexImage1DARB), .-GL_PREFIX(CompressedTexImage1DARB)
@@ -16212,7 +16302,7 @@ GL_PREFIX(CompressedTexImage1DARB):
 GL_PREFIX(CompressedTexImage2DARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3488(%rax), %r11
+	movq	3504(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16230,13 +16320,13 @@ GL_PREFIX(CompressedTexImage2DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3488(%rax), %r11
+	movq	3504(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3488(%rax), %r11
+	movq	3504(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16254,7 +16344,7 @@ GL_PREFIX(CompressedTexImage2DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3488(%rax), %r11
+	movq	3504(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CompressedTexImage2DARB), .-GL_PREFIX(CompressedTexImage2DARB)
@@ -16265,7 +16355,7 @@ GL_PREFIX(CompressedTexImage2DARB):
 GL_PREFIX(CompressedTexImage3DARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3496(%rax), %r11
+	movq	3512(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16283,13 +16373,13 @@ GL_PREFIX(CompressedTexImage3DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3496(%rax), %r11
+	movq	3512(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3496(%rax), %r11
+	movq	3512(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16307,7 +16397,7 @@ GL_PREFIX(CompressedTexImage3DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3496(%rax), %r11
+	movq	3512(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CompressedTexImage3DARB), .-GL_PREFIX(CompressedTexImage3DARB)
@@ -16318,7 +16408,7 @@ GL_PREFIX(CompressedTexImage3DARB):
 GL_PREFIX(CompressedTexSubImage1DARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3504(%rax), %r11
+	movq	3520(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16336,13 +16426,13 @@ GL_PREFIX(CompressedTexSubImage1DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3504(%rax), %r11
+	movq	3520(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3504(%rax), %r11
+	movq	3520(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16360,7 +16450,7 @@ GL_PREFIX(CompressedTexSubImage1DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3504(%rax), %r11
+	movq	3520(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CompressedTexSubImage1DARB), .-GL_PREFIX(CompressedTexSubImage1DARB)
@@ -16371,7 +16461,7 @@ GL_PREFIX(CompressedTexSubImage1DARB):
 GL_PREFIX(CompressedTexSubImage2DARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3512(%rax), %r11
+	movq	3528(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16389,13 +16479,13 @@ GL_PREFIX(CompressedTexSubImage2DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3512(%rax), %r11
+	movq	3528(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3512(%rax), %r11
+	movq	3528(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16413,7 +16503,7 @@ GL_PREFIX(CompressedTexSubImage2DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3512(%rax), %r11
+	movq	3528(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CompressedTexSubImage2DARB), .-GL_PREFIX(CompressedTexSubImage2DARB)
@@ -16424,7 +16514,7 @@ GL_PREFIX(CompressedTexSubImage2DARB):
 GL_PREFIX(CompressedTexSubImage3DARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3520(%rax), %r11
+	movq	3536(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16442,13 +16532,13 @@ GL_PREFIX(CompressedTexSubImage3DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3520(%rax), %r11
+	movq	3536(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3520(%rax), %r11
+	movq	3536(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16466,7 +16556,7 @@ GL_PREFIX(CompressedTexSubImage3DARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3520(%rax), %r11
+	movq	3536(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CompressedTexSubImage3DARB), .-GL_PREFIX(CompressedTexSubImage3DARB)
@@ -16477,7 +16567,7 @@ GL_PREFIX(CompressedTexSubImage3DARB):
 GL_PREFIX(GetCompressedTexImageARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3528(%rax), %r11
+	movq	3544(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16487,13 +16577,13 @@ GL_PREFIX(GetCompressedTexImageARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3528(%rax), %r11
+	movq	3544(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3528(%rax), %r11
+	movq	3544(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16503,7 +16593,7 @@ GL_PREFIX(GetCompressedTexImageARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3528(%rax), %r11
+	movq	3544(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetCompressedTexImageARB), .-GL_PREFIX(GetCompressedTexImageARB)
@@ -16514,25 +16604,25 @@ GL_PREFIX(GetCompressedTexImageARB):
 GL_PREFIX(DisableVertexAttribArrayARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3536(%rax), %r11
+	movq	3552(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	3536(%rax), %r11
+	movq	3552(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3536(%rax), %r11
+	movq	3552(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	3536(%rax), %r11
+	movq	3552(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DisableVertexAttribArrayARB), .-GL_PREFIX(DisableVertexAttribArrayARB)
@@ -16543,25 +16633,25 @@ GL_PREFIX(DisableVertexAttribArrayARB):
 GL_PREFIX(EnableVertexAttribArrayARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3544(%rax), %r11
+	movq	3560(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	3544(%rax), %r11
+	movq	3560(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3544(%rax), %r11
+	movq	3560(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	3544(%rax), %r11
+	movq	3560(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EnableVertexAttribArrayARB), .-GL_PREFIX(EnableVertexAttribArrayARB)
@@ -16572,7 +16662,7 @@ GL_PREFIX(EnableVertexAttribArrayARB):
 GL_PREFIX(GetProgramEnvParameterdvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3552(%rax), %r11
+	movq	3568(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16582,13 +16672,13 @@ GL_PREFIX(GetProgramEnvParameterdvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3552(%rax), %r11
+	movq	3568(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3552(%rax), %r11
+	movq	3568(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16598,7 +16688,7 @@ GL_PREFIX(GetProgramEnvParameterdvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3552(%rax), %r11
+	movq	3568(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramEnvParameterdvARB), .-GL_PREFIX(GetProgramEnvParameterdvARB)
@@ -16609,7 +16699,7 @@ GL_PREFIX(GetProgramEnvParameterdvARB):
 GL_PREFIX(GetProgramEnvParameterfvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3560(%rax), %r11
+	movq	3576(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16619,13 +16709,13 @@ GL_PREFIX(GetProgramEnvParameterfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3560(%rax), %r11
+	movq	3576(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3560(%rax), %r11
+	movq	3576(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16635,7 +16725,7 @@ GL_PREFIX(GetProgramEnvParameterfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3560(%rax), %r11
+	movq	3576(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramEnvParameterfvARB), .-GL_PREFIX(GetProgramEnvParameterfvARB)
@@ -16646,7 +16736,7 @@ GL_PREFIX(GetProgramEnvParameterfvARB):
 GL_PREFIX(GetProgramLocalParameterdvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3568(%rax), %r11
+	movq	3584(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16656,13 +16746,13 @@ GL_PREFIX(GetProgramLocalParameterdvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3568(%rax), %r11
+	movq	3584(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3568(%rax), %r11
+	movq	3584(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16672,7 +16762,7 @@ GL_PREFIX(GetProgramLocalParameterdvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3568(%rax), %r11
+	movq	3584(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramLocalParameterdvARB), .-GL_PREFIX(GetProgramLocalParameterdvARB)
@@ -16683,7 +16773,7 @@ GL_PREFIX(GetProgramLocalParameterdvARB):
 GL_PREFIX(GetProgramLocalParameterfvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3576(%rax), %r11
+	movq	3592(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16693,13 +16783,13 @@ GL_PREFIX(GetProgramLocalParameterfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3576(%rax), %r11
+	movq	3592(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3576(%rax), %r11
+	movq	3592(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16709,7 +16799,7 @@ GL_PREFIX(GetProgramLocalParameterfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3576(%rax), %r11
+	movq	3592(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramLocalParameterfvARB), .-GL_PREFIX(GetProgramLocalParameterfvARB)
@@ -16720,7 +16810,7 @@ GL_PREFIX(GetProgramLocalParameterfvARB):
 GL_PREFIX(GetProgramStringARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3584(%rax), %r11
+	movq	3600(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16730,13 +16820,13 @@ GL_PREFIX(GetProgramStringARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3584(%rax), %r11
+	movq	3600(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3584(%rax), %r11
+	movq	3600(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16746,7 +16836,7 @@ GL_PREFIX(GetProgramStringARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3584(%rax), %r11
+	movq	3600(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramStringARB), .-GL_PREFIX(GetProgramStringARB)
@@ -16757,7 +16847,7 @@ GL_PREFIX(GetProgramStringARB):
 GL_PREFIX(GetProgramivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3592(%rax), %r11
+	movq	3608(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16767,13 +16857,13 @@ GL_PREFIX(GetProgramivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3592(%rax), %r11
+	movq	3608(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3592(%rax), %r11
+	movq	3608(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16783,7 +16873,7 @@ GL_PREFIX(GetProgramivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3592(%rax), %r11
+	movq	3608(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramivARB), .-GL_PREFIX(GetProgramivARB)
@@ -16794,7 +16884,7 @@ GL_PREFIX(GetProgramivARB):
 GL_PREFIX(GetVertexAttribdvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3600(%rax), %r11
+	movq	3616(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16804,13 +16894,13 @@ GL_PREFIX(GetVertexAttribdvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3600(%rax), %r11
+	movq	3616(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3600(%rax), %r11
+	movq	3616(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16820,7 +16910,7 @@ GL_PREFIX(GetVertexAttribdvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3600(%rax), %r11
+	movq	3616(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribdvARB), .-GL_PREFIX(GetVertexAttribdvARB)
@@ -16831,7 +16921,7 @@ GL_PREFIX(GetVertexAttribdvARB):
 GL_PREFIX(GetVertexAttribfvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3608(%rax), %r11
+	movq	3624(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16841,13 +16931,13 @@ GL_PREFIX(GetVertexAttribfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3608(%rax), %r11
+	movq	3624(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3608(%rax), %r11
+	movq	3624(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16857,7 +16947,7 @@ GL_PREFIX(GetVertexAttribfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3608(%rax), %r11
+	movq	3624(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribfvARB), .-GL_PREFIX(GetVertexAttribfvARB)
@@ -16868,7 +16958,7 @@ GL_PREFIX(GetVertexAttribfvARB):
 GL_PREFIX(GetVertexAttribivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3616(%rax), %r11
+	movq	3632(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16878,13 +16968,13 @@ GL_PREFIX(GetVertexAttribivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3616(%rax), %r11
+	movq	3632(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3616(%rax), %r11
+	movq	3632(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16894,7 +16984,7 @@ GL_PREFIX(GetVertexAttribivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3616(%rax), %r11
+	movq	3632(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribivARB), .-GL_PREFIX(GetVertexAttribivARB)
@@ -16905,7 +16995,7 @@ GL_PREFIX(GetVertexAttribivARB):
 GL_PREFIX(ProgramEnvParameter4dARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3624(%rax), %r11
+	movq	3640(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$56, %rsp
@@ -16923,13 +17013,13 @@ GL_PREFIX(ProgramEnvParameter4dARB):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	3624(%rax), %r11
+	movq	3640(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3624(%rax), %r11
+	movq	3640(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$56, %rsp
@@ -16947,7 +17037,7 @@ GL_PREFIX(ProgramEnvParameter4dARB):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	3624(%rax), %r11
+	movq	3640(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramEnvParameter4dARB), .-GL_PREFIX(ProgramEnvParameter4dARB)
@@ -16958,7 +17048,7 @@ GL_PREFIX(ProgramEnvParameter4dARB):
 GL_PREFIX(ProgramEnvParameter4dvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3632(%rax), %r11
+	movq	3648(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -16968,13 +17058,13 @@ GL_PREFIX(ProgramEnvParameter4dvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3632(%rax), %r11
+	movq	3648(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3632(%rax), %r11
+	movq	3648(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -16984,7 +17074,7 @@ GL_PREFIX(ProgramEnvParameter4dvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3632(%rax), %r11
+	movq	3648(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramEnvParameter4dvARB), .-GL_PREFIX(ProgramEnvParameter4dvARB)
@@ -16995,7 +17085,7 @@ GL_PREFIX(ProgramEnvParameter4dvARB):
 GL_PREFIX(ProgramEnvParameter4fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3640(%rax), %r11
+	movq	3656(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$56, %rsp
@@ -17013,13 +17103,13 @@ GL_PREFIX(ProgramEnvParameter4fARB):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	3640(%rax), %r11
+	movq	3656(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3640(%rax), %r11
+	movq	3656(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$56, %rsp
@@ -17037,7 +17127,7 @@ GL_PREFIX(ProgramEnvParameter4fARB):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	3640(%rax), %r11
+	movq	3656(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramEnvParameter4fARB), .-GL_PREFIX(ProgramEnvParameter4fARB)
@@ -17048,7 +17138,7 @@ GL_PREFIX(ProgramEnvParameter4fARB):
 GL_PREFIX(ProgramEnvParameter4fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3648(%rax), %r11
+	movq	3664(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17058,13 +17148,13 @@ GL_PREFIX(ProgramEnvParameter4fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3648(%rax), %r11
+	movq	3664(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3648(%rax), %r11
+	movq	3664(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17074,7 +17164,7 @@ GL_PREFIX(ProgramEnvParameter4fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3648(%rax), %r11
+	movq	3664(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramEnvParameter4fvARB), .-GL_PREFIX(ProgramEnvParameter4fvARB)
@@ -17085,7 +17175,7 @@ GL_PREFIX(ProgramEnvParameter4fvARB):
 GL_PREFIX(ProgramLocalParameter4dARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3656(%rax), %r11
+	movq	3672(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$56, %rsp
@@ -17103,13 +17193,13 @@ GL_PREFIX(ProgramLocalParameter4dARB):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	3656(%rax), %r11
+	movq	3672(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3656(%rax), %r11
+	movq	3672(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$56, %rsp
@@ -17127,7 +17217,7 @@ GL_PREFIX(ProgramLocalParameter4dARB):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	3656(%rax), %r11
+	movq	3672(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramLocalParameter4dARB), .-GL_PREFIX(ProgramLocalParameter4dARB)
@@ -17138,7 +17228,7 @@ GL_PREFIX(ProgramLocalParameter4dARB):
 GL_PREFIX(ProgramLocalParameter4dvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3664(%rax), %r11
+	movq	3680(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17148,13 +17238,13 @@ GL_PREFIX(ProgramLocalParameter4dvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3664(%rax), %r11
+	movq	3680(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3664(%rax), %r11
+	movq	3680(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17164,7 +17254,7 @@ GL_PREFIX(ProgramLocalParameter4dvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3664(%rax), %r11
+	movq	3680(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramLocalParameter4dvARB), .-GL_PREFIX(ProgramLocalParameter4dvARB)
@@ -17175,7 +17265,7 @@ GL_PREFIX(ProgramLocalParameter4dvARB):
 GL_PREFIX(ProgramLocalParameter4fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3672(%rax), %r11
+	movq	3688(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$56, %rsp
@@ -17193,13 +17283,13 @@ GL_PREFIX(ProgramLocalParameter4fARB):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	3672(%rax), %r11
+	movq	3688(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3672(%rax), %r11
+	movq	3688(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$56, %rsp
@@ -17217,7 +17307,7 @@ GL_PREFIX(ProgramLocalParameter4fARB):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	3672(%rax), %r11
+	movq	3688(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramLocalParameter4fARB), .-GL_PREFIX(ProgramLocalParameter4fARB)
@@ -17228,7 +17318,7 @@ GL_PREFIX(ProgramLocalParameter4fARB):
 GL_PREFIX(ProgramLocalParameter4fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3680(%rax), %r11
+	movq	3696(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17238,13 +17328,13 @@ GL_PREFIX(ProgramLocalParameter4fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3680(%rax), %r11
+	movq	3696(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3680(%rax), %r11
+	movq	3696(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17254,7 +17344,7 @@ GL_PREFIX(ProgramLocalParameter4fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3680(%rax), %r11
+	movq	3696(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramLocalParameter4fvARB), .-GL_PREFIX(ProgramLocalParameter4fvARB)
@@ -17265,7 +17355,7 @@ GL_PREFIX(ProgramLocalParameter4fvARB):
 GL_PREFIX(ProgramStringARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3688(%rax), %r11
+	movq	3704(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17279,13 +17369,13 @@ GL_PREFIX(ProgramStringARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3688(%rax), %r11
+	movq	3704(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3688(%rax), %r11
+	movq	3704(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17299,7 +17389,7 @@ GL_PREFIX(ProgramStringARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3688(%rax), %r11
+	movq	3704(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramStringARB), .-GL_PREFIX(ProgramStringARB)
@@ -17310,7 +17400,7 @@ GL_PREFIX(ProgramStringARB):
 GL_PREFIX(VertexAttrib1dARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3696(%rax), %r11
+	movq	3712(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -17320,13 +17410,13 @@ GL_PREFIX(VertexAttrib1dARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	3696(%rax), %r11
+	movq	3712(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3696(%rax), %r11
+	movq	3712(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -17336,7 +17426,7 @@ GL_PREFIX(VertexAttrib1dARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	3696(%rax), %r11
+	movq	3712(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1dARB), .-GL_PREFIX(VertexAttrib1dARB)
@@ -17347,7 +17437,7 @@ GL_PREFIX(VertexAttrib1dARB):
 GL_PREFIX(VertexAttrib1dvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3704(%rax), %r11
+	movq	3720(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17357,13 +17447,13 @@ GL_PREFIX(VertexAttrib1dvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3704(%rax), %r11
+	movq	3720(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3704(%rax), %r11
+	movq	3720(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17373,7 +17463,7 @@ GL_PREFIX(VertexAttrib1dvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3704(%rax), %r11
+	movq	3720(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1dvARB), .-GL_PREFIX(VertexAttrib1dvARB)
@@ -17384,7 +17474,7 @@ GL_PREFIX(VertexAttrib1dvARB):
 GL_PREFIX(VertexAttrib1fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3712(%rax), %r11
+	movq	3728(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -17394,13 +17484,13 @@ GL_PREFIX(VertexAttrib1fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	3712(%rax), %r11
+	movq	3728(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3712(%rax), %r11
+	movq	3728(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -17410,7 +17500,7 @@ GL_PREFIX(VertexAttrib1fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	3712(%rax), %r11
+	movq	3728(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1fARB), .-GL_PREFIX(VertexAttrib1fARB)
@@ -17421,7 +17511,7 @@ GL_PREFIX(VertexAttrib1fARB):
 GL_PREFIX(VertexAttrib1fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3720(%rax), %r11
+	movq	3736(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17431,13 +17521,13 @@ GL_PREFIX(VertexAttrib1fvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3720(%rax), %r11
+	movq	3736(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3720(%rax), %r11
+	movq	3736(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17447,7 +17537,7 @@ GL_PREFIX(VertexAttrib1fvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3720(%rax), %r11
+	movq	3736(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1fvARB), .-GL_PREFIX(VertexAttrib1fvARB)
@@ -17458,7 +17548,7 @@ GL_PREFIX(VertexAttrib1fvARB):
 GL_PREFIX(VertexAttrib1sARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3728(%rax), %r11
+	movq	3744(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17468,13 +17558,13 @@ GL_PREFIX(VertexAttrib1sARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3728(%rax), %r11
+	movq	3744(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3728(%rax), %r11
+	movq	3744(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17484,7 +17574,7 @@ GL_PREFIX(VertexAttrib1sARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3728(%rax), %r11
+	movq	3744(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1sARB), .-GL_PREFIX(VertexAttrib1sARB)
@@ -17495,7 +17585,7 @@ GL_PREFIX(VertexAttrib1sARB):
 GL_PREFIX(VertexAttrib1svARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3736(%rax), %r11
+	movq	3752(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17505,13 +17595,13 @@ GL_PREFIX(VertexAttrib1svARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3736(%rax), %r11
+	movq	3752(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3736(%rax), %r11
+	movq	3752(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17521,7 +17611,7 @@ GL_PREFIX(VertexAttrib1svARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3736(%rax), %r11
+	movq	3752(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1svARB), .-GL_PREFIX(VertexAttrib1svARB)
@@ -17532,7 +17622,7 @@ GL_PREFIX(VertexAttrib1svARB):
 GL_PREFIX(VertexAttrib2dARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3744(%rax), %r11
+	movq	3760(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -17544,13 +17634,13 @@ GL_PREFIX(VertexAttrib2dARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	3744(%rax), %r11
+	movq	3760(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3744(%rax), %r11
+	movq	3760(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -17562,7 +17652,7 @@ GL_PREFIX(VertexAttrib2dARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	3744(%rax), %r11
+	movq	3760(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2dARB), .-GL_PREFIX(VertexAttrib2dARB)
@@ -17573,7 +17663,7 @@ GL_PREFIX(VertexAttrib2dARB):
 GL_PREFIX(VertexAttrib2dvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3752(%rax), %r11
+	movq	3768(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17583,13 +17673,13 @@ GL_PREFIX(VertexAttrib2dvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3752(%rax), %r11
+	movq	3768(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3752(%rax), %r11
+	movq	3768(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17599,7 +17689,7 @@ GL_PREFIX(VertexAttrib2dvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3752(%rax), %r11
+	movq	3768(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2dvARB), .-GL_PREFIX(VertexAttrib2dvARB)
@@ -17610,7 +17700,7 @@ GL_PREFIX(VertexAttrib2dvARB):
 GL_PREFIX(VertexAttrib2fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3760(%rax), %r11
+	movq	3776(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -17622,13 +17712,13 @@ GL_PREFIX(VertexAttrib2fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	3760(%rax), %r11
+	movq	3776(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3760(%rax), %r11
+	movq	3776(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -17640,7 +17730,7 @@ GL_PREFIX(VertexAttrib2fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	3760(%rax), %r11
+	movq	3776(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2fARB), .-GL_PREFIX(VertexAttrib2fARB)
@@ -17651,7 +17741,7 @@ GL_PREFIX(VertexAttrib2fARB):
 GL_PREFIX(VertexAttrib2fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3768(%rax), %r11
+	movq	3784(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17661,13 +17751,13 @@ GL_PREFIX(VertexAttrib2fvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3768(%rax), %r11
+	movq	3784(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3768(%rax), %r11
+	movq	3784(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17677,7 +17767,7 @@ GL_PREFIX(VertexAttrib2fvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3768(%rax), %r11
+	movq	3784(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2fvARB), .-GL_PREFIX(VertexAttrib2fvARB)
@@ -17688,7 +17778,7 @@ GL_PREFIX(VertexAttrib2fvARB):
 GL_PREFIX(VertexAttrib2sARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3776(%rax), %r11
+	movq	3792(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17698,13 +17788,13 @@ GL_PREFIX(VertexAttrib2sARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3776(%rax), %r11
+	movq	3792(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3776(%rax), %r11
+	movq	3792(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17714,7 +17804,7 @@ GL_PREFIX(VertexAttrib2sARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3776(%rax), %r11
+	movq	3792(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2sARB), .-GL_PREFIX(VertexAttrib2sARB)
@@ -17725,7 +17815,7 @@ GL_PREFIX(VertexAttrib2sARB):
 GL_PREFIX(VertexAttrib2svARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3784(%rax), %r11
+	movq	3800(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17735,13 +17825,13 @@ GL_PREFIX(VertexAttrib2svARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3784(%rax), %r11
+	movq	3800(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3784(%rax), %r11
+	movq	3800(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17751,7 +17841,7 @@ GL_PREFIX(VertexAttrib2svARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3784(%rax), %r11
+	movq	3800(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2svARB), .-GL_PREFIX(VertexAttrib2svARB)
@@ -17762,7 +17852,7 @@ GL_PREFIX(VertexAttrib2svARB):
 GL_PREFIX(VertexAttrib3dARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3792(%rax), %r11
+	movq	3808(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -17776,13 +17866,13 @@ GL_PREFIX(VertexAttrib3dARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	3792(%rax), %r11
+	movq	3808(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3792(%rax), %r11
+	movq	3808(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -17796,7 +17886,7 @@ GL_PREFIX(VertexAttrib3dARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	3792(%rax), %r11
+	movq	3808(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3dARB), .-GL_PREFIX(VertexAttrib3dARB)
@@ -17807,7 +17897,7 @@ GL_PREFIX(VertexAttrib3dARB):
 GL_PREFIX(VertexAttrib3dvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3800(%rax), %r11
+	movq	3816(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17817,13 +17907,13 @@ GL_PREFIX(VertexAttrib3dvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3800(%rax), %r11
+	movq	3816(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3800(%rax), %r11
+	movq	3816(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17833,7 +17923,7 @@ GL_PREFIX(VertexAttrib3dvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3800(%rax), %r11
+	movq	3816(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3dvARB), .-GL_PREFIX(VertexAttrib3dvARB)
@@ -17844,7 +17934,7 @@ GL_PREFIX(VertexAttrib3dvARB):
 GL_PREFIX(VertexAttrib3fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3808(%rax), %r11
+	movq	3824(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -17858,13 +17948,13 @@ GL_PREFIX(VertexAttrib3fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	3808(%rax), %r11
+	movq	3824(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3808(%rax), %r11
+	movq	3824(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -17878,7 +17968,7 @@ GL_PREFIX(VertexAttrib3fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	3808(%rax), %r11
+	movq	3824(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3fARB), .-GL_PREFIX(VertexAttrib3fARB)
@@ -17889,7 +17979,7 @@ GL_PREFIX(VertexAttrib3fARB):
 GL_PREFIX(VertexAttrib3fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3816(%rax), %r11
+	movq	3832(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17899,13 +17989,13 @@ GL_PREFIX(VertexAttrib3fvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3816(%rax), %r11
+	movq	3832(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3816(%rax), %r11
+	movq	3832(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17915,7 +18005,7 @@ GL_PREFIX(VertexAttrib3fvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3816(%rax), %r11
+	movq	3832(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3fvARB), .-GL_PREFIX(VertexAttrib3fvARB)
@@ -17926,7 +18016,7 @@ GL_PREFIX(VertexAttrib3fvARB):
 GL_PREFIX(VertexAttrib3sARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3824(%rax), %r11
+	movq	3840(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17940,13 +18030,13 @@ GL_PREFIX(VertexAttrib3sARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3824(%rax), %r11
+	movq	3840(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3824(%rax), %r11
+	movq	3840(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17960,7 +18050,7 @@ GL_PREFIX(VertexAttrib3sARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3824(%rax), %r11
+	movq	3840(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3sARB), .-GL_PREFIX(VertexAttrib3sARB)
@@ -17971,7 +18061,7 @@ GL_PREFIX(VertexAttrib3sARB):
 GL_PREFIX(VertexAttrib3svARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3832(%rax), %r11
+	movq	3848(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -17981,13 +18071,13 @@ GL_PREFIX(VertexAttrib3svARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3832(%rax), %r11
+	movq	3848(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3832(%rax), %r11
+	movq	3848(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -17997,7 +18087,7 @@ GL_PREFIX(VertexAttrib3svARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3832(%rax), %r11
+	movq	3848(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3svARB), .-GL_PREFIX(VertexAttrib3svARB)
@@ -18008,7 +18098,7 @@ GL_PREFIX(VertexAttrib3svARB):
 GL_PREFIX(VertexAttrib4NbvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3840(%rax), %r11
+	movq	3856(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18018,13 +18108,13 @@ GL_PREFIX(VertexAttrib4NbvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3840(%rax), %r11
+	movq	3856(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3840(%rax), %r11
+	movq	3856(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18034,7 +18124,7 @@ GL_PREFIX(VertexAttrib4NbvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3840(%rax), %r11
+	movq	3856(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4NbvARB), .-GL_PREFIX(VertexAttrib4NbvARB)
@@ -18045,7 +18135,7 @@ GL_PREFIX(VertexAttrib4NbvARB):
 GL_PREFIX(VertexAttrib4NivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3848(%rax), %r11
+	movq	3864(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18055,13 +18145,13 @@ GL_PREFIX(VertexAttrib4NivARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3848(%rax), %r11
+	movq	3864(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3848(%rax), %r11
+	movq	3864(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18071,7 +18161,7 @@ GL_PREFIX(VertexAttrib4NivARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3848(%rax), %r11
+	movq	3864(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4NivARB), .-GL_PREFIX(VertexAttrib4NivARB)
@@ -18082,7 +18172,7 @@ GL_PREFIX(VertexAttrib4NivARB):
 GL_PREFIX(VertexAttrib4NsvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3856(%rax), %r11
+	movq	3872(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18092,13 +18182,13 @@ GL_PREFIX(VertexAttrib4NsvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3856(%rax), %r11
+	movq	3872(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3856(%rax), %r11
+	movq	3872(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18108,7 +18198,7 @@ GL_PREFIX(VertexAttrib4NsvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3856(%rax), %r11
+	movq	3872(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4NsvARB), .-GL_PREFIX(VertexAttrib4NsvARB)
@@ -18119,7 +18209,7 @@ GL_PREFIX(VertexAttrib4NsvARB):
 GL_PREFIX(VertexAttrib4NubARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3864(%rax), %r11
+	movq	3880(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18133,13 +18223,13 @@ GL_PREFIX(VertexAttrib4NubARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3864(%rax), %r11
+	movq	3880(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3864(%rax), %r11
+	movq	3880(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18153,7 +18243,7 @@ GL_PREFIX(VertexAttrib4NubARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3864(%rax), %r11
+	movq	3880(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4NubARB), .-GL_PREFIX(VertexAttrib4NubARB)
@@ -18164,7 +18254,7 @@ GL_PREFIX(VertexAttrib4NubARB):
 GL_PREFIX(VertexAttrib4NubvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3872(%rax), %r11
+	movq	3888(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18174,13 +18264,13 @@ GL_PREFIX(VertexAttrib4NubvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3872(%rax), %r11
+	movq	3888(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3872(%rax), %r11
+	movq	3888(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18190,7 +18280,7 @@ GL_PREFIX(VertexAttrib4NubvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3872(%rax), %r11
+	movq	3888(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4NubvARB), .-GL_PREFIX(VertexAttrib4NubvARB)
@@ -18201,7 +18291,7 @@ GL_PREFIX(VertexAttrib4NubvARB):
 GL_PREFIX(VertexAttrib4NuivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3880(%rax), %r11
+	movq	3896(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18211,13 +18301,13 @@ GL_PREFIX(VertexAttrib4NuivARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3880(%rax), %r11
+	movq	3896(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3880(%rax), %r11
+	movq	3896(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18227,7 +18317,7 @@ GL_PREFIX(VertexAttrib4NuivARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3880(%rax), %r11
+	movq	3896(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4NuivARB), .-GL_PREFIX(VertexAttrib4NuivARB)
@@ -18238,7 +18328,7 @@ GL_PREFIX(VertexAttrib4NuivARB):
 GL_PREFIX(VertexAttrib4NusvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3888(%rax), %r11
+	movq	3904(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18248,13 +18338,13 @@ GL_PREFIX(VertexAttrib4NusvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3888(%rax), %r11
+	movq	3904(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3888(%rax), %r11
+	movq	3904(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18264,7 +18354,7 @@ GL_PREFIX(VertexAttrib4NusvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3888(%rax), %r11
+	movq	3904(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4NusvARB), .-GL_PREFIX(VertexAttrib4NusvARB)
@@ -18275,7 +18365,7 @@ GL_PREFIX(VertexAttrib4NusvARB):
 GL_PREFIX(VertexAttrib4bvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3896(%rax), %r11
+	movq	3912(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18285,13 +18375,13 @@ GL_PREFIX(VertexAttrib4bvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3896(%rax), %r11
+	movq	3912(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3896(%rax), %r11
+	movq	3912(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18301,7 +18391,7 @@ GL_PREFIX(VertexAttrib4bvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3896(%rax), %r11
+	movq	3912(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4bvARB), .-GL_PREFIX(VertexAttrib4bvARB)
@@ -18312,7 +18402,7 @@ GL_PREFIX(VertexAttrib4bvARB):
 GL_PREFIX(VertexAttrib4dARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3904(%rax), %r11
+	movq	3920(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -18328,13 +18418,13 @@ GL_PREFIX(VertexAttrib4dARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	3904(%rax), %r11
+	movq	3920(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3904(%rax), %r11
+	movq	3920(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -18350,7 +18440,7 @@ GL_PREFIX(VertexAttrib4dARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	3904(%rax), %r11
+	movq	3920(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4dARB), .-GL_PREFIX(VertexAttrib4dARB)
@@ -18361,7 +18451,7 @@ GL_PREFIX(VertexAttrib4dARB):
 GL_PREFIX(VertexAttrib4dvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3912(%rax), %r11
+	movq	3928(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18371,13 +18461,13 @@ GL_PREFIX(VertexAttrib4dvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3912(%rax), %r11
+	movq	3928(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3912(%rax), %r11
+	movq	3928(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18387,7 +18477,7 @@ GL_PREFIX(VertexAttrib4dvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3912(%rax), %r11
+	movq	3928(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4dvARB), .-GL_PREFIX(VertexAttrib4dvARB)
@@ -18398,7 +18488,7 @@ GL_PREFIX(VertexAttrib4dvARB):
 GL_PREFIX(VertexAttrib4fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3920(%rax), %r11
+	movq	3936(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -18414,13 +18504,13 @@ GL_PREFIX(VertexAttrib4fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	3920(%rax), %r11
+	movq	3936(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3920(%rax), %r11
+	movq	3936(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -18436,7 +18526,7 @@ GL_PREFIX(VertexAttrib4fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	3920(%rax), %r11
+	movq	3936(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4fARB), .-GL_PREFIX(VertexAttrib4fARB)
@@ -18447,7 +18537,7 @@ GL_PREFIX(VertexAttrib4fARB):
 GL_PREFIX(VertexAttrib4fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3928(%rax), %r11
+	movq	3944(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18457,13 +18547,13 @@ GL_PREFIX(VertexAttrib4fvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3928(%rax), %r11
+	movq	3944(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3928(%rax), %r11
+	movq	3944(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18473,7 +18563,7 @@ GL_PREFIX(VertexAttrib4fvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3928(%rax), %r11
+	movq	3944(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4fvARB), .-GL_PREFIX(VertexAttrib4fvARB)
@@ -18484,7 +18574,7 @@ GL_PREFIX(VertexAttrib4fvARB):
 GL_PREFIX(VertexAttrib4ivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3936(%rax), %r11
+	movq	3952(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18494,13 +18584,13 @@ GL_PREFIX(VertexAttrib4ivARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3936(%rax), %r11
+	movq	3952(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3936(%rax), %r11
+	movq	3952(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18510,7 +18600,7 @@ GL_PREFIX(VertexAttrib4ivARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3936(%rax), %r11
+	movq	3952(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4ivARB), .-GL_PREFIX(VertexAttrib4ivARB)
@@ -18521,7 +18611,7 @@ GL_PREFIX(VertexAttrib4ivARB):
 GL_PREFIX(VertexAttrib4sARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3944(%rax), %r11
+	movq	3960(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18535,13 +18625,13 @@ GL_PREFIX(VertexAttrib4sARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3944(%rax), %r11
+	movq	3960(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3944(%rax), %r11
+	movq	3960(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18555,7 +18645,7 @@ GL_PREFIX(VertexAttrib4sARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3944(%rax), %r11
+	movq	3960(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4sARB), .-GL_PREFIX(VertexAttrib4sARB)
@@ -18566,7 +18656,7 @@ GL_PREFIX(VertexAttrib4sARB):
 GL_PREFIX(VertexAttrib4svARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3952(%rax), %r11
+	movq	3968(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18576,13 +18666,13 @@ GL_PREFIX(VertexAttrib4svARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3952(%rax), %r11
+	movq	3968(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3952(%rax), %r11
+	movq	3968(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18592,7 +18682,7 @@ GL_PREFIX(VertexAttrib4svARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3952(%rax), %r11
+	movq	3968(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4svARB), .-GL_PREFIX(VertexAttrib4svARB)
@@ -18603,7 +18693,7 @@ GL_PREFIX(VertexAttrib4svARB):
 GL_PREFIX(VertexAttrib4ubvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3960(%rax), %r11
+	movq	3976(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18613,13 +18703,13 @@ GL_PREFIX(VertexAttrib4ubvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3960(%rax), %r11
+	movq	3976(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3960(%rax), %r11
+	movq	3976(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18629,7 +18719,7 @@ GL_PREFIX(VertexAttrib4ubvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3960(%rax), %r11
+	movq	3976(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4ubvARB), .-GL_PREFIX(VertexAttrib4ubvARB)
@@ -18640,7 +18730,7 @@ GL_PREFIX(VertexAttrib4ubvARB):
 GL_PREFIX(VertexAttrib4uivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3968(%rax), %r11
+	movq	3984(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18650,13 +18740,13 @@ GL_PREFIX(VertexAttrib4uivARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3968(%rax), %r11
+	movq	3984(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3968(%rax), %r11
+	movq	3984(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18666,7 +18756,7 @@ GL_PREFIX(VertexAttrib4uivARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3968(%rax), %r11
+	movq	3984(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4uivARB), .-GL_PREFIX(VertexAttrib4uivARB)
@@ -18677,7 +18767,7 @@ GL_PREFIX(VertexAttrib4uivARB):
 GL_PREFIX(VertexAttrib4usvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3976(%rax), %r11
+	movq	3992(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18687,13 +18777,13 @@ GL_PREFIX(VertexAttrib4usvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3976(%rax), %r11
+	movq	3992(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3976(%rax), %r11
+	movq	3992(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18703,7 +18793,7 @@ GL_PREFIX(VertexAttrib4usvARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3976(%rax), %r11
+	movq	3992(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4usvARB), .-GL_PREFIX(VertexAttrib4usvARB)
@@ -18714,7 +18804,7 @@ GL_PREFIX(VertexAttrib4usvARB):
 GL_PREFIX(VertexAttribPointerARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3984(%rax), %r11
+	movq	4000(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18732,13 +18822,13 @@ GL_PREFIX(VertexAttribPointerARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3984(%rax), %r11
+	movq	4000(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3984(%rax), %r11
+	movq	4000(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18756,7 +18846,7 @@ GL_PREFIX(VertexAttribPointerARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	3984(%rax), %r11
+	movq	4000(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribPointerARB), .-GL_PREFIX(VertexAttribPointerARB)
@@ -18767,7 +18857,7 @@ GL_PREFIX(VertexAttribPointerARB):
 GL_PREFIX(BindBufferARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	3992(%rax), %r11
+	movq	4008(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18777,13 +18867,13 @@ GL_PREFIX(BindBufferARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3992(%rax), %r11
+	movq	4008(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	3992(%rax), %r11
+	movq	4008(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18793,7 +18883,7 @@ GL_PREFIX(BindBufferARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	3992(%rax), %r11
+	movq	4008(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindBufferARB), .-GL_PREFIX(BindBufferARB)
@@ -18804,7 +18894,7 @@ GL_PREFIX(BindBufferARB):
 GL_PREFIX(BufferDataARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4000(%rax), %r11
+	movq	4016(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18818,13 +18908,13 @@ GL_PREFIX(BufferDataARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4000(%rax), %r11
+	movq	4016(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4000(%rax), %r11
+	movq	4016(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18838,7 +18928,7 @@ GL_PREFIX(BufferDataARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4000(%rax), %r11
+	movq	4016(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BufferDataARB), .-GL_PREFIX(BufferDataARB)
@@ -18849,7 +18939,7 @@ GL_PREFIX(BufferDataARB):
 GL_PREFIX(BufferSubDataARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4008(%rax), %r11
+	movq	4024(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18863,13 +18953,13 @@ GL_PREFIX(BufferSubDataARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4008(%rax), %r11
+	movq	4024(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4008(%rax), %r11
+	movq	4024(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18883,7 +18973,7 @@ GL_PREFIX(BufferSubDataARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4008(%rax), %r11
+	movq	4024(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BufferSubDataARB), .-GL_PREFIX(BufferSubDataARB)
@@ -18894,7 +18984,7 @@ GL_PREFIX(BufferSubDataARB):
 GL_PREFIX(DeleteBuffersARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4016(%rax), %r11
+	movq	4032(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18904,13 +18994,13 @@ GL_PREFIX(DeleteBuffersARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4016(%rax), %r11
+	movq	4032(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4016(%rax), %r11
+	movq	4032(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18920,7 +19010,7 @@ GL_PREFIX(DeleteBuffersARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4016(%rax), %r11
+	movq	4032(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteBuffersARB), .-GL_PREFIX(DeleteBuffersARB)
@@ -18931,7 +19021,7 @@ GL_PREFIX(DeleteBuffersARB):
 GL_PREFIX(GenBuffersARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4024(%rax), %r11
+	movq	4040(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18941,13 +19031,13 @@ GL_PREFIX(GenBuffersARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4024(%rax), %r11
+	movq	4040(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4024(%rax), %r11
+	movq	4040(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18957,7 +19047,7 @@ GL_PREFIX(GenBuffersARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4024(%rax), %r11
+	movq	4040(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenBuffersARB), .-GL_PREFIX(GenBuffersARB)
@@ -18968,7 +19058,7 @@ GL_PREFIX(GenBuffersARB):
 GL_PREFIX(GetBufferParameterivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4032(%rax), %r11
+	movq	4048(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -18978,13 +19068,13 @@ GL_PREFIX(GetBufferParameterivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4032(%rax), %r11
+	movq	4048(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4032(%rax), %r11
+	movq	4048(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -18994,7 +19084,7 @@ GL_PREFIX(GetBufferParameterivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4032(%rax), %r11
+	movq	4048(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetBufferParameterivARB), .-GL_PREFIX(GetBufferParameterivARB)
@@ -19005,7 +19095,7 @@ GL_PREFIX(GetBufferParameterivARB):
 GL_PREFIX(GetBufferPointervARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4040(%rax), %r11
+	movq	4056(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19015,13 +19105,13 @@ GL_PREFIX(GetBufferPointervARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4040(%rax), %r11
+	movq	4056(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4040(%rax), %r11
+	movq	4056(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19031,7 +19121,7 @@ GL_PREFIX(GetBufferPointervARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4040(%rax), %r11
+	movq	4056(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetBufferPointervARB), .-GL_PREFIX(GetBufferPointervARB)
@@ -19042,7 +19132,7 @@ GL_PREFIX(GetBufferPointervARB):
 GL_PREFIX(GetBufferSubDataARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4048(%rax), %r11
+	movq	4064(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19056,13 +19146,13 @@ GL_PREFIX(GetBufferSubDataARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4048(%rax), %r11
+	movq	4064(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4048(%rax), %r11
+	movq	4064(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19076,7 +19166,7 @@ GL_PREFIX(GetBufferSubDataARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4048(%rax), %r11
+	movq	4064(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetBufferSubDataARB), .-GL_PREFIX(GetBufferSubDataARB)
@@ -19087,25 +19177,25 @@ GL_PREFIX(GetBufferSubDataARB):
 GL_PREFIX(IsBufferARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4056(%rax), %r11
+	movq	4072(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4056(%rax), %r11
+	movq	4072(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4056(%rax), %r11
+	movq	4072(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4056(%rax), %r11
+	movq	4072(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsBufferARB), .-GL_PREFIX(IsBufferARB)
@@ -19116,7 +19206,7 @@ GL_PREFIX(IsBufferARB):
 GL_PREFIX(MapBufferARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4064(%rax), %r11
+	movq	4080(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19126,13 +19216,13 @@ GL_PREFIX(MapBufferARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4064(%rax), %r11
+	movq	4080(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4064(%rax), %r11
+	movq	4080(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19142,7 +19232,7 @@ GL_PREFIX(MapBufferARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4064(%rax), %r11
+	movq	4080(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(MapBufferARB), .-GL_PREFIX(MapBufferARB)
@@ -19153,25 +19243,25 @@ GL_PREFIX(MapBufferARB):
 GL_PREFIX(UnmapBufferARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4072(%rax), %r11
+	movq	4088(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4072(%rax), %r11
+	movq	4088(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4072(%rax), %r11
+	movq	4088(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4072(%rax), %r11
+	movq	4088(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(UnmapBufferARB), .-GL_PREFIX(UnmapBufferARB)
@@ -19182,7 +19272,7 @@ GL_PREFIX(UnmapBufferARB):
 GL_PREFIX(BeginQueryARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4080(%rax), %r11
+	movq	4096(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19192,13 +19282,13 @@ GL_PREFIX(BeginQueryARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4080(%rax), %r11
+	movq	4096(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4080(%rax), %r11
+	movq	4096(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19208,7 +19298,7 @@ GL_PREFIX(BeginQueryARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4080(%rax), %r11
+	movq	4096(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BeginQueryARB), .-GL_PREFIX(BeginQueryARB)
@@ -19219,7 +19309,7 @@ GL_PREFIX(BeginQueryARB):
 GL_PREFIX(DeleteQueriesARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4088(%rax), %r11
+	movq	4104(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19229,13 +19319,13 @@ GL_PREFIX(DeleteQueriesARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4088(%rax), %r11
+	movq	4104(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4088(%rax), %r11
+	movq	4104(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19245,7 +19335,7 @@ GL_PREFIX(DeleteQueriesARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4088(%rax), %r11
+	movq	4104(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteQueriesARB), .-GL_PREFIX(DeleteQueriesARB)
@@ -19256,25 +19346,25 @@ GL_PREFIX(DeleteQueriesARB):
 GL_PREFIX(EndQueryARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4096(%rax), %r11
+	movq	4112(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4096(%rax), %r11
+	movq	4112(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4096(%rax), %r11
+	movq	4112(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4096(%rax), %r11
+	movq	4112(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EndQueryARB), .-GL_PREFIX(EndQueryARB)
@@ -19285,7 +19375,7 @@ GL_PREFIX(EndQueryARB):
 GL_PREFIX(GenQueriesARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4104(%rax), %r11
+	movq	4120(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19295,13 +19385,13 @@ GL_PREFIX(GenQueriesARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4104(%rax), %r11
+	movq	4120(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4104(%rax), %r11
+	movq	4120(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19311,7 +19401,7 @@ GL_PREFIX(GenQueriesARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4104(%rax), %r11
+	movq	4120(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenQueriesARB), .-GL_PREFIX(GenQueriesARB)
@@ -19322,7 +19412,7 @@ GL_PREFIX(GenQueriesARB):
 GL_PREFIX(GetQueryObjectivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4112(%rax), %r11
+	movq	4128(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19332,13 +19422,13 @@ GL_PREFIX(GetQueryObjectivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4112(%rax), %r11
+	movq	4128(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4112(%rax), %r11
+	movq	4128(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19348,7 +19438,7 @@ GL_PREFIX(GetQueryObjectivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4112(%rax), %r11
+	movq	4128(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetQueryObjectivARB), .-GL_PREFIX(GetQueryObjectivARB)
@@ -19359,7 +19449,7 @@ GL_PREFIX(GetQueryObjectivARB):
 GL_PREFIX(GetQueryObjectuivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4120(%rax), %r11
+	movq	4136(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19369,13 +19459,13 @@ GL_PREFIX(GetQueryObjectuivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4120(%rax), %r11
+	movq	4136(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4120(%rax), %r11
+	movq	4136(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19385,7 +19475,7 @@ GL_PREFIX(GetQueryObjectuivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4120(%rax), %r11
+	movq	4136(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetQueryObjectuivARB), .-GL_PREFIX(GetQueryObjectuivARB)
@@ -19396,7 +19486,7 @@ GL_PREFIX(GetQueryObjectuivARB):
 GL_PREFIX(GetQueryivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4128(%rax), %r11
+	movq	4144(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19406,13 +19496,13 @@ GL_PREFIX(GetQueryivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4128(%rax), %r11
+	movq	4144(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4128(%rax), %r11
+	movq	4144(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19422,7 +19512,7 @@ GL_PREFIX(GetQueryivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4128(%rax), %r11
+	movq	4144(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetQueryivARB), .-GL_PREFIX(GetQueryivARB)
@@ -19433,25 +19523,25 @@ GL_PREFIX(GetQueryivARB):
 GL_PREFIX(IsQueryARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4136(%rax), %r11
+	movq	4152(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4136(%rax), %r11
+	movq	4152(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4136(%rax), %r11
+	movq	4152(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4136(%rax), %r11
+	movq	4152(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsQueryARB), .-GL_PREFIX(IsQueryARB)
@@ -19462,7 +19552,7 @@ GL_PREFIX(IsQueryARB):
 GL_PREFIX(AttachObjectARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4144(%rax), %r11
+	movq	4160(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19472,13 +19562,13 @@ GL_PREFIX(AttachObjectARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4144(%rax), %r11
+	movq	4160(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4144(%rax), %r11
+	movq	4160(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19488,7 +19578,7 @@ GL_PREFIX(AttachObjectARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4144(%rax), %r11
+	movq	4160(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(AttachObjectARB), .-GL_PREFIX(AttachObjectARB)
@@ -19499,25 +19589,25 @@ GL_PREFIX(AttachObjectARB):
 GL_PREFIX(CompileShaderARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4152(%rax), %r11
+	movq	4168(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4152(%rax), %r11
+	movq	4168(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4152(%rax), %r11
+	movq	4168(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4152(%rax), %r11
+	movq	4168(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CompileShaderARB), .-GL_PREFIX(CompileShaderARB)
@@ -19528,25 +19618,25 @@ GL_PREFIX(CompileShaderARB):
 GL_PREFIX(CreateProgramObjectARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4160(%rax), %r11
+	movq	4176(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	4160(%rax), %r11
+	movq	4176(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4160(%rax), %r11
+	movq	4176(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	4160(%rax), %r11
+	movq	4176(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CreateProgramObjectARB), .-GL_PREFIX(CreateProgramObjectARB)
@@ -19557,25 +19647,25 @@ GL_PREFIX(CreateProgramObjectARB):
 GL_PREFIX(CreateShaderObjectARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4168(%rax), %r11
+	movq	4184(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4168(%rax), %r11
+	movq	4184(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4168(%rax), %r11
+	movq	4184(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4168(%rax), %r11
+	movq	4184(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CreateShaderObjectARB), .-GL_PREFIX(CreateShaderObjectARB)
@@ -19586,25 +19676,25 @@ GL_PREFIX(CreateShaderObjectARB):
 GL_PREFIX(DeleteObjectARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4176(%rax), %r11
+	movq	4192(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4176(%rax), %r11
+	movq	4192(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4176(%rax), %r11
+	movq	4192(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4176(%rax), %r11
+	movq	4192(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteObjectARB), .-GL_PREFIX(DeleteObjectARB)
@@ -19615,7 +19705,7 @@ GL_PREFIX(DeleteObjectARB):
 GL_PREFIX(DetachObjectARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4184(%rax), %r11
+	movq	4200(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19625,13 +19715,13 @@ GL_PREFIX(DetachObjectARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4184(%rax), %r11
+	movq	4200(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4184(%rax), %r11
+	movq	4200(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19641,7 +19731,7 @@ GL_PREFIX(DetachObjectARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4184(%rax), %r11
+	movq	4200(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DetachObjectARB), .-GL_PREFIX(DetachObjectARB)
@@ -19652,7 +19742,7 @@ GL_PREFIX(DetachObjectARB):
 GL_PREFIX(GetActiveUniformARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4192(%rax), %r11
+	movq	4208(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19670,13 +19760,13 @@ GL_PREFIX(GetActiveUniformARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4192(%rax), %r11
+	movq	4208(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4192(%rax), %r11
+	movq	4208(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19694,7 +19784,7 @@ GL_PREFIX(GetActiveUniformARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4192(%rax), %r11
+	movq	4208(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetActiveUniformARB), .-GL_PREFIX(GetActiveUniformARB)
@@ -19705,7 +19795,7 @@ GL_PREFIX(GetActiveUniformARB):
 GL_PREFIX(GetAttachedObjectsARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4200(%rax), %r11
+	movq	4216(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19719,13 +19809,13 @@ GL_PREFIX(GetAttachedObjectsARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4200(%rax), %r11
+	movq	4216(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4200(%rax), %r11
+	movq	4216(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19739,7 +19829,7 @@ GL_PREFIX(GetAttachedObjectsARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4200(%rax), %r11
+	movq	4216(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetAttachedObjectsARB), .-GL_PREFIX(GetAttachedObjectsARB)
@@ -19750,25 +19840,25 @@ GL_PREFIX(GetAttachedObjectsARB):
 GL_PREFIX(GetHandleARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4208(%rax), %r11
+	movq	4224(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4208(%rax), %r11
+	movq	4224(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4208(%rax), %r11
+	movq	4224(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4208(%rax), %r11
+	movq	4224(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetHandleARB), .-GL_PREFIX(GetHandleARB)
@@ -19779,7 +19869,7 @@ GL_PREFIX(GetHandleARB):
 GL_PREFIX(GetInfoLogARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4216(%rax), %r11
+	movq	4232(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19793,13 +19883,13 @@ GL_PREFIX(GetInfoLogARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4216(%rax), %r11
+	movq	4232(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4216(%rax), %r11
+	movq	4232(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19813,7 +19903,7 @@ GL_PREFIX(GetInfoLogARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4216(%rax), %r11
+	movq	4232(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetInfoLogARB), .-GL_PREFIX(GetInfoLogARB)
@@ -19824,7 +19914,7 @@ GL_PREFIX(GetInfoLogARB):
 GL_PREFIX(GetObjectParameterfvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4224(%rax), %r11
+	movq	4240(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19834,13 +19924,13 @@ GL_PREFIX(GetObjectParameterfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4224(%rax), %r11
+	movq	4240(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4224(%rax), %r11
+	movq	4240(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19850,7 +19940,7 @@ GL_PREFIX(GetObjectParameterfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4224(%rax), %r11
+	movq	4240(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetObjectParameterfvARB), .-GL_PREFIX(GetObjectParameterfvARB)
@@ -19861,7 +19951,7 @@ GL_PREFIX(GetObjectParameterfvARB):
 GL_PREFIX(GetObjectParameterivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4232(%rax), %r11
+	movq	4248(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19871,13 +19961,13 @@ GL_PREFIX(GetObjectParameterivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4232(%rax), %r11
+	movq	4248(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4232(%rax), %r11
+	movq	4248(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19887,7 +19977,7 @@ GL_PREFIX(GetObjectParameterivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4232(%rax), %r11
+	movq	4248(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetObjectParameterivARB), .-GL_PREFIX(GetObjectParameterivARB)
@@ -19898,7 +19988,7 @@ GL_PREFIX(GetObjectParameterivARB):
 GL_PREFIX(GetShaderSourceARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4240(%rax), %r11
+	movq	4256(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19912,13 +20002,13 @@ GL_PREFIX(GetShaderSourceARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4240(%rax), %r11
+	movq	4256(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4240(%rax), %r11
+	movq	4256(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19932,7 +20022,7 @@ GL_PREFIX(GetShaderSourceARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4240(%rax), %r11
+	movq	4256(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetShaderSourceARB), .-GL_PREFIX(GetShaderSourceARB)
@@ -19943,7 +20033,7 @@ GL_PREFIX(GetShaderSourceARB):
 GL_PREFIX(GetUniformLocationARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4248(%rax), %r11
+	movq	4264(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19953,13 +20043,13 @@ GL_PREFIX(GetUniformLocationARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4248(%rax), %r11
+	movq	4264(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4248(%rax), %r11
+	movq	4264(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -19969,7 +20059,7 @@ GL_PREFIX(GetUniformLocationARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4248(%rax), %r11
+	movq	4264(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetUniformLocationARB), .-GL_PREFIX(GetUniformLocationARB)
@@ -19980,7 +20070,7 @@ GL_PREFIX(GetUniformLocationARB):
 GL_PREFIX(GetUniformfvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4256(%rax), %r11
+	movq	4272(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -19990,13 +20080,13 @@ GL_PREFIX(GetUniformfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4256(%rax), %r11
+	movq	4272(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4256(%rax), %r11
+	movq	4272(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20006,7 +20096,7 @@ GL_PREFIX(GetUniformfvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4256(%rax), %r11
+	movq	4272(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetUniformfvARB), .-GL_PREFIX(GetUniformfvARB)
@@ -20017,7 +20107,7 @@ GL_PREFIX(GetUniformfvARB):
 GL_PREFIX(GetUniformivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4264(%rax), %r11
+	movq	4280(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20027,13 +20117,13 @@ GL_PREFIX(GetUniformivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4264(%rax), %r11
+	movq	4280(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4264(%rax), %r11
+	movq	4280(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20043,7 +20133,7 @@ GL_PREFIX(GetUniformivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4264(%rax), %r11
+	movq	4280(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetUniformivARB), .-GL_PREFIX(GetUniformivARB)
@@ -20054,25 +20144,25 @@ GL_PREFIX(GetUniformivARB):
 GL_PREFIX(LinkProgramARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4272(%rax), %r11
+	movq	4288(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4272(%rax), %r11
+	movq	4288(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4272(%rax), %r11
+	movq	4288(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4272(%rax), %r11
+	movq	4288(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(LinkProgramARB), .-GL_PREFIX(LinkProgramARB)
@@ -20083,7 +20173,7 @@ GL_PREFIX(LinkProgramARB):
 GL_PREFIX(ShaderSourceARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4280(%rax), %r11
+	movq	4296(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20097,13 +20187,13 @@ GL_PREFIX(ShaderSourceARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4280(%rax), %r11
+	movq	4296(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4280(%rax), %r11
+	movq	4296(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20117,7 +20207,7 @@ GL_PREFIX(ShaderSourceARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4280(%rax), %r11
+	movq	4296(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ShaderSourceARB), .-GL_PREFIX(ShaderSourceARB)
@@ -20128,7 +20218,7 @@ GL_PREFIX(ShaderSourceARB):
 GL_PREFIX(Uniform1fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4288(%rax), %r11
+	movq	4304(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -20138,13 +20228,13 @@ GL_PREFIX(Uniform1fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4288(%rax), %r11
+	movq	4304(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4288(%rax), %r11
+	movq	4304(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -20154,7 +20244,7 @@ GL_PREFIX(Uniform1fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4288(%rax), %r11
+	movq	4304(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform1fARB), .-GL_PREFIX(Uniform1fARB)
@@ -20165,7 +20255,7 @@ GL_PREFIX(Uniform1fARB):
 GL_PREFIX(Uniform1fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4296(%rax), %r11
+	movq	4312(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20175,13 +20265,13 @@ GL_PREFIX(Uniform1fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4296(%rax), %r11
+	movq	4312(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4296(%rax), %r11
+	movq	4312(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20191,7 +20281,7 @@ GL_PREFIX(Uniform1fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4296(%rax), %r11
+	movq	4312(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform1fvARB), .-GL_PREFIX(Uniform1fvARB)
@@ -20202,7 +20292,7 @@ GL_PREFIX(Uniform1fvARB):
 GL_PREFIX(Uniform1iARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4304(%rax), %r11
+	movq	4320(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20212,13 +20302,13 @@ GL_PREFIX(Uniform1iARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4304(%rax), %r11
+	movq	4320(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4304(%rax), %r11
+	movq	4320(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20228,7 +20318,7 @@ GL_PREFIX(Uniform1iARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4304(%rax), %r11
+	movq	4320(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform1iARB), .-GL_PREFIX(Uniform1iARB)
@@ -20239,7 +20329,7 @@ GL_PREFIX(Uniform1iARB):
 GL_PREFIX(Uniform1ivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4312(%rax), %r11
+	movq	4328(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20249,13 +20339,13 @@ GL_PREFIX(Uniform1ivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4312(%rax), %r11
+	movq	4328(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4312(%rax), %r11
+	movq	4328(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20265,7 +20355,7 @@ GL_PREFIX(Uniform1ivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4312(%rax), %r11
+	movq	4328(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform1ivARB), .-GL_PREFIX(Uniform1ivARB)
@@ -20276,7 +20366,7 @@ GL_PREFIX(Uniform1ivARB):
 GL_PREFIX(Uniform2fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4320(%rax), %r11
+	movq	4336(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -20288,13 +20378,13 @@ GL_PREFIX(Uniform2fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4320(%rax), %r11
+	movq	4336(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4320(%rax), %r11
+	movq	4336(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -20306,7 +20396,7 @@ GL_PREFIX(Uniform2fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4320(%rax), %r11
+	movq	4336(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform2fARB), .-GL_PREFIX(Uniform2fARB)
@@ -20317,7 +20407,7 @@ GL_PREFIX(Uniform2fARB):
 GL_PREFIX(Uniform2fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4328(%rax), %r11
+	movq	4344(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20327,13 +20417,13 @@ GL_PREFIX(Uniform2fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4328(%rax), %r11
+	movq	4344(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4328(%rax), %r11
+	movq	4344(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20343,7 +20433,7 @@ GL_PREFIX(Uniform2fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4328(%rax), %r11
+	movq	4344(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform2fvARB), .-GL_PREFIX(Uniform2fvARB)
@@ -20354,7 +20444,7 @@ GL_PREFIX(Uniform2fvARB):
 GL_PREFIX(Uniform2iARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4336(%rax), %r11
+	movq	4352(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20364,13 +20454,13 @@ GL_PREFIX(Uniform2iARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4336(%rax), %r11
+	movq	4352(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4336(%rax), %r11
+	movq	4352(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20380,7 +20470,7 @@ GL_PREFIX(Uniform2iARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4336(%rax), %r11
+	movq	4352(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform2iARB), .-GL_PREFIX(Uniform2iARB)
@@ -20391,7 +20481,7 @@ GL_PREFIX(Uniform2iARB):
 GL_PREFIX(Uniform2ivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4344(%rax), %r11
+	movq	4360(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20401,13 +20491,13 @@ GL_PREFIX(Uniform2ivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4344(%rax), %r11
+	movq	4360(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4344(%rax), %r11
+	movq	4360(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20417,7 +20507,7 @@ GL_PREFIX(Uniform2ivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4344(%rax), %r11
+	movq	4360(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform2ivARB), .-GL_PREFIX(Uniform2ivARB)
@@ -20428,7 +20518,7 @@ GL_PREFIX(Uniform2ivARB):
 GL_PREFIX(Uniform3fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4352(%rax), %r11
+	movq	4368(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -20442,13 +20532,13 @@ GL_PREFIX(Uniform3fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	4352(%rax), %r11
+	movq	4368(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4352(%rax), %r11
+	movq	4368(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -20462,7 +20552,7 @@ GL_PREFIX(Uniform3fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	4352(%rax), %r11
+	movq	4368(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform3fARB), .-GL_PREFIX(Uniform3fARB)
@@ -20473,7 +20563,7 @@ GL_PREFIX(Uniform3fARB):
 GL_PREFIX(Uniform3fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4360(%rax), %r11
+	movq	4376(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20483,13 +20573,13 @@ GL_PREFIX(Uniform3fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4360(%rax), %r11
+	movq	4376(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4360(%rax), %r11
+	movq	4376(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20499,7 +20589,7 @@ GL_PREFIX(Uniform3fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4360(%rax), %r11
+	movq	4376(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform3fvARB), .-GL_PREFIX(Uniform3fvARB)
@@ -20510,7 +20600,7 @@ GL_PREFIX(Uniform3fvARB):
 GL_PREFIX(Uniform3iARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4368(%rax), %r11
+	movq	4384(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20524,13 +20614,13 @@ GL_PREFIX(Uniform3iARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4368(%rax), %r11
+	movq	4384(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4368(%rax), %r11
+	movq	4384(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20544,7 +20634,7 @@ GL_PREFIX(Uniform3iARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4368(%rax), %r11
+	movq	4384(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform3iARB), .-GL_PREFIX(Uniform3iARB)
@@ -20555,7 +20645,7 @@ GL_PREFIX(Uniform3iARB):
 GL_PREFIX(Uniform3ivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4376(%rax), %r11
+	movq	4392(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20565,13 +20655,13 @@ GL_PREFIX(Uniform3ivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4376(%rax), %r11
+	movq	4392(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4376(%rax), %r11
+	movq	4392(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20581,7 +20671,7 @@ GL_PREFIX(Uniform3ivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4376(%rax), %r11
+	movq	4392(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform3ivARB), .-GL_PREFIX(Uniform3ivARB)
@@ -20592,7 +20682,7 @@ GL_PREFIX(Uniform3ivARB):
 GL_PREFIX(Uniform4fARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4384(%rax), %r11
+	movq	4400(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -20608,13 +20698,13 @@ GL_PREFIX(Uniform4fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	4384(%rax), %r11
+	movq	4400(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4384(%rax), %r11
+	movq	4400(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -20630,7 +20720,7 @@ GL_PREFIX(Uniform4fARB):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	4384(%rax), %r11
+	movq	4400(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform4fARB), .-GL_PREFIX(Uniform4fARB)
@@ -20641,7 +20731,7 @@ GL_PREFIX(Uniform4fARB):
 GL_PREFIX(Uniform4fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4392(%rax), %r11
+	movq	4408(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20651,13 +20741,13 @@ GL_PREFIX(Uniform4fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4392(%rax), %r11
+	movq	4408(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4392(%rax), %r11
+	movq	4408(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20667,7 +20757,7 @@ GL_PREFIX(Uniform4fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4392(%rax), %r11
+	movq	4408(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform4fvARB), .-GL_PREFIX(Uniform4fvARB)
@@ -20678,7 +20768,7 @@ GL_PREFIX(Uniform4fvARB):
 GL_PREFIX(Uniform4iARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4400(%rax), %r11
+	movq	4416(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20692,13 +20782,13 @@ GL_PREFIX(Uniform4iARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4400(%rax), %r11
+	movq	4416(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4400(%rax), %r11
+	movq	4416(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20712,7 +20802,7 @@ GL_PREFIX(Uniform4iARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4400(%rax), %r11
+	movq	4416(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform4iARB), .-GL_PREFIX(Uniform4iARB)
@@ -20723,7 +20813,7 @@ GL_PREFIX(Uniform4iARB):
 GL_PREFIX(Uniform4ivARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4408(%rax), %r11
+	movq	4424(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20733,13 +20823,13 @@ GL_PREFIX(Uniform4ivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4408(%rax), %r11
+	movq	4424(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4408(%rax), %r11
+	movq	4424(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20749,7 +20839,7 @@ GL_PREFIX(Uniform4ivARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4408(%rax), %r11
+	movq	4424(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(Uniform4ivARB), .-GL_PREFIX(Uniform4ivARB)
@@ -20760,7 +20850,7 @@ GL_PREFIX(Uniform4ivARB):
 GL_PREFIX(UniformMatrix2fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4416(%rax), %r11
+	movq	4432(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20774,13 +20864,13 @@ GL_PREFIX(UniformMatrix2fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4416(%rax), %r11
+	movq	4432(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4416(%rax), %r11
+	movq	4432(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20794,7 +20884,7 @@ GL_PREFIX(UniformMatrix2fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4416(%rax), %r11
+	movq	4432(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(UniformMatrix2fvARB), .-GL_PREFIX(UniformMatrix2fvARB)
@@ -20805,7 +20895,7 @@ GL_PREFIX(UniformMatrix2fvARB):
 GL_PREFIX(UniformMatrix3fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4424(%rax), %r11
+	movq	4440(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20819,13 +20909,13 @@ GL_PREFIX(UniformMatrix3fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4424(%rax), %r11
+	movq	4440(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4424(%rax), %r11
+	movq	4440(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20839,7 +20929,7 @@ GL_PREFIX(UniformMatrix3fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4424(%rax), %r11
+	movq	4440(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(UniformMatrix3fvARB), .-GL_PREFIX(UniformMatrix3fvARB)
@@ -20850,7 +20940,7 @@ GL_PREFIX(UniformMatrix3fvARB):
 GL_PREFIX(UniformMatrix4fvARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4432(%rax), %r11
+	movq	4448(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20864,13 +20954,13 @@ GL_PREFIX(UniformMatrix4fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4432(%rax), %r11
+	movq	4448(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4432(%rax), %r11
+	movq	4448(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20884,7 +20974,7 @@ GL_PREFIX(UniformMatrix4fvARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4432(%rax), %r11
+	movq	4448(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(UniformMatrix4fvARB), .-GL_PREFIX(UniformMatrix4fvARB)
@@ -20895,25 +20985,25 @@ GL_PREFIX(UniformMatrix4fvARB):
 GL_PREFIX(UseProgramObjectARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4440(%rax), %r11
+	movq	4456(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4440(%rax), %r11
+	movq	4456(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4440(%rax), %r11
+	movq	4456(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4440(%rax), %r11
+	movq	4456(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(UseProgramObjectARB), .-GL_PREFIX(UseProgramObjectARB)
@@ -20924,25 +21014,25 @@ GL_PREFIX(UseProgramObjectARB):
 GL_PREFIX(ValidateProgramARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4448(%rax), %r11
+	movq	4464(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4448(%rax), %r11
+	movq	4464(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4448(%rax), %r11
+	movq	4464(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4448(%rax), %r11
+	movq	4464(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ValidateProgramARB), .-GL_PREFIX(ValidateProgramARB)
@@ -20953,7 +21043,7 @@ GL_PREFIX(ValidateProgramARB):
 GL_PREFIX(BindAttribLocationARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4456(%rax), %r11
+	movq	4472(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -20963,13 +21053,13 @@ GL_PREFIX(BindAttribLocationARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4456(%rax), %r11
+	movq	4472(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4456(%rax), %r11
+	movq	4472(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -20979,7 +21069,7 @@ GL_PREFIX(BindAttribLocationARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4456(%rax), %r11
+	movq	4472(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindAttribLocationARB), .-GL_PREFIX(BindAttribLocationARB)
@@ -20990,7 +21080,7 @@ GL_PREFIX(BindAttribLocationARB):
 GL_PREFIX(GetActiveAttribARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4464(%rax), %r11
+	movq	4480(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21008,13 +21098,13 @@ GL_PREFIX(GetActiveAttribARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4464(%rax), %r11
+	movq	4480(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4464(%rax), %r11
+	movq	4480(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21032,7 +21122,7 @@ GL_PREFIX(GetActiveAttribARB):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4464(%rax), %r11
+	movq	4480(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetActiveAttribARB), .-GL_PREFIX(GetActiveAttribARB)
@@ -21043,7 +21133,7 @@ GL_PREFIX(GetActiveAttribARB):
 GL_PREFIX(GetAttribLocationARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4472(%rax), %r11
+	movq	4488(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21053,13 +21143,13 @@ GL_PREFIX(GetAttribLocationARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4472(%rax), %r11
+	movq	4488(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4472(%rax), %r11
+	movq	4488(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21069,7 +21159,7 @@ GL_PREFIX(GetAttribLocationARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4472(%rax), %r11
+	movq	4488(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetAttribLocationARB), .-GL_PREFIX(GetAttribLocationARB)
@@ -21080,7 +21170,7 @@ GL_PREFIX(GetAttribLocationARB):
 GL_PREFIX(DrawBuffersARB):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4480(%rax), %r11
+	movq	4496(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21090,13 +21180,13 @@ GL_PREFIX(DrawBuffersARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4480(%rax), %r11
+	movq	4496(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4480(%rax), %r11
+	movq	4496(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21106,7 +21196,7 @@ GL_PREFIX(DrawBuffersARB):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4480(%rax), %r11
+	movq	4496(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DrawBuffersARB), .-GL_PREFIX(DrawBuffersARB)
@@ -21117,7 +21207,7 @@ GL_PREFIX(DrawBuffersARB):
 GL_PREFIX(RenderbufferStorageMultisample):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4488(%rax), %r11
+	movq	4504(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21131,13 +21221,13 @@ GL_PREFIX(RenderbufferStorageMultisample):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4488(%rax), %r11
+	movq	4504(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4488(%rax), %r11
+	movq	4504(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21151,7 +21241,7 @@ GL_PREFIX(RenderbufferStorageMultisample):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4488(%rax), %r11
+	movq	4504(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(RenderbufferStorageMultisample), .-GL_PREFIX(RenderbufferStorageMultisample)
@@ -21162,7 +21252,7 @@ GL_PREFIX(RenderbufferStorageMultisample):
 GL_PREFIX(FlushMappedBufferRange):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4496(%rax), %r11
+	movq	4512(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21172,13 +21262,13 @@ GL_PREFIX(FlushMappedBufferRange):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4496(%rax), %r11
+	movq	4512(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4496(%rax), %r11
+	movq	4512(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21188,7 +21278,7 @@ GL_PREFIX(FlushMappedBufferRange):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4496(%rax), %r11
+	movq	4512(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FlushMappedBufferRange), .-GL_PREFIX(FlushMappedBufferRange)
@@ -21199,7 +21289,7 @@ GL_PREFIX(FlushMappedBufferRange):
 GL_PREFIX(MapBufferRange):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4504(%rax), %r11
+	movq	4520(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21213,13 +21303,13 @@ GL_PREFIX(MapBufferRange):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4504(%rax), %r11
+	movq	4520(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4504(%rax), %r11
+	movq	4520(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21233,7 +21323,7 @@ GL_PREFIX(MapBufferRange):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4504(%rax), %r11
+	movq	4520(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(MapBufferRange), .-GL_PREFIX(MapBufferRange)
@@ -21244,25 +21334,25 @@ GL_PREFIX(MapBufferRange):
 GL_PREFIX(BindVertexArray):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4512(%rax), %r11
+	movq	4528(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4512(%rax), %r11
+	movq	4528(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4512(%rax), %r11
+	movq	4528(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4512(%rax), %r11
+	movq	4528(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindVertexArray), .-GL_PREFIX(BindVertexArray)
@@ -21273,7 +21363,7 @@ GL_PREFIX(BindVertexArray):
 GL_PREFIX(GenVertexArrays):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4520(%rax), %r11
+	movq	4536(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21283,13 +21373,13 @@ GL_PREFIX(GenVertexArrays):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4520(%rax), %r11
+	movq	4536(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4520(%rax), %r11
+	movq	4536(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21299,7 +21389,7 @@ GL_PREFIX(GenVertexArrays):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4520(%rax), %r11
+	movq	4536(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenVertexArrays), .-GL_PREFIX(GenVertexArrays)
@@ -21310,7 +21400,7 @@ GL_PREFIX(GenVertexArrays):
 GL_PREFIX(CopyBufferSubData):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4528(%rax), %r11
+	movq	4544(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21324,13 +21414,13 @@ GL_PREFIX(CopyBufferSubData):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4528(%rax), %r11
+	movq	4544(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4528(%rax), %r11
+	movq	4544(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21344,7 +21434,7 @@ GL_PREFIX(CopyBufferSubData):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4528(%rax), %r11
+	movq	4544(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CopyBufferSubData), .-GL_PREFIX(CopyBufferSubData)
@@ -21355,7 +21445,7 @@ GL_PREFIX(CopyBufferSubData):
 GL_PREFIX(ClientWaitSync):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4536(%rax), %r11
+	movq	4552(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21365,13 +21455,13 @@ GL_PREFIX(ClientWaitSync):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4536(%rax), %r11
+	movq	4552(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4536(%rax), %r11
+	movq	4552(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21381,7 +21471,7 @@ GL_PREFIX(ClientWaitSync):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4536(%rax), %r11
+	movq	4552(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ClientWaitSync), .-GL_PREFIX(ClientWaitSync)
@@ -21392,25 +21482,25 @@ GL_PREFIX(ClientWaitSync):
 GL_PREFIX(DeleteSync):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4544(%rax), %r11
+	movq	4560(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4544(%rax), %r11
+	movq	4560(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4544(%rax), %r11
+	movq	4560(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4544(%rax), %r11
+	movq	4560(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteSync), .-GL_PREFIX(DeleteSync)
@@ -21421,7 +21511,7 @@ GL_PREFIX(DeleteSync):
 GL_PREFIX(FenceSync):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4552(%rax), %r11
+	movq	4568(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21431,13 +21521,13 @@ GL_PREFIX(FenceSync):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4552(%rax), %r11
+	movq	4568(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4552(%rax), %r11
+	movq	4568(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21447,7 +21537,7 @@ GL_PREFIX(FenceSync):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4552(%rax), %r11
+	movq	4568(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FenceSync), .-GL_PREFIX(FenceSync)
@@ -21458,7 +21548,7 @@ GL_PREFIX(FenceSync):
 GL_PREFIX(GetInteger64v):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4560(%rax), %r11
+	movq	4576(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21468,13 +21558,13 @@ GL_PREFIX(GetInteger64v):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4560(%rax), %r11
+	movq	4576(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4560(%rax), %r11
+	movq	4576(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21484,7 +21574,7 @@ GL_PREFIX(GetInteger64v):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4560(%rax), %r11
+	movq	4576(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetInteger64v), .-GL_PREFIX(GetInteger64v)
@@ -21495,7 +21585,7 @@ GL_PREFIX(GetInteger64v):
 GL_PREFIX(GetSynciv):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4568(%rax), %r11
+	movq	4584(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21509,13 +21599,13 @@ GL_PREFIX(GetSynciv):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4568(%rax), %r11
+	movq	4584(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4568(%rax), %r11
+	movq	4584(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21529,7 +21619,7 @@ GL_PREFIX(GetSynciv):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4568(%rax), %r11
+	movq	4584(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetSynciv), .-GL_PREFIX(GetSynciv)
@@ -21540,25 +21630,25 @@ GL_PREFIX(GetSynciv):
 GL_PREFIX(IsSync):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4576(%rax), %r11
+	movq	4592(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4576(%rax), %r11
+	movq	4592(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4576(%rax), %r11
+	movq	4592(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4576(%rax), %r11
+	movq	4592(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsSync), .-GL_PREFIX(IsSync)
@@ -21569,7 +21659,7 @@ GL_PREFIX(IsSync):
 GL_PREFIX(WaitSync):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4584(%rax), %r11
+	movq	4600(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21579,13 +21669,13 @@ GL_PREFIX(WaitSync):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4584(%rax), %r11
+	movq	4600(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4584(%rax), %r11
+	movq	4600(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21595,7 +21685,7 @@ GL_PREFIX(WaitSync):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4584(%rax), %r11
+	movq	4600(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WaitSync), .-GL_PREFIX(WaitSync)
@@ -21606,7 +21696,7 @@ GL_PREFIX(WaitSync):
 GL_PREFIX(DrawElementsBaseVertex):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4592(%rax), %r11
+	movq	4608(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21620,13 +21710,13 @@ GL_PREFIX(DrawElementsBaseVertex):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4592(%rax), %r11
+	movq	4608(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4592(%rax), %r11
+	movq	4608(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21640,7 +21730,7 @@ GL_PREFIX(DrawElementsBaseVertex):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4592(%rax), %r11
+	movq	4608(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DrawElementsBaseVertex), .-GL_PREFIX(DrawElementsBaseVertex)
@@ -21651,7 +21741,7 @@ GL_PREFIX(DrawElementsBaseVertex):
 GL_PREFIX(DrawRangeElementsBaseVertex):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4600(%rax), %r11
+	movq	4616(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21669,13 +21759,13 @@ GL_PREFIX(DrawRangeElementsBaseVertex):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4600(%rax), %r11
+	movq	4616(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4600(%rax), %r11
+	movq	4616(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21693,7 +21783,7 @@ GL_PREFIX(DrawRangeElementsBaseVertex):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4600(%rax), %r11
+	movq	4616(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DrawRangeElementsBaseVertex), .-GL_PREFIX(DrawRangeElementsBaseVertex)
@@ -21704,7 +21794,7 @@ GL_PREFIX(DrawRangeElementsBaseVertex):
 GL_PREFIX(MultiDrawElementsBaseVertex):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4608(%rax), %r11
+	movq	4624(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21722,13 +21812,13 @@ GL_PREFIX(MultiDrawElementsBaseVertex):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4608(%rax), %r11
+	movq	4624(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4608(%rax), %r11
+	movq	4624(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21746,7 +21836,7 @@ GL_PREFIX(MultiDrawElementsBaseVertex):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4608(%rax), %r11
+	movq	4624(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(MultiDrawElementsBaseVertex), .-GL_PREFIX(MultiDrawElementsBaseVertex)
@@ -21757,7 +21847,7 @@ GL_PREFIX(MultiDrawElementsBaseVertex):
 GL_PREFIX(PolygonOffsetEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4616(%rax), %r11
+	movq	4632(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -21767,13 +21857,13 @@ GL_PREFIX(PolygonOffsetEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4616(%rax), %r11
+	movq	4632(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4616(%rax), %r11
+	movq	4632(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -21783,19 +21873,19 @@ GL_PREFIX(PolygonOffsetEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4616(%rax), %r11
+	movq	4632(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PolygonOffsetEXT), .-GL_PREFIX(PolygonOffsetEXT)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_578)
-	.type	GL_PREFIX(_dispatch_stub_578), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_578))
-GL_PREFIX(_dispatch_stub_578):
+	.globl	GL_PREFIX(_dispatch_stub_580)
+	.type	GL_PREFIX(_dispatch_stub_580), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_580))
+GL_PREFIX(_dispatch_stub_580):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4624(%rax), %r11
+	movq	4640(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21805,13 +21895,13 @@ GL_PREFIX(_dispatch_stub_578):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4624(%rax), %r11
+	movq	4640(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4624(%rax), %r11
+	movq	4640(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21821,19 +21911,19 @@ GL_PREFIX(_dispatch_stub_578):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4624(%rax), %r11
+	movq	4640(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_578), .-GL_PREFIX(_dispatch_stub_578)
+	.size	GL_PREFIX(_dispatch_stub_580), .-GL_PREFIX(_dispatch_stub_580)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_579)
-	.type	GL_PREFIX(_dispatch_stub_579), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_579))
-GL_PREFIX(_dispatch_stub_579):
+	.globl	GL_PREFIX(_dispatch_stub_581)
+	.type	GL_PREFIX(_dispatch_stub_581), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_581))
+GL_PREFIX(_dispatch_stub_581):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4632(%rax), %r11
+	movq	4648(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21843,13 +21933,13 @@ GL_PREFIX(_dispatch_stub_579):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4632(%rax), %r11
+	movq	4648(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4632(%rax), %r11
+	movq	4648(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21859,19 +21949,19 @@ GL_PREFIX(_dispatch_stub_579):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4632(%rax), %r11
+	movq	4648(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_579), .-GL_PREFIX(_dispatch_stub_579)
+	.size	GL_PREFIX(_dispatch_stub_581), .-GL_PREFIX(_dispatch_stub_581)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_580)
-	.type	GL_PREFIX(_dispatch_stub_580), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_580))
-GL_PREFIX(_dispatch_stub_580):
+	.globl	GL_PREFIX(_dispatch_stub_582)
+	.type	GL_PREFIX(_dispatch_stub_582), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_582))
+GL_PREFIX(_dispatch_stub_582):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4640(%rax), %r11
+	movq	4656(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -21881,13 +21971,13 @@ GL_PREFIX(_dispatch_stub_580):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4640(%rax), %r11
+	movq	4656(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4640(%rax), %r11
+	movq	4656(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -21897,19 +21987,19 @@ GL_PREFIX(_dispatch_stub_580):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4640(%rax), %r11
+	movq	4656(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_580), .-GL_PREFIX(_dispatch_stub_580)
+	.size	GL_PREFIX(_dispatch_stub_582), .-GL_PREFIX(_dispatch_stub_582)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_581)
-	.type	GL_PREFIX(_dispatch_stub_581), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_581))
-GL_PREFIX(_dispatch_stub_581):
+	.globl	GL_PREFIX(_dispatch_stub_583)
+	.type	GL_PREFIX(_dispatch_stub_583), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_583))
+GL_PREFIX(_dispatch_stub_583):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4648(%rax), %r11
+	movq	4664(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21919,13 +22009,13 @@ GL_PREFIX(_dispatch_stub_581):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4648(%rax), %r11
+	movq	4664(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4648(%rax), %r11
+	movq	4664(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21935,19 +22025,19 @@ GL_PREFIX(_dispatch_stub_581):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4648(%rax), %r11
+	movq	4664(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_581), .-GL_PREFIX(_dispatch_stub_581)
+	.size	GL_PREFIX(_dispatch_stub_583), .-GL_PREFIX(_dispatch_stub_583)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_582)
-	.type	GL_PREFIX(_dispatch_stub_582), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_582))
-GL_PREFIX(_dispatch_stub_582):
+	.globl	GL_PREFIX(_dispatch_stub_584)
+	.type	GL_PREFIX(_dispatch_stub_584), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_584))
+GL_PREFIX(_dispatch_stub_584):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4656(%rax), %r11
+	movq	4672(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21957,13 +22047,13 @@ GL_PREFIX(_dispatch_stub_582):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4656(%rax), %r11
+	movq	4672(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4656(%rax), %r11
+	movq	4672(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -21973,19 +22063,19 @@ GL_PREFIX(_dispatch_stub_582):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4656(%rax), %r11
+	movq	4672(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_582), .-GL_PREFIX(_dispatch_stub_582)
+	.size	GL_PREFIX(_dispatch_stub_584), .-GL_PREFIX(_dispatch_stub_584)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_583)
-	.type	GL_PREFIX(_dispatch_stub_583), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_583))
-GL_PREFIX(_dispatch_stub_583):
+	.globl	GL_PREFIX(_dispatch_stub_585)
+	.type	GL_PREFIX(_dispatch_stub_585), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_585))
+GL_PREFIX(_dispatch_stub_585):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4664(%rax), %r11
+	movq	4680(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -21995,13 +22085,13 @@ GL_PREFIX(_dispatch_stub_583):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4664(%rax), %r11
+	movq	4680(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4664(%rax), %r11
+	movq	4680(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22011,19 +22101,19 @@ GL_PREFIX(_dispatch_stub_583):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4664(%rax), %r11
+	movq	4680(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_583), .-GL_PREFIX(_dispatch_stub_583)
+	.size	GL_PREFIX(_dispatch_stub_585), .-GL_PREFIX(_dispatch_stub_585)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_584)
-	.type	GL_PREFIX(_dispatch_stub_584), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_584))
-GL_PREFIX(_dispatch_stub_584):
+	.globl	GL_PREFIX(_dispatch_stub_586)
+	.type	GL_PREFIX(_dispatch_stub_586), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_586))
+GL_PREFIX(_dispatch_stub_586):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4672(%rax), %r11
+	movq	4688(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22033,13 +22123,13 @@ GL_PREFIX(_dispatch_stub_584):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4672(%rax), %r11
+	movq	4688(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4672(%rax), %r11
+	movq	4688(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22049,40 +22139,40 @@ GL_PREFIX(_dispatch_stub_584):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4672(%rax), %r11
+	movq	4688(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_584), .-GL_PREFIX(_dispatch_stub_584)
+	.size	GL_PREFIX(_dispatch_stub_586), .-GL_PREFIX(_dispatch_stub_586)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_585)
-	.type	GL_PREFIX(_dispatch_stub_585), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_585))
-GL_PREFIX(_dispatch_stub_585):
+	.globl	GL_PREFIX(_dispatch_stub_587)
+	.type	GL_PREFIX(_dispatch_stub_587), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_587))
+GL_PREFIX(_dispatch_stub_587):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4680(%rax), %r11
+	movq	4696(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4680(%rax), %r11
+	movq	4696(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4680(%rax), %r11
+	movq	4696(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4680(%rax), %r11
+	movq	4696(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_585), .-GL_PREFIX(_dispatch_stub_585)
+	.size	GL_PREFIX(_dispatch_stub_587), .-GL_PREFIX(_dispatch_stub_587)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(ColorPointerEXT)
@@ -22090,7 +22180,7 @@ GL_PREFIX(_dispatch_stub_585):
 GL_PREFIX(ColorPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4688(%rax), %r11
+	movq	4704(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22104,13 +22194,13 @@ GL_PREFIX(ColorPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4688(%rax), %r11
+	movq	4704(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4688(%rax), %r11
+	movq	4704(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22124,7 +22214,7 @@ GL_PREFIX(ColorPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4688(%rax), %r11
+	movq	4704(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ColorPointerEXT), .-GL_PREFIX(ColorPointerEXT)
@@ -22135,7 +22225,7 @@ GL_PREFIX(ColorPointerEXT):
 GL_PREFIX(EdgeFlagPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4696(%rax), %r11
+	movq	4712(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22145,13 +22235,13 @@ GL_PREFIX(EdgeFlagPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4696(%rax), %r11
+	movq	4712(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4696(%rax), %r11
+	movq	4712(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22161,7 +22251,7 @@ GL_PREFIX(EdgeFlagPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4696(%rax), %r11
+	movq	4712(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EdgeFlagPointerEXT), .-GL_PREFIX(EdgeFlagPointerEXT)
@@ -22172,7 +22262,7 @@ GL_PREFIX(EdgeFlagPointerEXT):
 GL_PREFIX(IndexPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4704(%rax), %r11
+	movq	4720(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22186,13 +22276,13 @@ GL_PREFIX(IndexPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4704(%rax), %r11
+	movq	4720(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4704(%rax), %r11
+	movq	4720(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22206,7 +22296,7 @@ GL_PREFIX(IndexPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4704(%rax), %r11
+	movq	4720(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IndexPointerEXT), .-GL_PREFIX(IndexPointerEXT)
@@ -22217,7 +22307,7 @@ GL_PREFIX(IndexPointerEXT):
 GL_PREFIX(NormalPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4712(%rax), %r11
+	movq	4728(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22231,13 +22321,13 @@ GL_PREFIX(NormalPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4712(%rax), %r11
+	movq	4728(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4712(%rax), %r11
+	movq	4728(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22251,7 +22341,7 @@ GL_PREFIX(NormalPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4712(%rax), %r11
+	movq	4728(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(NormalPointerEXT), .-GL_PREFIX(NormalPointerEXT)
@@ -22262,7 +22352,7 @@ GL_PREFIX(NormalPointerEXT):
 GL_PREFIX(TexCoordPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4720(%rax), %r11
+	movq	4736(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22276,13 +22366,13 @@ GL_PREFIX(TexCoordPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4720(%rax), %r11
+	movq	4736(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4720(%rax), %r11
+	movq	4736(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22296,7 +22386,7 @@ GL_PREFIX(TexCoordPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4720(%rax), %r11
+	movq	4736(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(TexCoordPointerEXT), .-GL_PREFIX(TexCoordPointerEXT)
@@ -22307,7 +22397,7 @@ GL_PREFIX(TexCoordPointerEXT):
 GL_PREFIX(VertexPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4728(%rax), %r11
+	movq	4744(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22321,13 +22411,13 @@ GL_PREFIX(VertexPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4728(%rax), %r11
+	movq	4744(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4728(%rax), %r11
+	movq	4744(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22341,7 +22431,7 @@ GL_PREFIX(VertexPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4728(%rax), %r11
+	movq	4744(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexPointerEXT), .-GL_PREFIX(VertexPointerEXT)
@@ -22352,7 +22442,7 @@ GL_PREFIX(VertexPointerEXT):
 GL_PREFIX(PointParameterfEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4736(%rax), %r11
+	movq	4752(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -22362,13 +22452,13 @@ GL_PREFIX(PointParameterfEXT):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4736(%rax), %r11
+	movq	4752(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4736(%rax), %r11
+	movq	4752(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -22378,7 +22468,7 @@ GL_PREFIX(PointParameterfEXT):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	4736(%rax), %r11
+	movq	4752(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PointParameterfEXT), .-GL_PREFIX(PointParameterfEXT)
@@ -22389,7 +22479,7 @@ GL_PREFIX(PointParameterfEXT):
 GL_PREFIX(PointParameterfvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4744(%rax), %r11
+	movq	4760(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22399,13 +22489,13 @@ GL_PREFIX(PointParameterfvEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4744(%rax), %r11
+	movq	4760(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4744(%rax), %r11
+	movq	4760(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22415,7 +22505,7 @@ GL_PREFIX(PointParameterfvEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4744(%rax), %r11
+	movq	4760(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PointParameterfvEXT), .-GL_PREFIX(PointParameterfvEXT)
@@ -22426,7 +22516,7 @@ GL_PREFIX(PointParameterfvEXT):
 GL_PREFIX(LockArraysEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4752(%rax), %r11
+	movq	4768(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22436,13 +22526,13 @@ GL_PREFIX(LockArraysEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4752(%rax), %r11
+	movq	4768(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4752(%rax), %r11
+	movq	4768(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22452,7 +22542,7 @@ GL_PREFIX(LockArraysEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4752(%rax), %r11
+	movq	4768(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(LockArraysEXT), .-GL_PREFIX(LockArraysEXT)
@@ -22463,37 +22553,37 @@ GL_PREFIX(LockArraysEXT):
 GL_PREFIX(UnlockArraysEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4760(%rax), %r11
+	movq	4776(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	4760(%rax), %r11
+	movq	4776(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4760(%rax), %r11
+	movq	4776(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	4760(%rax), %r11
+	movq	4776(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(UnlockArraysEXT), .-GL_PREFIX(UnlockArraysEXT)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_596)
-	.type	GL_PREFIX(_dispatch_stub_596), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_596))
-GL_PREFIX(_dispatch_stub_596):
+	.globl	GL_PREFIX(_dispatch_stub_598)
+	.type	GL_PREFIX(_dispatch_stub_598), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_598))
+GL_PREFIX(_dispatch_stub_598):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4768(%rax), %r11
+	movq	4784(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22503,13 +22593,13 @@ GL_PREFIX(_dispatch_stub_596):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4768(%rax), %r11
+	movq	4784(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4768(%rax), %r11
+	movq	4784(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22519,19 +22609,19 @@ GL_PREFIX(_dispatch_stub_596):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4768(%rax), %r11
+	movq	4784(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_596), .-GL_PREFIX(_dispatch_stub_596)
+	.size	GL_PREFIX(_dispatch_stub_598), .-GL_PREFIX(_dispatch_stub_598)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_597)
-	.type	GL_PREFIX(_dispatch_stub_597), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_597))
-GL_PREFIX(_dispatch_stub_597):
+	.globl	GL_PREFIX(_dispatch_stub_599)
+	.type	GL_PREFIX(_dispatch_stub_599), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_599))
+GL_PREFIX(_dispatch_stub_599):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4776(%rax), %r11
+	movq	4792(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22541,13 +22631,13 @@ GL_PREFIX(_dispatch_stub_597):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4776(%rax), %r11
+	movq	4792(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4776(%rax), %r11
+	movq	4792(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22557,10 +22647,10 @@ GL_PREFIX(_dispatch_stub_597):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	4776(%rax), %r11
+	movq	4792(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_597), .-GL_PREFIX(_dispatch_stub_597)
+	.size	GL_PREFIX(_dispatch_stub_599), .-GL_PREFIX(_dispatch_stub_599)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(SecondaryColor3bEXT)
@@ -22568,7 +22658,7 @@ GL_PREFIX(_dispatch_stub_597):
 GL_PREFIX(SecondaryColor3bEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4784(%rax), %r11
+	movq	4800(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22578,13 +22668,13 @@ GL_PREFIX(SecondaryColor3bEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4784(%rax), %r11
+	movq	4800(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4784(%rax), %r11
+	movq	4800(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22594,7 +22684,7 @@ GL_PREFIX(SecondaryColor3bEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4784(%rax), %r11
+	movq	4800(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3bEXT), .-GL_PREFIX(SecondaryColor3bEXT)
@@ -22605,25 +22695,25 @@ GL_PREFIX(SecondaryColor3bEXT):
 GL_PREFIX(SecondaryColor3bvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4792(%rax), %r11
+	movq	4808(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4792(%rax), %r11
+	movq	4808(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4792(%rax), %r11
+	movq	4808(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4792(%rax), %r11
+	movq	4808(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3bvEXT), .-GL_PREFIX(SecondaryColor3bvEXT)
@@ -22634,7 +22724,7 @@ GL_PREFIX(SecondaryColor3bvEXT):
 GL_PREFIX(SecondaryColor3dEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4800(%rax), %r11
+	movq	4816(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -22646,13 +22736,13 @@ GL_PREFIX(SecondaryColor3dEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4800(%rax), %r11
+	movq	4816(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4800(%rax), %r11
+	movq	4816(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -22664,7 +22754,7 @@ GL_PREFIX(SecondaryColor3dEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4800(%rax), %r11
+	movq	4816(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3dEXT), .-GL_PREFIX(SecondaryColor3dEXT)
@@ -22675,25 +22765,25 @@ GL_PREFIX(SecondaryColor3dEXT):
 GL_PREFIX(SecondaryColor3dvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4808(%rax), %r11
+	movq	4824(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4808(%rax), %r11
+	movq	4824(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4808(%rax), %r11
+	movq	4824(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4808(%rax), %r11
+	movq	4824(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3dvEXT), .-GL_PREFIX(SecondaryColor3dvEXT)
@@ -22704,7 +22794,7 @@ GL_PREFIX(SecondaryColor3dvEXT):
 GL_PREFIX(SecondaryColor3fEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4816(%rax), %r11
+	movq	4832(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -22716,13 +22806,13 @@ GL_PREFIX(SecondaryColor3fEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4816(%rax), %r11
+	movq	4832(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4816(%rax), %r11
+	movq	4832(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -22734,7 +22824,7 @@ GL_PREFIX(SecondaryColor3fEXT):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	4816(%rax), %r11
+	movq	4832(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3fEXT), .-GL_PREFIX(SecondaryColor3fEXT)
@@ -22745,25 +22835,25 @@ GL_PREFIX(SecondaryColor3fEXT):
 GL_PREFIX(SecondaryColor3fvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4824(%rax), %r11
+	movq	4840(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4824(%rax), %r11
+	movq	4840(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4824(%rax), %r11
+	movq	4840(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4824(%rax), %r11
+	movq	4840(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3fvEXT), .-GL_PREFIX(SecondaryColor3fvEXT)
@@ -22774,7 +22864,7 @@ GL_PREFIX(SecondaryColor3fvEXT):
 GL_PREFIX(SecondaryColor3iEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4832(%rax), %r11
+	movq	4848(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22784,13 +22874,13 @@ GL_PREFIX(SecondaryColor3iEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4832(%rax), %r11
+	movq	4848(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4832(%rax), %r11
+	movq	4848(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22800,7 +22890,7 @@ GL_PREFIX(SecondaryColor3iEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4832(%rax), %r11
+	movq	4848(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3iEXT), .-GL_PREFIX(SecondaryColor3iEXT)
@@ -22811,25 +22901,25 @@ GL_PREFIX(SecondaryColor3iEXT):
 GL_PREFIX(SecondaryColor3ivEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4840(%rax), %r11
+	movq	4856(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4840(%rax), %r11
+	movq	4856(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4840(%rax), %r11
+	movq	4856(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4840(%rax), %r11
+	movq	4856(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3ivEXT), .-GL_PREFIX(SecondaryColor3ivEXT)
@@ -22840,7 +22930,7 @@ GL_PREFIX(SecondaryColor3ivEXT):
 GL_PREFIX(SecondaryColor3sEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4848(%rax), %r11
+	movq	4864(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22850,13 +22940,13 @@ GL_PREFIX(SecondaryColor3sEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4848(%rax), %r11
+	movq	4864(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4848(%rax), %r11
+	movq	4864(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22866,7 +22956,7 @@ GL_PREFIX(SecondaryColor3sEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4848(%rax), %r11
+	movq	4864(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3sEXT), .-GL_PREFIX(SecondaryColor3sEXT)
@@ -22877,25 +22967,25 @@ GL_PREFIX(SecondaryColor3sEXT):
 GL_PREFIX(SecondaryColor3svEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4856(%rax), %r11
+	movq	4872(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4856(%rax), %r11
+	movq	4872(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4856(%rax), %r11
+	movq	4872(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4856(%rax), %r11
+	movq	4872(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3svEXT), .-GL_PREFIX(SecondaryColor3svEXT)
@@ -22906,7 +22996,7 @@ GL_PREFIX(SecondaryColor3svEXT):
 GL_PREFIX(SecondaryColor3ubEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4864(%rax), %r11
+	movq	4880(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22916,13 +23006,13 @@ GL_PREFIX(SecondaryColor3ubEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4864(%rax), %r11
+	movq	4880(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4864(%rax), %r11
+	movq	4880(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22932,7 +23022,7 @@ GL_PREFIX(SecondaryColor3ubEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4864(%rax), %r11
+	movq	4880(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3ubEXT), .-GL_PREFIX(SecondaryColor3ubEXT)
@@ -22943,25 +23033,25 @@ GL_PREFIX(SecondaryColor3ubEXT):
 GL_PREFIX(SecondaryColor3ubvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4872(%rax), %r11
+	movq	4888(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4872(%rax), %r11
+	movq	4888(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4872(%rax), %r11
+	movq	4888(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4872(%rax), %r11
+	movq	4888(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3ubvEXT), .-GL_PREFIX(SecondaryColor3ubvEXT)
@@ -22972,7 +23062,7 @@ GL_PREFIX(SecondaryColor3ubvEXT):
 GL_PREFIX(SecondaryColor3uiEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4880(%rax), %r11
+	movq	4896(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -22982,13 +23072,13 @@ GL_PREFIX(SecondaryColor3uiEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4880(%rax), %r11
+	movq	4896(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4880(%rax), %r11
+	movq	4896(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -22998,7 +23088,7 @@ GL_PREFIX(SecondaryColor3uiEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4880(%rax), %r11
+	movq	4896(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3uiEXT), .-GL_PREFIX(SecondaryColor3uiEXT)
@@ -23009,25 +23099,25 @@ GL_PREFIX(SecondaryColor3uiEXT):
 GL_PREFIX(SecondaryColor3uivEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4888(%rax), %r11
+	movq	4904(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4888(%rax), %r11
+	movq	4904(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4888(%rax), %r11
+	movq	4904(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4888(%rax), %r11
+	movq	4904(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3uivEXT), .-GL_PREFIX(SecondaryColor3uivEXT)
@@ -23038,7 +23128,7 @@ GL_PREFIX(SecondaryColor3uivEXT):
 GL_PREFIX(SecondaryColor3usEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4896(%rax), %r11
+	movq	4912(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23048,13 +23138,13 @@ GL_PREFIX(SecondaryColor3usEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4896(%rax), %r11
+	movq	4912(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4896(%rax), %r11
+	movq	4912(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23064,7 +23154,7 @@ GL_PREFIX(SecondaryColor3usEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4896(%rax), %r11
+	movq	4912(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3usEXT), .-GL_PREFIX(SecondaryColor3usEXT)
@@ -23075,25 +23165,25 @@ GL_PREFIX(SecondaryColor3usEXT):
 GL_PREFIX(SecondaryColor3usvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4904(%rax), %r11
+	movq	4920(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4904(%rax), %r11
+	movq	4920(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4904(%rax), %r11
+	movq	4920(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4904(%rax), %r11
+	movq	4920(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColor3usvEXT), .-GL_PREFIX(SecondaryColor3usvEXT)
@@ -23104,7 +23194,7 @@ GL_PREFIX(SecondaryColor3usvEXT):
 GL_PREFIX(SecondaryColorPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4912(%rax), %r11
+	movq	4928(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23118,13 +23208,13 @@ GL_PREFIX(SecondaryColorPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4912(%rax), %r11
+	movq	4928(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4912(%rax), %r11
+	movq	4928(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23138,7 +23228,7 @@ GL_PREFIX(SecondaryColorPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4912(%rax), %r11
+	movq	4928(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SecondaryColorPointerEXT), .-GL_PREFIX(SecondaryColorPointerEXT)
@@ -23149,7 +23239,7 @@ GL_PREFIX(SecondaryColorPointerEXT):
 GL_PREFIX(MultiDrawArraysEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4920(%rax), %r11
+	movq	4936(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23163,13 +23253,13 @@ GL_PREFIX(MultiDrawArraysEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4920(%rax), %r11
+	movq	4936(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4920(%rax), %r11
+	movq	4936(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23183,7 +23273,7 @@ GL_PREFIX(MultiDrawArraysEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4920(%rax), %r11
+	movq	4936(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(MultiDrawArraysEXT), .-GL_PREFIX(MultiDrawArraysEXT)
@@ -23194,7 +23284,7 @@ GL_PREFIX(MultiDrawArraysEXT):
 GL_PREFIX(MultiDrawElementsEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4928(%rax), %r11
+	movq	4944(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23208,13 +23298,13 @@ GL_PREFIX(MultiDrawElementsEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4928(%rax), %r11
+	movq	4944(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4928(%rax), %r11
+	movq	4944(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23228,7 +23318,7 @@ GL_PREFIX(MultiDrawElementsEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4928(%rax), %r11
+	movq	4944(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(MultiDrawElementsEXT), .-GL_PREFIX(MultiDrawElementsEXT)
@@ -23239,7 +23329,7 @@ GL_PREFIX(MultiDrawElementsEXT):
 GL_PREFIX(FogCoordPointerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4936(%rax), %r11
+	movq	4952(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23249,13 +23339,13 @@ GL_PREFIX(FogCoordPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4936(%rax), %r11
+	movq	4952(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4936(%rax), %r11
+	movq	4952(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23265,7 +23355,7 @@ GL_PREFIX(FogCoordPointerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4936(%rax), %r11
+	movq	4952(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoordPointerEXT), .-GL_PREFIX(FogCoordPointerEXT)
@@ -23276,7 +23366,7 @@ GL_PREFIX(FogCoordPointerEXT):
 GL_PREFIX(FogCoorddEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4944(%rax), %r11
+	movq	4960(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$8, %rsp
@@ -23284,13 +23374,13 @@ GL_PREFIX(FogCoorddEXT):
 	call	_x86_64_get_dispatch@PLT
 	movq	(%rsp), %xmm0
 	addq	$8, %rsp
-	movq	4944(%rax), %r11
+	movq	4960(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4944(%rax), %r11
+	movq	4960(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$8, %rsp
@@ -23298,7 +23388,7 @@ GL_PREFIX(FogCoorddEXT):
 	call	_glapi_get_dispatch
 	movq	(%rsp), %xmm0
 	addq	$8, %rsp
-	movq	4944(%rax), %r11
+	movq	4960(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoorddEXT), .-GL_PREFIX(FogCoorddEXT)
@@ -23309,25 +23399,25 @@ GL_PREFIX(FogCoorddEXT):
 GL_PREFIX(FogCoorddvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4952(%rax), %r11
+	movq	4968(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4952(%rax), %r11
+	movq	4968(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4952(%rax), %r11
+	movq	4968(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4952(%rax), %r11
+	movq	4968(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoorddvEXT), .-GL_PREFIX(FogCoorddvEXT)
@@ -23338,7 +23428,7 @@ GL_PREFIX(FogCoorddvEXT):
 GL_PREFIX(FogCoordfEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4960(%rax), %r11
+	movq	4976(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$8, %rsp
@@ -23346,13 +23436,13 @@ GL_PREFIX(FogCoordfEXT):
 	call	_x86_64_get_dispatch@PLT
 	movq	(%rsp), %xmm0
 	addq	$8, %rsp
-	movq	4960(%rax), %r11
+	movq	4976(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4960(%rax), %r11
+	movq	4976(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$8, %rsp
@@ -23360,7 +23450,7 @@ GL_PREFIX(FogCoordfEXT):
 	call	_glapi_get_dispatch
 	movq	(%rsp), %xmm0
 	addq	$8, %rsp
-	movq	4960(%rax), %r11
+	movq	4976(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoordfEXT), .-GL_PREFIX(FogCoordfEXT)
@@ -23371,58 +23461,58 @@ GL_PREFIX(FogCoordfEXT):
 GL_PREFIX(FogCoordfvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4968(%rax), %r11
+	movq	4984(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4968(%rax), %r11
+	movq	4984(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4968(%rax), %r11
+	movq	4984(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4968(%rax), %r11
+	movq	4984(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FogCoordfvEXT), .-GL_PREFIX(FogCoordfvEXT)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_622)
-	.type	GL_PREFIX(_dispatch_stub_622), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_622))
-GL_PREFIX(_dispatch_stub_622):
+	.globl	GL_PREFIX(_dispatch_stub_624)
+	.type	GL_PREFIX(_dispatch_stub_624), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_624))
+GL_PREFIX(_dispatch_stub_624):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4976(%rax), %r11
+	movq	4992(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	4976(%rax), %r11
+	movq	4992(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4976(%rax), %r11
+	movq	4992(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	4976(%rax), %r11
+	movq	4992(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_622), .-GL_PREFIX(_dispatch_stub_622)
+	.size	GL_PREFIX(_dispatch_stub_624), .-GL_PREFIX(_dispatch_stub_624)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(BlendFuncSeparateEXT)
@@ -23430,7 +23520,7 @@ GL_PREFIX(_dispatch_stub_622):
 GL_PREFIX(BlendFuncSeparateEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4984(%rax), %r11
+	movq	5000(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23444,13 +23534,13 @@ GL_PREFIX(BlendFuncSeparateEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4984(%rax), %r11
+	movq	5000(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4984(%rax), %r11
+	movq	5000(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23464,7 +23554,7 @@ GL_PREFIX(BlendFuncSeparateEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	4984(%rax), %r11
+	movq	5000(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BlendFuncSeparateEXT), .-GL_PREFIX(BlendFuncSeparateEXT)
@@ -23475,25 +23565,25 @@ GL_PREFIX(BlendFuncSeparateEXT):
 GL_PREFIX(FlushVertexArrayRangeNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	4992(%rax), %r11
+	movq	5008(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	4992(%rax), %r11
+	movq	5008(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	4992(%rax), %r11
+	movq	5008(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	4992(%rax), %r11
+	movq	5008(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FlushVertexArrayRangeNV), .-GL_PREFIX(FlushVertexArrayRangeNV)
@@ -23504,7 +23594,7 @@ GL_PREFIX(FlushVertexArrayRangeNV):
 GL_PREFIX(VertexArrayRangeNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5000(%rax), %r11
+	movq	5016(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23514,13 +23604,13 @@ GL_PREFIX(VertexArrayRangeNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5000(%rax), %r11
+	movq	5016(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5000(%rax), %r11
+	movq	5016(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23530,7 +23620,7 @@ GL_PREFIX(VertexArrayRangeNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5000(%rax), %r11
+	movq	5016(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexArrayRangeNV), .-GL_PREFIX(VertexArrayRangeNV)
@@ -23541,7 +23631,7 @@ GL_PREFIX(VertexArrayRangeNV):
 GL_PREFIX(CombinerInputNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5008(%rax), %r11
+	movq	5024(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23559,13 +23649,13 @@ GL_PREFIX(CombinerInputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5008(%rax), %r11
+	movq	5024(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5008(%rax), %r11
+	movq	5024(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23583,7 +23673,7 @@ GL_PREFIX(CombinerInputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5008(%rax), %r11
+	movq	5024(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerInputNV), .-GL_PREFIX(CombinerInputNV)
@@ -23594,7 +23684,7 @@ GL_PREFIX(CombinerInputNV):
 GL_PREFIX(CombinerOutputNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5016(%rax), %r11
+	movq	5032(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23612,13 +23702,13 @@ GL_PREFIX(CombinerOutputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5016(%rax), %r11
+	movq	5032(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5016(%rax), %r11
+	movq	5032(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23636,7 +23726,7 @@ GL_PREFIX(CombinerOutputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5016(%rax), %r11
+	movq	5032(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerOutputNV), .-GL_PREFIX(CombinerOutputNV)
@@ -23647,7 +23737,7 @@ GL_PREFIX(CombinerOutputNV):
 GL_PREFIX(CombinerParameterfNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5024(%rax), %r11
+	movq	5040(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -23657,13 +23747,13 @@ GL_PREFIX(CombinerParameterfNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5024(%rax), %r11
+	movq	5040(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5024(%rax), %r11
+	movq	5040(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -23673,7 +23763,7 @@ GL_PREFIX(CombinerParameterfNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5024(%rax), %r11
+	movq	5040(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerParameterfNV), .-GL_PREFIX(CombinerParameterfNV)
@@ -23684,7 +23774,7 @@ GL_PREFIX(CombinerParameterfNV):
 GL_PREFIX(CombinerParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5032(%rax), %r11
+	movq	5048(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23694,13 +23784,13 @@ GL_PREFIX(CombinerParameterfvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5032(%rax), %r11
+	movq	5048(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5032(%rax), %r11
+	movq	5048(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23710,7 +23800,7 @@ GL_PREFIX(CombinerParameterfvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5032(%rax), %r11
+	movq	5048(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerParameterfvNV), .-GL_PREFIX(CombinerParameterfvNV)
@@ -23721,7 +23811,7 @@ GL_PREFIX(CombinerParameterfvNV):
 GL_PREFIX(CombinerParameteriNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5040(%rax), %r11
+	movq	5056(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23731,13 +23821,13 @@ GL_PREFIX(CombinerParameteriNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5040(%rax), %r11
+	movq	5056(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5040(%rax), %r11
+	movq	5056(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23747,7 +23837,7 @@ GL_PREFIX(CombinerParameteriNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5040(%rax), %r11
+	movq	5056(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerParameteriNV), .-GL_PREFIX(CombinerParameteriNV)
@@ -23758,7 +23848,7 @@ GL_PREFIX(CombinerParameteriNV):
 GL_PREFIX(CombinerParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5048(%rax), %r11
+	movq	5064(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23768,13 +23858,13 @@ GL_PREFIX(CombinerParameterivNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5048(%rax), %r11
+	movq	5064(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5048(%rax), %r11
+	movq	5064(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23784,7 +23874,7 @@ GL_PREFIX(CombinerParameterivNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5048(%rax), %r11
+	movq	5064(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CombinerParameterivNV), .-GL_PREFIX(CombinerParameterivNV)
@@ -23795,7 +23885,7 @@ GL_PREFIX(CombinerParameterivNV):
 GL_PREFIX(FinalCombinerInputNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5056(%rax), %r11
+	movq	5072(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23809,13 +23899,13 @@ GL_PREFIX(FinalCombinerInputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5056(%rax), %r11
+	movq	5072(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5056(%rax), %r11
+	movq	5072(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23829,7 +23919,7 @@ GL_PREFIX(FinalCombinerInputNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5056(%rax), %r11
+	movq	5072(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FinalCombinerInputNV), .-GL_PREFIX(FinalCombinerInputNV)
@@ -23840,7 +23930,7 @@ GL_PREFIX(FinalCombinerInputNV):
 GL_PREFIX(GetCombinerInputParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5064(%rax), %r11
+	movq	5080(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23854,13 +23944,13 @@ GL_PREFIX(GetCombinerInputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5064(%rax), %r11
+	movq	5080(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5064(%rax), %r11
+	movq	5080(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23874,7 +23964,7 @@ GL_PREFIX(GetCombinerInputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5064(%rax), %r11
+	movq	5080(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetCombinerInputParameterfvNV), .-GL_PREFIX(GetCombinerInputParameterfvNV)
@@ -23885,7 +23975,7 @@ GL_PREFIX(GetCombinerInputParameterfvNV):
 GL_PREFIX(GetCombinerInputParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5072(%rax), %r11
+	movq	5088(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23899,13 +23989,13 @@ GL_PREFIX(GetCombinerInputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5072(%rax), %r11
+	movq	5088(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5072(%rax), %r11
+	movq	5088(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23919,7 +24009,7 @@ GL_PREFIX(GetCombinerInputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5072(%rax), %r11
+	movq	5088(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetCombinerInputParameterivNV), .-GL_PREFIX(GetCombinerInputParameterivNV)
@@ -23930,7 +24020,7 @@ GL_PREFIX(GetCombinerInputParameterivNV):
 GL_PREFIX(GetCombinerOutputParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5080(%rax), %r11
+	movq	5096(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23944,13 +24034,13 @@ GL_PREFIX(GetCombinerOutputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5080(%rax), %r11
+	movq	5096(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5080(%rax), %r11
+	movq	5096(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -23964,7 +24054,7 @@ GL_PREFIX(GetCombinerOutputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5080(%rax), %r11
+	movq	5096(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetCombinerOutputParameterfvNV), .-GL_PREFIX(GetCombinerOutputParameterfvNV)
@@ -23975,7 +24065,7 @@ GL_PREFIX(GetCombinerOutputParameterfvNV):
 GL_PREFIX(GetCombinerOutputParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5088(%rax), %r11
+	movq	5104(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -23989,13 +24079,13 @@ GL_PREFIX(GetCombinerOutputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5088(%rax), %r11
+	movq	5104(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5088(%rax), %r11
+	movq	5104(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24009,7 +24099,7 @@ GL_PREFIX(GetCombinerOutputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5088(%rax), %r11
+	movq	5104(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetCombinerOutputParameterivNV), .-GL_PREFIX(GetCombinerOutputParameterivNV)
@@ -24020,7 +24110,7 @@ GL_PREFIX(GetCombinerOutputParameterivNV):
 GL_PREFIX(GetFinalCombinerInputParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5096(%rax), %r11
+	movq	5112(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24030,13 +24120,13 @@ GL_PREFIX(GetFinalCombinerInputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5096(%rax), %r11
+	movq	5112(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5096(%rax), %r11
+	movq	5112(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24046,7 +24136,7 @@ GL_PREFIX(GetFinalCombinerInputParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5096(%rax), %r11
+	movq	5112(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetFinalCombinerInputParameterfvNV), .-GL_PREFIX(GetFinalCombinerInputParameterfvNV)
@@ -24057,7 +24147,7 @@ GL_PREFIX(GetFinalCombinerInputParameterfvNV):
 GL_PREFIX(GetFinalCombinerInputParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5104(%rax), %r11
+	movq	5120(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24067,13 +24157,13 @@ GL_PREFIX(GetFinalCombinerInputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5104(%rax), %r11
+	movq	5120(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5104(%rax), %r11
+	movq	5120(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24083,7 +24173,7 @@ GL_PREFIX(GetFinalCombinerInputParameterivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5104(%rax), %r11
+	movq	5120(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetFinalCombinerInputParameterivNV), .-GL_PREFIX(GetFinalCombinerInputParameterivNV)
@@ -24094,25 +24184,25 @@ GL_PREFIX(GetFinalCombinerInputParameterivNV):
 GL_PREFIX(ResizeBuffersMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5112(%rax), %r11
+	movq	5128(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	5112(%rax), %r11
+	movq	5128(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5112(%rax), %r11
+	movq	5128(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	5112(%rax), %r11
+	movq	5128(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ResizeBuffersMESA), .-GL_PREFIX(ResizeBuffersMESA)
@@ -24123,7 +24213,7 @@ GL_PREFIX(ResizeBuffersMESA):
 GL_PREFIX(WindowPos2dMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5120(%rax), %r11
+	movq	5136(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -24133,13 +24223,13 @@ GL_PREFIX(WindowPos2dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5120(%rax), %r11
+	movq	5136(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5120(%rax), %r11
+	movq	5136(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -24149,7 +24239,7 @@ GL_PREFIX(WindowPos2dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5120(%rax), %r11
+	movq	5136(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2dMESA), .-GL_PREFIX(WindowPos2dMESA)
@@ -24160,25 +24250,25 @@ GL_PREFIX(WindowPos2dMESA):
 GL_PREFIX(WindowPos2dvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5128(%rax), %r11
+	movq	5144(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5128(%rax), %r11
+	movq	5144(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5128(%rax), %r11
+	movq	5144(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5128(%rax), %r11
+	movq	5144(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2dvMESA), .-GL_PREFIX(WindowPos2dvMESA)
@@ -24189,7 +24279,7 @@ GL_PREFIX(WindowPos2dvMESA):
 GL_PREFIX(WindowPos2fMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5136(%rax), %r11
+	movq	5152(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -24199,13 +24289,13 @@ GL_PREFIX(WindowPos2fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5136(%rax), %r11
+	movq	5152(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5136(%rax), %r11
+	movq	5152(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -24215,7 +24305,7 @@ GL_PREFIX(WindowPos2fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5136(%rax), %r11
+	movq	5152(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2fMESA), .-GL_PREFIX(WindowPos2fMESA)
@@ -24226,25 +24316,25 @@ GL_PREFIX(WindowPos2fMESA):
 GL_PREFIX(WindowPos2fvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5144(%rax), %r11
+	movq	5160(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5144(%rax), %r11
+	movq	5160(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5144(%rax), %r11
+	movq	5160(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5144(%rax), %r11
+	movq	5160(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2fvMESA), .-GL_PREFIX(WindowPos2fvMESA)
@@ -24255,7 +24345,7 @@ GL_PREFIX(WindowPos2fvMESA):
 GL_PREFIX(WindowPos2iMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5152(%rax), %r11
+	movq	5168(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24265,13 +24355,13 @@ GL_PREFIX(WindowPos2iMESA):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5152(%rax), %r11
+	movq	5168(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5152(%rax), %r11
+	movq	5168(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24281,7 +24371,7 @@ GL_PREFIX(WindowPos2iMESA):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5152(%rax), %r11
+	movq	5168(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2iMESA), .-GL_PREFIX(WindowPos2iMESA)
@@ -24292,25 +24382,25 @@ GL_PREFIX(WindowPos2iMESA):
 GL_PREFIX(WindowPos2ivMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5160(%rax), %r11
+	movq	5176(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5160(%rax), %r11
+	movq	5176(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5160(%rax), %r11
+	movq	5176(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5160(%rax), %r11
+	movq	5176(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2ivMESA), .-GL_PREFIX(WindowPos2ivMESA)
@@ -24321,7 +24411,7 @@ GL_PREFIX(WindowPos2ivMESA):
 GL_PREFIX(WindowPos2sMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5168(%rax), %r11
+	movq	5184(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24331,13 +24421,13 @@ GL_PREFIX(WindowPos2sMESA):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5168(%rax), %r11
+	movq	5184(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5168(%rax), %r11
+	movq	5184(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24347,7 +24437,7 @@ GL_PREFIX(WindowPos2sMESA):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5168(%rax), %r11
+	movq	5184(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2sMESA), .-GL_PREFIX(WindowPos2sMESA)
@@ -24358,25 +24448,25 @@ GL_PREFIX(WindowPos2sMESA):
 GL_PREFIX(WindowPos2svMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5176(%rax), %r11
+	movq	5192(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5176(%rax), %r11
+	movq	5192(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5176(%rax), %r11
+	movq	5192(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5176(%rax), %r11
+	movq	5192(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos2svMESA), .-GL_PREFIX(WindowPos2svMESA)
@@ -24387,7 +24477,7 @@ GL_PREFIX(WindowPos2svMESA):
 GL_PREFIX(WindowPos3dMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5184(%rax), %r11
+	movq	5200(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -24399,13 +24489,13 @@ GL_PREFIX(WindowPos3dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5184(%rax), %r11
+	movq	5200(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5184(%rax), %r11
+	movq	5200(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -24417,7 +24507,7 @@ GL_PREFIX(WindowPos3dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5184(%rax), %r11
+	movq	5200(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3dMESA), .-GL_PREFIX(WindowPos3dMESA)
@@ -24428,25 +24518,25 @@ GL_PREFIX(WindowPos3dMESA):
 GL_PREFIX(WindowPos3dvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5192(%rax), %r11
+	movq	5208(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5192(%rax), %r11
+	movq	5208(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5192(%rax), %r11
+	movq	5208(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5192(%rax), %r11
+	movq	5208(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3dvMESA), .-GL_PREFIX(WindowPos3dvMESA)
@@ -24457,7 +24547,7 @@ GL_PREFIX(WindowPos3dvMESA):
 GL_PREFIX(WindowPos3fMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5200(%rax), %r11
+	movq	5216(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -24469,13 +24559,13 @@ GL_PREFIX(WindowPos3fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5200(%rax), %r11
+	movq	5216(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5200(%rax), %r11
+	movq	5216(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -24487,7 +24577,7 @@ GL_PREFIX(WindowPos3fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$24, %rsp
-	movq	5200(%rax), %r11
+	movq	5216(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3fMESA), .-GL_PREFIX(WindowPos3fMESA)
@@ -24498,25 +24588,25 @@ GL_PREFIX(WindowPos3fMESA):
 GL_PREFIX(WindowPos3fvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5208(%rax), %r11
+	movq	5224(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5208(%rax), %r11
+	movq	5224(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5208(%rax), %r11
+	movq	5224(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5208(%rax), %r11
+	movq	5224(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3fvMESA), .-GL_PREFIX(WindowPos3fvMESA)
@@ -24527,7 +24617,7 @@ GL_PREFIX(WindowPos3fvMESA):
 GL_PREFIX(WindowPos3iMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5216(%rax), %r11
+	movq	5232(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24537,13 +24627,13 @@ GL_PREFIX(WindowPos3iMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5216(%rax), %r11
+	movq	5232(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5216(%rax), %r11
+	movq	5232(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24553,7 +24643,7 @@ GL_PREFIX(WindowPos3iMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5216(%rax), %r11
+	movq	5232(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3iMESA), .-GL_PREFIX(WindowPos3iMESA)
@@ -24564,25 +24654,25 @@ GL_PREFIX(WindowPos3iMESA):
 GL_PREFIX(WindowPos3ivMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5224(%rax), %r11
+	movq	5240(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5224(%rax), %r11
+	movq	5240(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5224(%rax), %r11
+	movq	5240(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5224(%rax), %r11
+	movq	5240(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3ivMESA), .-GL_PREFIX(WindowPos3ivMESA)
@@ -24593,7 +24683,7 @@ GL_PREFIX(WindowPos3ivMESA):
 GL_PREFIX(WindowPos3sMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5232(%rax), %r11
+	movq	5248(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24603,13 +24693,13 @@ GL_PREFIX(WindowPos3sMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5232(%rax), %r11
+	movq	5248(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5232(%rax), %r11
+	movq	5248(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24619,7 +24709,7 @@ GL_PREFIX(WindowPos3sMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5232(%rax), %r11
+	movq	5248(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3sMESA), .-GL_PREFIX(WindowPos3sMESA)
@@ -24630,25 +24720,25 @@ GL_PREFIX(WindowPos3sMESA):
 GL_PREFIX(WindowPos3svMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5240(%rax), %r11
+	movq	5256(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5240(%rax), %r11
+	movq	5256(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5240(%rax), %r11
+	movq	5256(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5240(%rax), %r11
+	movq	5256(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos3svMESA), .-GL_PREFIX(WindowPos3svMESA)
@@ -24659,7 +24749,7 @@ GL_PREFIX(WindowPos3svMESA):
 GL_PREFIX(WindowPos4dMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5248(%rax), %r11
+	movq	5264(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -24673,13 +24763,13 @@ GL_PREFIX(WindowPos4dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$40, %rsp
-	movq	5248(%rax), %r11
+	movq	5264(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5248(%rax), %r11
+	movq	5264(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -24693,7 +24783,7 @@ GL_PREFIX(WindowPos4dMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$40, %rsp
-	movq	5248(%rax), %r11
+	movq	5264(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4dMESA), .-GL_PREFIX(WindowPos4dMESA)
@@ -24704,25 +24794,25 @@ GL_PREFIX(WindowPos4dMESA):
 GL_PREFIX(WindowPos4dvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5256(%rax), %r11
+	movq	5272(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5256(%rax), %r11
+	movq	5272(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5256(%rax), %r11
+	movq	5272(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5256(%rax), %r11
+	movq	5272(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4dvMESA), .-GL_PREFIX(WindowPos4dvMESA)
@@ -24733,7 +24823,7 @@ GL_PREFIX(WindowPos4dvMESA):
 GL_PREFIX(WindowPos4fMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5264(%rax), %r11
+	movq	5280(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -24747,13 +24837,13 @@ GL_PREFIX(WindowPos4fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$40, %rsp
-	movq	5264(%rax), %r11
+	movq	5280(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5264(%rax), %r11
+	movq	5280(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -24767,7 +24857,7 @@ GL_PREFIX(WindowPos4fMESA):
 	movq	8(%rsp), %xmm1
 	movq	(%rsp), %xmm0
 	addq	$40, %rsp
-	movq	5264(%rax), %r11
+	movq	5280(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4fMESA), .-GL_PREFIX(WindowPos4fMESA)
@@ -24778,25 +24868,25 @@ GL_PREFIX(WindowPos4fMESA):
 GL_PREFIX(WindowPos4fvMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5272(%rax), %r11
+	movq	5288(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5272(%rax), %r11
+	movq	5288(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5272(%rax), %r11
+	movq	5288(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5272(%rax), %r11
+	movq	5288(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4fvMESA), .-GL_PREFIX(WindowPos4fvMESA)
@@ -24807,7 +24897,7 @@ GL_PREFIX(WindowPos4fvMESA):
 GL_PREFIX(WindowPos4iMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5280(%rax), %r11
+	movq	5296(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24821,13 +24911,13 @@ GL_PREFIX(WindowPos4iMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5280(%rax), %r11
+	movq	5296(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5280(%rax), %r11
+	movq	5296(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24841,7 +24931,7 @@ GL_PREFIX(WindowPos4iMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5280(%rax), %r11
+	movq	5296(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4iMESA), .-GL_PREFIX(WindowPos4iMESA)
@@ -24852,25 +24942,25 @@ GL_PREFIX(WindowPos4iMESA):
 GL_PREFIX(WindowPos4ivMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5288(%rax), %r11
+	movq	5304(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5288(%rax), %r11
+	movq	5304(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5288(%rax), %r11
+	movq	5304(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5288(%rax), %r11
+	movq	5304(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4ivMESA), .-GL_PREFIX(WindowPos4ivMESA)
@@ -24881,7 +24971,7 @@ GL_PREFIX(WindowPos4ivMESA):
 GL_PREFIX(WindowPos4sMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5296(%rax), %r11
+	movq	5312(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24895,13 +24985,13 @@ GL_PREFIX(WindowPos4sMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5296(%rax), %r11
+	movq	5312(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5296(%rax), %r11
+	movq	5312(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24915,7 +25005,7 @@ GL_PREFIX(WindowPos4sMESA):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5296(%rax), %r11
+	movq	5312(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4sMESA), .-GL_PREFIX(WindowPos4sMESA)
@@ -24926,37 +25016,37 @@ GL_PREFIX(WindowPos4sMESA):
 GL_PREFIX(WindowPos4svMESA):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5304(%rax), %r11
+	movq	5320(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5304(%rax), %r11
+	movq	5320(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5304(%rax), %r11
+	movq	5320(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5304(%rax), %r11
+	movq	5320(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(WindowPos4svMESA), .-GL_PREFIX(WindowPos4svMESA)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_664)
-	.type	GL_PREFIX(_dispatch_stub_664), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_664))
-GL_PREFIX(_dispatch_stub_664):
+	.globl	GL_PREFIX(_dispatch_stub_666)
+	.type	GL_PREFIX(_dispatch_stub_666), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_666))
+GL_PREFIX(_dispatch_stub_666):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5312(%rax), %r11
+	movq	5328(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -24970,13 +25060,13 @@ GL_PREFIX(_dispatch_stub_664):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5312(%rax), %r11
+	movq	5328(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5312(%rax), %r11
+	movq	5328(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -24990,19 +25080,19 @@ GL_PREFIX(_dispatch_stub_664):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5312(%rax), %r11
+	movq	5328(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_664), .-GL_PREFIX(_dispatch_stub_664)
+	.size	GL_PREFIX(_dispatch_stub_666), .-GL_PREFIX(_dispatch_stub_666)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_665)
-	.type	GL_PREFIX(_dispatch_stub_665), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_665))
-GL_PREFIX(_dispatch_stub_665):
+	.globl	GL_PREFIX(_dispatch_stub_667)
+	.type	GL_PREFIX(_dispatch_stub_667), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_667))
+GL_PREFIX(_dispatch_stub_667):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5320(%rax), %r11
+	movq	5336(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25020,13 +25110,13 @@ GL_PREFIX(_dispatch_stub_665):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5320(%rax), %r11
+	movq	5336(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5320(%rax), %r11
+	movq	5336(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25044,19 +25134,19 @@ GL_PREFIX(_dispatch_stub_665):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5320(%rax), %r11
+	movq	5336(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_665), .-GL_PREFIX(_dispatch_stub_665)
+	.size	GL_PREFIX(_dispatch_stub_667), .-GL_PREFIX(_dispatch_stub_667)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_666)
-	.type	GL_PREFIX(_dispatch_stub_666), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_666))
-GL_PREFIX(_dispatch_stub_666):
+	.globl	GL_PREFIX(_dispatch_stub_668)
+	.type	GL_PREFIX(_dispatch_stub_668), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_668))
+GL_PREFIX(_dispatch_stub_668):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5328(%rax), %r11
+	movq	5344(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25066,13 +25156,13 @@ GL_PREFIX(_dispatch_stub_666):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5328(%rax), %r11
+	movq	5344(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5328(%rax), %r11
+	movq	5344(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25082,49 +25172,49 @@ GL_PREFIX(_dispatch_stub_666):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5328(%rax), %r11
+	movq	5344(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_666), .-GL_PREFIX(_dispatch_stub_666)
+	.size	GL_PREFIX(_dispatch_stub_668), .-GL_PREFIX(_dispatch_stub_668)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_667)
-	.type	GL_PREFIX(_dispatch_stub_667), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_667))
-GL_PREFIX(_dispatch_stub_667):
+	.globl	GL_PREFIX(_dispatch_stub_669)
+	.type	GL_PREFIX(_dispatch_stub_669), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_669))
+GL_PREFIX(_dispatch_stub_669):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5336(%rax), %r11
+	movq	5352(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5336(%rax), %r11
+	movq	5352(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5336(%rax), %r11
+	movq	5352(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5336(%rax), %r11
+	movq	5352(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_667), .-GL_PREFIX(_dispatch_stub_667)
+	.size	GL_PREFIX(_dispatch_stub_669), .-GL_PREFIX(_dispatch_stub_669)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_668)
-	.type	GL_PREFIX(_dispatch_stub_668), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_668))
-GL_PREFIX(_dispatch_stub_668):
+	.globl	GL_PREFIX(_dispatch_stub_670)
+	.type	GL_PREFIX(_dispatch_stub_670), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_670))
+GL_PREFIX(_dispatch_stub_670):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5344(%rax), %r11
+	movq	5360(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25134,13 +25224,13 @@ GL_PREFIX(_dispatch_stub_668):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5344(%rax), %r11
+	movq	5360(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5344(%rax), %r11
+	movq	5360(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25150,19 +25240,19 @@ GL_PREFIX(_dispatch_stub_668):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5344(%rax), %r11
+	movq	5360(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_668), .-GL_PREFIX(_dispatch_stub_668)
+	.size	GL_PREFIX(_dispatch_stub_670), .-GL_PREFIX(_dispatch_stub_670)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_669)
-	.type	GL_PREFIX(_dispatch_stub_669), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_669))
-GL_PREFIX(_dispatch_stub_669):
+	.globl	GL_PREFIX(_dispatch_stub_671)
+	.type	GL_PREFIX(_dispatch_stub_671), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_671))
+GL_PREFIX(_dispatch_stub_671):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5352(%rax), %r11
+	movq	5368(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25172,13 +25262,13 @@ GL_PREFIX(_dispatch_stub_669):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5352(%rax), %r11
+	movq	5368(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5352(%rax), %r11
+	movq	5368(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25188,49 +25278,49 @@ GL_PREFIX(_dispatch_stub_669):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5352(%rax), %r11
+	movq	5368(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_669), .-GL_PREFIX(_dispatch_stub_669)
+	.size	GL_PREFIX(_dispatch_stub_671), .-GL_PREFIX(_dispatch_stub_671)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_670)
-	.type	GL_PREFIX(_dispatch_stub_670), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_670))
-GL_PREFIX(_dispatch_stub_670):
+	.globl	GL_PREFIX(_dispatch_stub_672)
+	.type	GL_PREFIX(_dispatch_stub_672), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_672))
+GL_PREFIX(_dispatch_stub_672):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5360(%rax), %r11
+	movq	5376(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5360(%rax), %r11
+	movq	5376(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5360(%rax), %r11
+	movq	5376(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5360(%rax), %r11
+	movq	5376(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_670), .-GL_PREFIX(_dispatch_stub_670)
+	.size	GL_PREFIX(_dispatch_stub_672), .-GL_PREFIX(_dispatch_stub_672)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_671)
-	.type	GL_PREFIX(_dispatch_stub_671), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_671))
-GL_PREFIX(_dispatch_stub_671):
+	.globl	GL_PREFIX(_dispatch_stub_673)
+	.type	GL_PREFIX(_dispatch_stub_673), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_673))
+GL_PREFIX(_dispatch_stub_673):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5368(%rax), %r11
+	movq	5384(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25240,13 +25330,13 @@ GL_PREFIX(_dispatch_stub_671):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5368(%rax), %r11
+	movq	5384(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5368(%rax), %r11
+	movq	5384(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25256,40 +25346,40 @@ GL_PREFIX(_dispatch_stub_671):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5368(%rax), %r11
+	movq	5384(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_671), .-GL_PREFIX(_dispatch_stub_671)
+	.size	GL_PREFIX(_dispatch_stub_673), .-GL_PREFIX(_dispatch_stub_673)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_672)
-	.type	GL_PREFIX(_dispatch_stub_672), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_672))
-GL_PREFIX(_dispatch_stub_672):
+	.globl	GL_PREFIX(_dispatch_stub_674)
+	.type	GL_PREFIX(_dispatch_stub_674), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_674))
+GL_PREFIX(_dispatch_stub_674):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5376(%rax), %r11
+	movq	5392(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5376(%rax), %r11
+	movq	5392(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5376(%rax), %r11
+	movq	5392(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5376(%rax), %r11
+	movq	5392(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_672), .-GL_PREFIX(_dispatch_stub_672)
+	.size	GL_PREFIX(_dispatch_stub_674), .-GL_PREFIX(_dispatch_stub_674)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(AreProgramsResidentNV)
@@ -25297,7 +25387,7 @@ GL_PREFIX(_dispatch_stub_672):
 GL_PREFIX(AreProgramsResidentNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5384(%rax), %r11
+	movq	5400(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25307,13 +25397,13 @@ GL_PREFIX(AreProgramsResidentNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5384(%rax), %r11
+	movq	5400(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5384(%rax), %r11
+	movq	5400(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25323,7 +25413,7 @@ GL_PREFIX(AreProgramsResidentNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5384(%rax), %r11
+	movq	5400(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(AreProgramsResidentNV), .-GL_PREFIX(AreProgramsResidentNV)
@@ -25334,7 +25424,7 @@ GL_PREFIX(AreProgramsResidentNV):
 GL_PREFIX(BindProgramNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5392(%rax), %r11
+	movq	5408(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25344,13 +25434,13 @@ GL_PREFIX(BindProgramNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5392(%rax), %r11
+	movq	5408(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5392(%rax), %r11
+	movq	5408(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25360,7 +25450,7 @@ GL_PREFIX(BindProgramNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5392(%rax), %r11
+	movq	5408(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindProgramNV), .-GL_PREFIX(BindProgramNV)
@@ -25371,7 +25461,7 @@ GL_PREFIX(BindProgramNV):
 GL_PREFIX(DeleteProgramsNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5400(%rax), %r11
+	movq	5416(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25381,13 +25471,13 @@ GL_PREFIX(DeleteProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5400(%rax), %r11
+	movq	5416(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5400(%rax), %r11
+	movq	5416(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25397,7 +25487,7 @@ GL_PREFIX(DeleteProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5400(%rax), %r11
+	movq	5416(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteProgramsNV), .-GL_PREFIX(DeleteProgramsNV)
@@ -25408,7 +25498,7 @@ GL_PREFIX(DeleteProgramsNV):
 GL_PREFIX(ExecuteProgramNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5408(%rax), %r11
+	movq	5424(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25418,13 +25508,13 @@ GL_PREFIX(ExecuteProgramNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5408(%rax), %r11
+	movq	5424(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5408(%rax), %r11
+	movq	5424(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25434,7 +25524,7 @@ GL_PREFIX(ExecuteProgramNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5408(%rax), %r11
+	movq	5424(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ExecuteProgramNV), .-GL_PREFIX(ExecuteProgramNV)
@@ -25445,7 +25535,7 @@ GL_PREFIX(ExecuteProgramNV):
 GL_PREFIX(GenProgramsNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5416(%rax), %r11
+	movq	5432(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25455,13 +25545,13 @@ GL_PREFIX(GenProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5416(%rax), %r11
+	movq	5432(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5416(%rax), %r11
+	movq	5432(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25471,7 +25561,7 @@ GL_PREFIX(GenProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5416(%rax), %r11
+	movq	5432(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenProgramsNV), .-GL_PREFIX(GenProgramsNV)
@@ -25482,7 +25572,7 @@ GL_PREFIX(GenProgramsNV):
 GL_PREFIX(GetProgramParameterdvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5424(%rax), %r11
+	movq	5440(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25496,13 +25586,13 @@ GL_PREFIX(GetProgramParameterdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5424(%rax), %r11
+	movq	5440(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5424(%rax), %r11
+	movq	5440(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25516,7 +25606,7 @@ GL_PREFIX(GetProgramParameterdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5424(%rax), %r11
+	movq	5440(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramParameterdvNV), .-GL_PREFIX(GetProgramParameterdvNV)
@@ -25527,7 +25617,7 @@ GL_PREFIX(GetProgramParameterdvNV):
 GL_PREFIX(GetProgramParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5432(%rax), %r11
+	movq	5448(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25541,13 +25631,13 @@ GL_PREFIX(GetProgramParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5432(%rax), %r11
+	movq	5448(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5432(%rax), %r11
+	movq	5448(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25561,7 +25651,7 @@ GL_PREFIX(GetProgramParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5432(%rax), %r11
+	movq	5448(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramParameterfvNV), .-GL_PREFIX(GetProgramParameterfvNV)
@@ -25572,7 +25662,7 @@ GL_PREFIX(GetProgramParameterfvNV):
 GL_PREFIX(GetProgramStringNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5440(%rax), %r11
+	movq	5456(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25582,13 +25672,13 @@ GL_PREFIX(GetProgramStringNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5440(%rax), %r11
+	movq	5456(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5440(%rax), %r11
+	movq	5456(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25598,7 +25688,7 @@ GL_PREFIX(GetProgramStringNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5440(%rax), %r11
+	movq	5456(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramStringNV), .-GL_PREFIX(GetProgramStringNV)
@@ -25609,7 +25699,7 @@ GL_PREFIX(GetProgramStringNV):
 GL_PREFIX(GetProgramivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5448(%rax), %r11
+	movq	5464(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25619,13 +25709,13 @@ GL_PREFIX(GetProgramivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5448(%rax), %r11
+	movq	5464(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5448(%rax), %r11
+	movq	5464(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25635,7 +25725,7 @@ GL_PREFIX(GetProgramivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5448(%rax), %r11
+	movq	5464(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramivNV), .-GL_PREFIX(GetProgramivNV)
@@ -25646,7 +25736,7 @@ GL_PREFIX(GetProgramivNV):
 GL_PREFIX(GetTrackMatrixivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5456(%rax), %r11
+	movq	5472(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25660,13 +25750,13 @@ GL_PREFIX(GetTrackMatrixivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5456(%rax), %r11
+	movq	5472(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5456(%rax), %r11
+	movq	5472(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25680,7 +25770,7 @@ GL_PREFIX(GetTrackMatrixivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5456(%rax), %r11
+	movq	5472(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetTrackMatrixivNV), .-GL_PREFIX(GetTrackMatrixivNV)
@@ -25691,7 +25781,7 @@ GL_PREFIX(GetTrackMatrixivNV):
 GL_PREFIX(GetVertexAttribPointervNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5464(%rax), %r11
+	movq	5480(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25701,13 +25791,13 @@ GL_PREFIX(GetVertexAttribPointervNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5464(%rax), %r11
+	movq	5480(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5464(%rax), %r11
+	movq	5480(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25717,7 +25807,7 @@ GL_PREFIX(GetVertexAttribPointervNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5464(%rax), %r11
+	movq	5480(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribPointervNV), .-GL_PREFIX(GetVertexAttribPointervNV)
@@ -25728,7 +25818,7 @@ GL_PREFIX(GetVertexAttribPointervNV):
 GL_PREFIX(GetVertexAttribdvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5472(%rax), %r11
+	movq	5488(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25738,13 +25828,13 @@ GL_PREFIX(GetVertexAttribdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5472(%rax), %r11
+	movq	5488(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5472(%rax), %r11
+	movq	5488(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25754,7 +25844,7 @@ GL_PREFIX(GetVertexAttribdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5472(%rax), %r11
+	movq	5488(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribdvNV), .-GL_PREFIX(GetVertexAttribdvNV)
@@ -25765,7 +25855,7 @@ GL_PREFIX(GetVertexAttribdvNV):
 GL_PREFIX(GetVertexAttribfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5480(%rax), %r11
+	movq	5496(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25775,13 +25865,13 @@ GL_PREFIX(GetVertexAttribfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5480(%rax), %r11
+	movq	5496(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5480(%rax), %r11
+	movq	5496(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25791,7 +25881,7 @@ GL_PREFIX(GetVertexAttribfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5480(%rax), %r11
+	movq	5496(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribfvNV), .-GL_PREFIX(GetVertexAttribfvNV)
@@ -25802,7 +25892,7 @@ GL_PREFIX(GetVertexAttribfvNV):
 GL_PREFIX(GetVertexAttribivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5488(%rax), %r11
+	movq	5504(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25812,13 +25902,13 @@ GL_PREFIX(GetVertexAttribivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5488(%rax), %r11
+	movq	5504(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5488(%rax), %r11
+	movq	5504(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25828,7 +25918,7 @@ GL_PREFIX(GetVertexAttribivNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5488(%rax), %r11
+	movq	5504(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetVertexAttribivNV), .-GL_PREFIX(GetVertexAttribivNV)
@@ -25839,25 +25929,25 @@ GL_PREFIX(GetVertexAttribivNV):
 GL_PREFIX(IsProgramNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5496(%rax), %r11
+	movq	5512(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5496(%rax), %r11
+	movq	5512(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5496(%rax), %r11
+	movq	5512(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5496(%rax), %r11
+	movq	5512(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsProgramNV), .-GL_PREFIX(IsProgramNV)
@@ -25868,7 +25958,7 @@ GL_PREFIX(IsProgramNV):
 GL_PREFIX(LoadProgramNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5504(%rax), %r11
+	movq	5520(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25882,13 +25972,13 @@ GL_PREFIX(LoadProgramNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5504(%rax), %r11
+	movq	5520(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5504(%rax), %r11
+	movq	5520(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25902,7 +25992,7 @@ GL_PREFIX(LoadProgramNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5504(%rax), %r11
+	movq	5520(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(LoadProgramNV), .-GL_PREFIX(LoadProgramNV)
@@ -25913,7 +26003,7 @@ GL_PREFIX(LoadProgramNV):
 GL_PREFIX(ProgramParameters4dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5512(%rax), %r11
+	movq	5528(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25927,13 +26017,13 @@ GL_PREFIX(ProgramParameters4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5512(%rax), %r11
+	movq	5528(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5512(%rax), %r11
+	movq	5528(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25947,7 +26037,7 @@ GL_PREFIX(ProgramParameters4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5512(%rax), %r11
+	movq	5528(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramParameters4dvNV), .-GL_PREFIX(ProgramParameters4dvNV)
@@ -25958,7 +26048,7 @@ GL_PREFIX(ProgramParameters4dvNV):
 GL_PREFIX(ProgramParameters4fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5520(%rax), %r11
+	movq	5536(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -25972,13 +26062,13 @@ GL_PREFIX(ProgramParameters4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5520(%rax), %r11
+	movq	5536(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5520(%rax), %r11
+	movq	5536(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -25992,7 +26082,7 @@ GL_PREFIX(ProgramParameters4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5520(%rax), %r11
+	movq	5536(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramParameters4fvNV), .-GL_PREFIX(ProgramParameters4fvNV)
@@ -26003,7 +26093,7 @@ GL_PREFIX(ProgramParameters4fvNV):
 GL_PREFIX(RequestResidentProgramsNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5528(%rax), %r11
+	movq	5544(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26013,13 +26103,13 @@ GL_PREFIX(RequestResidentProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5528(%rax), %r11
+	movq	5544(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5528(%rax), %r11
+	movq	5544(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26029,7 +26119,7 @@ GL_PREFIX(RequestResidentProgramsNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5528(%rax), %r11
+	movq	5544(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(RequestResidentProgramsNV), .-GL_PREFIX(RequestResidentProgramsNV)
@@ -26040,7 +26130,7 @@ GL_PREFIX(RequestResidentProgramsNV):
 GL_PREFIX(TrackMatrixNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5536(%rax), %r11
+	movq	5552(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26054,13 +26144,13 @@ GL_PREFIX(TrackMatrixNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5536(%rax), %r11
+	movq	5552(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5536(%rax), %r11
+	movq	5552(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26074,7 +26164,7 @@ GL_PREFIX(TrackMatrixNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5536(%rax), %r11
+	movq	5552(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(TrackMatrixNV), .-GL_PREFIX(TrackMatrixNV)
@@ -26085,7 +26175,7 @@ GL_PREFIX(TrackMatrixNV):
 GL_PREFIX(VertexAttrib1dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5544(%rax), %r11
+	movq	5560(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -26095,13 +26185,13 @@ GL_PREFIX(VertexAttrib1dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5544(%rax), %r11
+	movq	5560(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5544(%rax), %r11
+	movq	5560(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -26111,7 +26201,7 @@ GL_PREFIX(VertexAttrib1dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5544(%rax), %r11
+	movq	5560(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1dNV), .-GL_PREFIX(VertexAttrib1dNV)
@@ -26122,7 +26212,7 @@ GL_PREFIX(VertexAttrib1dNV):
 GL_PREFIX(VertexAttrib1dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5552(%rax), %r11
+	movq	5568(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26132,13 +26222,13 @@ GL_PREFIX(VertexAttrib1dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5552(%rax), %r11
+	movq	5568(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5552(%rax), %r11
+	movq	5568(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26148,7 +26238,7 @@ GL_PREFIX(VertexAttrib1dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5552(%rax), %r11
+	movq	5568(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1dvNV), .-GL_PREFIX(VertexAttrib1dvNV)
@@ -26159,7 +26249,7 @@ GL_PREFIX(VertexAttrib1dvNV):
 GL_PREFIX(VertexAttrib1fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5560(%rax), %r11
+	movq	5576(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -26169,13 +26259,13 @@ GL_PREFIX(VertexAttrib1fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5560(%rax), %r11
+	movq	5576(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5560(%rax), %r11
+	movq	5576(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -26185,7 +26275,7 @@ GL_PREFIX(VertexAttrib1fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5560(%rax), %r11
+	movq	5576(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1fNV), .-GL_PREFIX(VertexAttrib1fNV)
@@ -26196,7 +26286,7 @@ GL_PREFIX(VertexAttrib1fNV):
 GL_PREFIX(VertexAttrib1fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5568(%rax), %r11
+	movq	5584(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26206,13 +26296,13 @@ GL_PREFIX(VertexAttrib1fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5568(%rax), %r11
+	movq	5584(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5568(%rax), %r11
+	movq	5584(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26222,7 +26312,7 @@ GL_PREFIX(VertexAttrib1fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5568(%rax), %r11
+	movq	5584(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1fvNV), .-GL_PREFIX(VertexAttrib1fvNV)
@@ -26233,7 +26323,7 @@ GL_PREFIX(VertexAttrib1fvNV):
 GL_PREFIX(VertexAttrib1sNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5576(%rax), %r11
+	movq	5592(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26243,13 +26333,13 @@ GL_PREFIX(VertexAttrib1sNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5576(%rax), %r11
+	movq	5592(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5576(%rax), %r11
+	movq	5592(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26259,7 +26349,7 @@ GL_PREFIX(VertexAttrib1sNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5576(%rax), %r11
+	movq	5592(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1sNV), .-GL_PREFIX(VertexAttrib1sNV)
@@ -26270,7 +26360,7 @@ GL_PREFIX(VertexAttrib1sNV):
 GL_PREFIX(VertexAttrib1svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5584(%rax), %r11
+	movq	5600(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26280,13 +26370,13 @@ GL_PREFIX(VertexAttrib1svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5584(%rax), %r11
+	movq	5600(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5584(%rax), %r11
+	movq	5600(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26296,7 +26386,7 @@ GL_PREFIX(VertexAttrib1svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5584(%rax), %r11
+	movq	5600(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib1svNV), .-GL_PREFIX(VertexAttrib1svNV)
@@ -26307,7 +26397,7 @@ GL_PREFIX(VertexAttrib1svNV):
 GL_PREFIX(VertexAttrib2dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5592(%rax), %r11
+	movq	5608(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -26319,13 +26409,13 @@ GL_PREFIX(VertexAttrib2dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5592(%rax), %r11
+	movq	5608(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5592(%rax), %r11
+	movq	5608(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -26337,7 +26427,7 @@ GL_PREFIX(VertexAttrib2dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5592(%rax), %r11
+	movq	5608(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2dNV), .-GL_PREFIX(VertexAttrib2dNV)
@@ -26348,7 +26438,7 @@ GL_PREFIX(VertexAttrib2dNV):
 GL_PREFIX(VertexAttrib2dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5600(%rax), %r11
+	movq	5616(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26358,13 +26448,13 @@ GL_PREFIX(VertexAttrib2dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5600(%rax), %r11
+	movq	5616(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5600(%rax), %r11
+	movq	5616(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26374,7 +26464,7 @@ GL_PREFIX(VertexAttrib2dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5600(%rax), %r11
+	movq	5616(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2dvNV), .-GL_PREFIX(VertexAttrib2dvNV)
@@ -26385,7 +26475,7 @@ GL_PREFIX(VertexAttrib2dvNV):
 GL_PREFIX(VertexAttrib2fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5608(%rax), %r11
+	movq	5624(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$24, %rsp
@@ -26397,13 +26487,13 @@ GL_PREFIX(VertexAttrib2fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5608(%rax), %r11
+	movq	5624(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5608(%rax), %r11
+	movq	5624(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$24, %rsp
@@ -26415,7 +26505,7 @@ GL_PREFIX(VertexAttrib2fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$24, %rsp
-	movq	5608(%rax), %r11
+	movq	5624(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2fNV), .-GL_PREFIX(VertexAttrib2fNV)
@@ -26426,7 +26516,7 @@ GL_PREFIX(VertexAttrib2fNV):
 GL_PREFIX(VertexAttrib2fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5616(%rax), %r11
+	movq	5632(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26436,13 +26526,13 @@ GL_PREFIX(VertexAttrib2fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5616(%rax), %r11
+	movq	5632(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5616(%rax), %r11
+	movq	5632(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26452,7 +26542,7 @@ GL_PREFIX(VertexAttrib2fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5616(%rax), %r11
+	movq	5632(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2fvNV), .-GL_PREFIX(VertexAttrib2fvNV)
@@ -26463,7 +26553,7 @@ GL_PREFIX(VertexAttrib2fvNV):
 GL_PREFIX(VertexAttrib2sNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5624(%rax), %r11
+	movq	5640(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26473,13 +26563,13 @@ GL_PREFIX(VertexAttrib2sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5624(%rax), %r11
+	movq	5640(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5624(%rax), %r11
+	movq	5640(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26489,7 +26579,7 @@ GL_PREFIX(VertexAttrib2sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5624(%rax), %r11
+	movq	5640(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2sNV), .-GL_PREFIX(VertexAttrib2sNV)
@@ -26500,7 +26590,7 @@ GL_PREFIX(VertexAttrib2sNV):
 GL_PREFIX(VertexAttrib2svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5632(%rax), %r11
+	movq	5648(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26510,13 +26600,13 @@ GL_PREFIX(VertexAttrib2svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5632(%rax), %r11
+	movq	5648(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5632(%rax), %r11
+	movq	5648(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26526,7 +26616,7 @@ GL_PREFIX(VertexAttrib2svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5632(%rax), %r11
+	movq	5648(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib2svNV), .-GL_PREFIX(VertexAttrib2svNV)
@@ -26537,7 +26627,7 @@ GL_PREFIX(VertexAttrib2svNV):
 GL_PREFIX(VertexAttrib3dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5640(%rax), %r11
+	movq	5656(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -26551,13 +26641,13 @@ GL_PREFIX(VertexAttrib3dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5640(%rax), %r11
+	movq	5656(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5640(%rax), %r11
+	movq	5656(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -26571,7 +26661,7 @@ GL_PREFIX(VertexAttrib3dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5640(%rax), %r11
+	movq	5656(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3dNV), .-GL_PREFIX(VertexAttrib3dNV)
@@ -26582,7 +26672,7 @@ GL_PREFIX(VertexAttrib3dNV):
 GL_PREFIX(VertexAttrib3dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5648(%rax), %r11
+	movq	5664(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26592,13 +26682,13 @@ GL_PREFIX(VertexAttrib3dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5648(%rax), %r11
+	movq	5664(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5648(%rax), %r11
+	movq	5664(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26608,7 +26698,7 @@ GL_PREFIX(VertexAttrib3dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5648(%rax), %r11
+	movq	5664(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3dvNV), .-GL_PREFIX(VertexAttrib3dvNV)
@@ -26619,7 +26709,7 @@ GL_PREFIX(VertexAttrib3dvNV):
 GL_PREFIX(VertexAttrib3fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5656(%rax), %r11
+	movq	5672(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -26633,13 +26723,13 @@ GL_PREFIX(VertexAttrib3fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5656(%rax), %r11
+	movq	5672(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5656(%rax), %r11
+	movq	5672(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -26653,7 +26743,7 @@ GL_PREFIX(VertexAttrib3fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5656(%rax), %r11
+	movq	5672(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3fNV), .-GL_PREFIX(VertexAttrib3fNV)
@@ -26664,7 +26754,7 @@ GL_PREFIX(VertexAttrib3fNV):
 GL_PREFIX(VertexAttrib3fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5664(%rax), %r11
+	movq	5680(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26674,13 +26764,13 @@ GL_PREFIX(VertexAttrib3fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5664(%rax), %r11
+	movq	5680(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5664(%rax), %r11
+	movq	5680(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26690,7 +26780,7 @@ GL_PREFIX(VertexAttrib3fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5664(%rax), %r11
+	movq	5680(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3fvNV), .-GL_PREFIX(VertexAttrib3fvNV)
@@ -26701,7 +26791,7 @@ GL_PREFIX(VertexAttrib3fvNV):
 GL_PREFIX(VertexAttrib3sNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5672(%rax), %r11
+	movq	5688(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26715,13 +26805,13 @@ GL_PREFIX(VertexAttrib3sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5672(%rax), %r11
+	movq	5688(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5672(%rax), %r11
+	movq	5688(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26735,7 +26825,7 @@ GL_PREFIX(VertexAttrib3sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5672(%rax), %r11
+	movq	5688(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3sNV), .-GL_PREFIX(VertexAttrib3sNV)
@@ -26746,7 +26836,7 @@ GL_PREFIX(VertexAttrib3sNV):
 GL_PREFIX(VertexAttrib3svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5680(%rax), %r11
+	movq	5696(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26756,13 +26846,13 @@ GL_PREFIX(VertexAttrib3svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5680(%rax), %r11
+	movq	5696(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5680(%rax), %r11
+	movq	5696(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26772,7 +26862,7 @@ GL_PREFIX(VertexAttrib3svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5680(%rax), %r11
+	movq	5696(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib3svNV), .-GL_PREFIX(VertexAttrib3svNV)
@@ -26783,7 +26873,7 @@ GL_PREFIX(VertexAttrib3svNV):
 GL_PREFIX(VertexAttrib4dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5688(%rax), %r11
+	movq	5704(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -26799,13 +26889,13 @@ GL_PREFIX(VertexAttrib4dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5688(%rax), %r11
+	movq	5704(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5688(%rax), %r11
+	movq	5704(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -26821,7 +26911,7 @@ GL_PREFIX(VertexAttrib4dNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5688(%rax), %r11
+	movq	5704(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4dNV), .-GL_PREFIX(VertexAttrib4dNV)
@@ -26832,7 +26922,7 @@ GL_PREFIX(VertexAttrib4dNV):
 GL_PREFIX(VertexAttrib4dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5696(%rax), %r11
+	movq	5712(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26842,13 +26932,13 @@ GL_PREFIX(VertexAttrib4dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5696(%rax), %r11
+	movq	5712(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5696(%rax), %r11
+	movq	5712(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26858,7 +26948,7 @@ GL_PREFIX(VertexAttrib4dvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5696(%rax), %r11
+	movq	5712(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4dvNV), .-GL_PREFIX(VertexAttrib4dvNV)
@@ -26869,7 +26959,7 @@ GL_PREFIX(VertexAttrib4dvNV):
 GL_PREFIX(VertexAttrib4fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5704(%rax), %r11
+	movq	5720(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$40, %rsp
@@ -26885,13 +26975,13 @@ GL_PREFIX(VertexAttrib4fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5704(%rax), %r11
+	movq	5720(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5704(%rax), %r11
+	movq	5720(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$40, %rsp
@@ -26907,7 +26997,7 @@ GL_PREFIX(VertexAttrib4fNV):
 	movq	8(%rsp), %xmm0
 	movq	(%rsp), %rdi
 	addq	$40, %rsp
-	movq	5704(%rax), %r11
+	movq	5720(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4fNV), .-GL_PREFIX(VertexAttrib4fNV)
@@ -26918,7 +27008,7 @@ GL_PREFIX(VertexAttrib4fNV):
 GL_PREFIX(VertexAttrib4fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5712(%rax), %r11
+	movq	5728(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26928,13 +27018,13 @@ GL_PREFIX(VertexAttrib4fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5712(%rax), %r11
+	movq	5728(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5712(%rax), %r11
+	movq	5728(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26944,7 +27034,7 @@ GL_PREFIX(VertexAttrib4fvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5712(%rax), %r11
+	movq	5728(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4fvNV), .-GL_PREFIX(VertexAttrib4fvNV)
@@ -26955,7 +27045,7 @@ GL_PREFIX(VertexAttrib4fvNV):
 GL_PREFIX(VertexAttrib4sNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5720(%rax), %r11
+	movq	5736(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -26969,13 +27059,13 @@ GL_PREFIX(VertexAttrib4sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5720(%rax), %r11
+	movq	5736(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5720(%rax), %r11
+	movq	5736(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -26989,7 +27079,7 @@ GL_PREFIX(VertexAttrib4sNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5720(%rax), %r11
+	movq	5736(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4sNV), .-GL_PREFIX(VertexAttrib4sNV)
@@ -27000,7 +27090,7 @@ GL_PREFIX(VertexAttrib4sNV):
 GL_PREFIX(VertexAttrib4svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5728(%rax), %r11
+	movq	5744(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27010,13 +27100,13 @@ GL_PREFIX(VertexAttrib4svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5728(%rax), %r11
+	movq	5744(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5728(%rax), %r11
+	movq	5744(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27026,7 +27116,7 @@ GL_PREFIX(VertexAttrib4svNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5728(%rax), %r11
+	movq	5744(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4svNV), .-GL_PREFIX(VertexAttrib4svNV)
@@ -27037,7 +27127,7 @@ GL_PREFIX(VertexAttrib4svNV):
 GL_PREFIX(VertexAttrib4ubNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5736(%rax), %r11
+	movq	5752(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27051,13 +27141,13 @@ GL_PREFIX(VertexAttrib4ubNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5736(%rax), %r11
+	movq	5752(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5736(%rax), %r11
+	movq	5752(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27071,7 +27161,7 @@ GL_PREFIX(VertexAttrib4ubNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5736(%rax), %r11
+	movq	5752(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4ubNV), .-GL_PREFIX(VertexAttrib4ubNV)
@@ -27082,7 +27172,7 @@ GL_PREFIX(VertexAttrib4ubNV):
 GL_PREFIX(VertexAttrib4ubvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5744(%rax), %r11
+	movq	5760(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27092,13 +27182,13 @@ GL_PREFIX(VertexAttrib4ubvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5744(%rax), %r11
+	movq	5760(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5744(%rax), %r11
+	movq	5760(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27108,7 +27198,7 @@ GL_PREFIX(VertexAttrib4ubvNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5744(%rax), %r11
+	movq	5760(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttrib4ubvNV), .-GL_PREFIX(VertexAttrib4ubvNV)
@@ -27119,7 +27209,7 @@ GL_PREFIX(VertexAttrib4ubvNV):
 GL_PREFIX(VertexAttribPointerNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5752(%rax), %r11
+	movq	5768(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27133,13 +27223,13 @@ GL_PREFIX(VertexAttribPointerNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5752(%rax), %r11
+	movq	5768(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5752(%rax), %r11
+	movq	5768(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27153,7 +27243,7 @@ GL_PREFIX(VertexAttribPointerNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5752(%rax), %r11
+	movq	5768(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribPointerNV), .-GL_PREFIX(VertexAttribPointerNV)
@@ -27164,7 +27254,7 @@ GL_PREFIX(VertexAttribPointerNV):
 GL_PREFIX(VertexAttribs1dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5760(%rax), %r11
+	movq	5776(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27174,13 +27264,13 @@ GL_PREFIX(VertexAttribs1dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5760(%rax), %r11
+	movq	5776(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5760(%rax), %r11
+	movq	5776(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27190,7 +27280,7 @@ GL_PREFIX(VertexAttribs1dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5760(%rax), %r11
+	movq	5776(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs1dvNV), .-GL_PREFIX(VertexAttribs1dvNV)
@@ -27201,7 +27291,7 @@ GL_PREFIX(VertexAttribs1dvNV):
 GL_PREFIX(VertexAttribs1fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5768(%rax), %r11
+	movq	5784(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27211,13 +27301,13 @@ GL_PREFIX(VertexAttribs1fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5768(%rax), %r11
+	movq	5784(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5768(%rax), %r11
+	movq	5784(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27227,7 +27317,7 @@ GL_PREFIX(VertexAttribs1fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5768(%rax), %r11
+	movq	5784(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs1fvNV), .-GL_PREFIX(VertexAttribs1fvNV)
@@ -27238,7 +27328,7 @@ GL_PREFIX(VertexAttribs1fvNV):
 GL_PREFIX(VertexAttribs1svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5776(%rax), %r11
+	movq	5792(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27248,13 +27338,13 @@ GL_PREFIX(VertexAttribs1svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5776(%rax), %r11
+	movq	5792(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5776(%rax), %r11
+	movq	5792(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27264,7 +27354,7 @@ GL_PREFIX(VertexAttribs1svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5776(%rax), %r11
+	movq	5792(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs1svNV), .-GL_PREFIX(VertexAttribs1svNV)
@@ -27275,7 +27365,7 @@ GL_PREFIX(VertexAttribs1svNV):
 GL_PREFIX(VertexAttribs2dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5784(%rax), %r11
+	movq	5800(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27285,13 +27375,13 @@ GL_PREFIX(VertexAttribs2dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5784(%rax), %r11
+	movq	5800(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5784(%rax), %r11
+	movq	5800(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27301,7 +27391,7 @@ GL_PREFIX(VertexAttribs2dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5784(%rax), %r11
+	movq	5800(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs2dvNV), .-GL_PREFIX(VertexAttribs2dvNV)
@@ -27312,7 +27402,7 @@ GL_PREFIX(VertexAttribs2dvNV):
 GL_PREFIX(VertexAttribs2fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5792(%rax), %r11
+	movq	5808(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27322,13 +27412,13 @@ GL_PREFIX(VertexAttribs2fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5792(%rax), %r11
+	movq	5808(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5792(%rax), %r11
+	movq	5808(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27338,7 +27428,7 @@ GL_PREFIX(VertexAttribs2fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5792(%rax), %r11
+	movq	5808(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs2fvNV), .-GL_PREFIX(VertexAttribs2fvNV)
@@ -27349,7 +27439,7 @@ GL_PREFIX(VertexAttribs2fvNV):
 GL_PREFIX(VertexAttribs2svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5800(%rax), %r11
+	movq	5816(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27359,13 +27449,13 @@ GL_PREFIX(VertexAttribs2svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5800(%rax), %r11
+	movq	5816(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5800(%rax), %r11
+	movq	5816(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27375,7 +27465,7 @@ GL_PREFIX(VertexAttribs2svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5800(%rax), %r11
+	movq	5816(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs2svNV), .-GL_PREFIX(VertexAttribs2svNV)
@@ -27386,7 +27476,7 @@ GL_PREFIX(VertexAttribs2svNV):
 GL_PREFIX(VertexAttribs3dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5808(%rax), %r11
+	movq	5824(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27396,13 +27486,13 @@ GL_PREFIX(VertexAttribs3dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5808(%rax), %r11
+	movq	5824(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5808(%rax), %r11
+	movq	5824(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27412,7 +27502,7 @@ GL_PREFIX(VertexAttribs3dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5808(%rax), %r11
+	movq	5824(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs3dvNV), .-GL_PREFIX(VertexAttribs3dvNV)
@@ -27423,7 +27513,7 @@ GL_PREFIX(VertexAttribs3dvNV):
 GL_PREFIX(VertexAttribs3fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5816(%rax), %r11
+	movq	5832(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27433,13 +27523,13 @@ GL_PREFIX(VertexAttribs3fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5816(%rax), %r11
+	movq	5832(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5816(%rax), %r11
+	movq	5832(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27449,7 +27539,7 @@ GL_PREFIX(VertexAttribs3fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5816(%rax), %r11
+	movq	5832(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs3fvNV), .-GL_PREFIX(VertexAttribs3fvNV)
@@ -27460,7 +27550,7 @@ GL_PREFIX(VertexAttribs3fvNV):
 GL_PREFIX(VertexAttribs3svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5824(%rax), %r11
+	movq	5840(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27470,13 +27560,13 @@ GL_PREFIX(VertexAttribs3svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5824(%rax), %r11
+	movq	5840(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5824(%rax), %r11
+	movq	5840(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27486,7 +27576,7 @@ GL_PREFIX(VertexAttribs3svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5824(%rax), %r11
+	movq	5840(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs3svNV), .-GL_PREFIX(VertexAttribs3svNV)
@@ -27497,7 +27587,7 @@ GL_PREFIX(VertexAttribs3svNV):
 GL_PREFIX(VertexAttribs4dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5832(%rax), %r11
+	movq	5848(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27507,13 +27597,13 @@ GL_PREFIX(VertexAttribs4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5832(%rax), %r11
+	movq	5848(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5832(%rax), %r11
+	movq	5848(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27523,7 +27613,7 @@ GL_PREFIX(VertexAttribs4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5832(%rax), %r11
+	movq	5848(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs4dvNV), .-GL_PREFIX(VertexAttribs4dvNV)
@@ -27534,7 +27624,7 @@ GL_PREFIX(VertexAttribs4dvNV):
 GL_PREFIX(VertexAttribs4fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5840(%rax), %r11
+	movq	5856(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27544,13 +27634,13 @@ GL_PREFIX(VertexAttribs4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5840(%rax), %r11
+	movq	5856(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5840(%rax), %r11
+	movq	5856(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27560,7 +27650,7 @@ GL_PREFIX(VertexAttribs4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5840(%rax), %r11
+	movq	5856(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs4fvNV), .-GL_PREFIX(VertexAttribs4fvNV)
@@ -27571,7 +27661,7 @@ GL_PREFIX(VertexAttribs4fvNV):
 GL_PREFIX(VertexAttribs4svNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5848(%rax), %r11
+	movq	5864(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27581,13 +27671,13 @@ GL_PREFIX(VertexAttribs4svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5848(%rax), %r11
+	movq	5864(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5848(%rax), %r11
+	movq	5864(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27597,7 +27687,7 @@ GL_PREFIX(VertexAttribs4svNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5848(%rax), %r11
+	movq	5864(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs4svNV), .-GL_PREFIX(VertexAttribs4svNV)
@@ -27608,7 +27698,7 @@ GL_PREFIX(VertexAttribs4svNV):
 GL_PREFIX(VertexAttribs4ubvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5856(%rax), %r11
+	movq	5872(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27618,13 +27708,13 @@ GL_PREFIX(VertexAttribs4ubvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5856(%rax), %r11
+	movq	5872(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5856(%rax), %r11
+	movq	5872(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27634,7 +27724,7 @@ GL_PREFIX(VertexAttribs4ubvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5856(%rax), %r11
+	movq	5872(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(VertexAttribs4ubvNV), .-GL_PREFIX(VertexAttribs4ubvNV)
@@ -27645,7 +27735,7 @@ GL_PREFIX(VertexAttribs4ubvNV):
 GL_PREFIX(GetTexBumpParameterfvATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5864(%rax), %r11
+	movq	5880(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27655,13 +27745,13 @@ GL_PREFIX(GetTexBumpParameterfvATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5864(%rax), %r11
+	movq	5880(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5864(%rax), %r11
+	movq	5880(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27671,7 +27761,7 @@ GL_PREFIX(GetTexBumpParameterfvATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5864(%rax), %r11
+	movq	5880(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetTexBumpParameterfvATI), .-GL_PREFIX(GetTexBumpParameterfvATI)
@@ -27682,7 +27772,7 @@ GL_PREFIX(GetTexBumpParameterfvATI):
 GL_PREFIX(GetTexBumpParameterivATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5872(%rax), %r11
+	movq	5888(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27692,13 +27782,13 @@ GL_PREFIX(GetTexBumpParameterivATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5872(%rax), %r11
+	movq	5888(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5872(%rax), %r11
+	movq	5888(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27708,7 +27798,7 @@ GL_PREFIX(GetTexBumpParameterivATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5872(%rax), %r11
+	movq	5888(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetTexBumpParameterivATI), .-GL_PREFIX(GetTexBumpParameterivATI)
@@ -27719,7 +27809,7 @@ GL_PREFIX(GetTexBumpParameterivATI):
 GL_PREFIX(TexBumpParameterfvATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5880(%rax), %r11
+	movq	5896(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27729,13 +27819,13 @@ GL_PREFIX(TexBumpParameterfvATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5880(%rax), %r11
+	movq	5896(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5880(%rax), %r11
+	movq	5896(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27745,7 +27835,7 @@ GL_PREFIX(TexBumpParameterfvATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5880(%rax), %r11
+	movq	5896(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(TexBumpParameterfvATI), .-GL_PREFIX(TexBumpParameterfvATI)
@@ -27756,7 +27846,7 @@ GL_PREFIX(TexBumpParameterfvATI):
 GL_PREFIX(TexBumpParameterivATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5888(%rax), %r11
+	movq	5904(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27766,13 +27856,13 @@ GL_PREFIX(TexBumpParameterivATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5888(%rax), %r11
+	movq	5904(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5888(%rax), %r11
+	movq	5904(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27782,7 +27872,7 @@ GL_PREFIX(TexBumpParameterivATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	5888(%rax), %r11
+	movq	5904(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(TexBumpParameterivATI), .-GL_PREFIX(TexBumpParameterivATI)
@@ -27793,7 +27883,7 @@ GL_PREFIX(TexBumpParameterivATI):
 GL_PREFIX(AlphaFragmentOp1ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5896(%rax), %r11
+	movq	5912(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27811,13 +27901,13 @@ GL_PREFIX(AlphaFragmentOp1ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5896(%rax), %r11
+	movq	5912(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5896(%rax), %r11
+	movq	5912(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27835,7 +27925,7 @@ GL_PREFIX(AlphaFragmentOp1ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5896(%rax), %r11
+	movq	5912(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(AlphaFragmentOp1ATI), .-GL_PREFIX(AlphaFragmentOp1ATI)
@@ -27846,7 +27936,7 @@ GL_PREFIX(AlphaFragmentOp1ATI):
 GL_PREFIX(AlphaFragmentOp2ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5904(%rax), %r11
+	movq	5920(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27864,13 +27954,13 @@ GL_PREFIX(AlphaFragmentOp2ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5904(%rax), %r11
+	movq	5920(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5904(%rax), %r11
+	movq	5920(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27888,7 +27978,7 @@ GL_PREFIX(AlphaFragmentOp2ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5904(%rax), %r11
+	movq	5920(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(AlphaFragmentOp2ATI), .-GL_PREFIX(AlphaFragmentOp2ATI)
@@ -27899,7 +27989,7 @@ GL_PREFIX(AlphaFragmentOp2ATI):
 GL_PREFIX(AlphaFragmentOp3ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5912(%rax), %r11
+	movq	5928(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -27917,13 +28007,13 @@ GL_PREFIX(AlphaFragmentOp3ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5912(%rax), %r11
+	movq	5928(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5912(%rax), %r11
+	movq	5928(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -27941,7 +28031,7 @@ GL_PREFIX(AlphaFragmentOp3ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5912(%rax), %r11
+	movq	5928(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(AlphaFragmentOp3ATI), .-GL_PREFIX(AlphaFragmentOp3ATI)
@@ -27952,25 +28042,25 @@ GL_PREFIX(AlphaFragmentOp3ATI):
 GL_PREFIX(BeginFragmentShaderATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5920(%rax), %r11
+	movq	5936(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	5920(%rax), %r11
+	movq	5936(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5920(%rax), %r11
+	movq	5936(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	5920(%rax), %r11
+	movq	5936(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BeginFragmentShaderATI), .-GL_PREFIX(BeginFragmentShaderATI)
@@ -27981,25 +28071,25 @@ GL_PREFIX(BeginFragmentShaderATI):
 GL_PREFIX(BindFragmentShaderATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5928(%rax), %r11
+	movq	5944(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5928(%rax), %r11
+	movq	5944(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5928(%rax), %r11
+	movq	5944(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5928(%rax), %r11
+	movq	5944(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindFragmentShaderATI), .-GL_PREFIX(BindFragmentShaderATI)
@@ -28010,7 +28100,7 @@ GL_PREFIX(BindFragmentShaderATI):
 GL_PREFIX(ColorFragmentOp1ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5936(%rax), %r11
+	movq	5952(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28028,13 +28118,13 @@ GL_PREFIX(ColorFragmentOp1ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5936(%rax), %r11
+	movq	5952(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5936(%rax), %r11
+	movq	5952(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28052,7 +28142,7 @@ GL_PREFIX(ColorFragmentOp1ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5936(%rax), %r11
+	movq	5952(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ColorFragmentOp1ATI), .-GL_PREFIX(ColorFragmentOp1ATI)
@@ -28063,7 +28153,7 @@ GL_PREFIX(ColorFragmentOp1ATI):
 GL_PREFIX(ColorFragmentOp2ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5944(%rax), %r11
+	movq	5960(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28081,13 +28171,13 @@ GL_PREFIX(ColorFragmentOp2ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5944(%rax), %r11
+	movq	5960(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5944(%rax), %r11
+	movq	5960(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28105,7 +28195,7 @@ GL_PREFIX(ColorFragmentOp2ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5944(%rax), %r11
+	movq	5960(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ColorFragmentOp2ATI), .-GL_PREFIX(ColorFragmentOp2ATI)
@@ -28116,7 +28206,7 @@ GL_PREFIX(ColorFragmentOp2ATI):
 GL_PREFIX(ColorFragmentOp3ATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5952(%rax), %r11
+	movq	5968(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28134,13 +28224,13 @@ GL_PREFIX(ColorFragmentOp3ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5952(%rax), %r11
+	movq	5968(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5952(%rax), %r11
+	movq	5968(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28158,7 +28248,7 @@ GL_PREFIX(ColorFragmentOp3ATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5952(%rax), %r11
+	movq	5968(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ColorFragmentOp3ATI), .-GL_PREFIX(ColorFragmentOp3ATI)
@@ -28169,25 +28259,25 @@ GL_PREFIX(ColorFragmentOp3ATI):
 GL_PREFIX(DeleteFragmentShaderATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5960(%rax), %r11
+	movq	5976(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5960(%rax), %r11
+	movq	5976(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5960(%rax), %r11
+	movq	5976(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5960(%rax), %r11
+	movq	5976(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteFragmentShaderATI), .-GL_PREFIX(DeleteFragmentShaderATI)
@@ -28198,25 +28288,25 @@ GL_PREFIX(DeleteFragmentShaderATI):
 GL_PREFIX(EndFragmentShaderATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5968(%rax), %r11
+	movq	5984(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	5968(%rax), %r11
+	movq	5984(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5968(%rax), %r11
+	movq	5984(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	5968(%rax), %r11
+	movq	5984(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EndFragmentShaderATI), .-GL_PREFIX(EndFragmentShaderATI)
@@ -28227,25 +28317,25 @@ GL_PREFIX(EndFragmentShaderATI):
 GL_PREFIX(GenFragmentShadersATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5976(%rax), %r11
+	movq	5992(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	5976(%rax), %r11
+	movq	5992(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5976(%rax), %r11
+	movq	5992(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	5976(%rax), %r11
+	movq	5992(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenFragmentShadersATI), .-GL_PREFIX(GenFragmentShadersATI)
@@ -28256,7 +28346,7 @@ GL_PREFIX(GenFragmentShadersATI):
 GL_PREFIX(PassTexCoordATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5984(%rax), %r11
+	movq	6000(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28266,13 +28356,13 @@ GL_PREFIX(PassTexCoordATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5984(%rax), %r11
+	movq	6000(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5984(%rax), %r11
+	movq	6000(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28282,7 +28372,7 @@ GL_PREFIX(PassTexCoordATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5984(%rax), %r11
+	movq	6000(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PassTexCoordATI), .-GL_PREFIX(PassTexCoordATI)
@@ -28293,7 +28383,7 @@ GL_PREFIX(PassTexCoordATI):
 GL_PREFIX(SampleMapATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	5992(%rax), %r11
+	movq	6008(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28303,13 +28393,13 @@ GL_PREFIX(SampleMapATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5992(%rax), %r11
+	movq	6008(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	5992(%rax), %r11
+	movq	6008(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28319,7 +28409,7 @@ GL_PREFIX(SampleMapATI):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	5992(%rax), %r11
+	movq	6008(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SampleMapATI), .-GL_PREFIX(SampleMapATI)
@@ -28330,7 +28420,7 @@ GL_PREFIX(SampleMapATI):
 GL_PREFIX(SetFragmentShaderConstantATI):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6000(%rax), %r11
+	movq	6016(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28340,13 +28430,13 @@ GL_PREFIX(SetFragmentShaderConstantATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6000(%rax), %r11
+	movq	6016(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6000(%rax), %r11
+	movq	6016(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28356,7 +28446,7 @@ GL_PREFIX(SetFragmentShaderConstantATI):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6000(%rax), %r11
+	movq	6016(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(SetFragmentShaderConstantATI), .-GL_PREFIX(SetFragmentShaderConstantATI)
@@ -28367,7 +28457,7 @@ GL_PREFIX(SetFragmentShaderConstantATI):
 GL_PREFIX(PointParameteriNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6008(%rax), %r11
+	movq	6024(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28377,13 +28467,13 @@ GL_PREFIX(PointParameteriNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6008(%rax), %r11
+	movq	6024(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6008(%rax), %r11
+	movq	6024(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28393,7 +28483,7 @@ GL_PREFIX(PointParameteriNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6008(%rax), %r11
+	movq	6024(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PointParameteriNV), .-GL_PREFIX(PointParameteriNV)
@@ -28404,7 +28494,7 @@ GL_PREFIX(PointParameteriNV):
 GL_PREFIX(PointParameterivNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6016(%rax), %r11
+	movq	6032(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28414,13 +28504,13 @@ GL_PREFIX(PointParameterivNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6016(%rax), %r11
+	movq	6032(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6016(%rax), %r11
+	movq	6032(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28430,79 +28520,79 @@ GL_PREFIX(PointParameterivNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6016(%rax), %r11
+	movq	6032(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(PointParameterivNV), .-GL_PREFIX(PointParameterivNV)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_753)
-	.type	GL_PREFIX(_dispatch_stub_753), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_753))
-GL_PREFIX(_dispatch_stub_753):
+	.globl	GL_PREFIX(_dispatch_stub_755)
+	.type	GL_PREFIX(_dispatch_stub_755), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_755))
+GL_PREFIX(_dispatch_stub_755):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6024(%rax), %r11
+	movq	6040(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6024(%rax), %r11
+	movq	6040(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6024(%rax), %r11
+	movq	6040(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6024(%rax), %r11
+	movq	6040(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_753), .-GL_PREFIX(_dispatch_stub_753)
+	.size	GL_PREFIX(_dispatch_stub_755), .-GL_PREFIX(_dispatch_stub_755)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_754)
-	.type	GL_PREFIX(_dispatch_stub_754), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_754))
-GL_PREFIX(_dispatch_stub_754):
+	.globl	GL_PREFIX(_dispatch_stub_756)
+	.type	GL_PREFIX(_dispatch_stub_756), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_756))
+GL_PREFIX(_dispatch_stub_756):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6032(%rax), %r11
+	movq	6048(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6032(%rax), %r11
+	movq	6048(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6032(%rax), %r11
+	movq	6048(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6032(%rax), %r11
+	movq	6048(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_754), .-GL_PREFIX(_dispatch_stub_754)
+	.size	GL_PREFIX(_dispatch_stub_756), .-GL_PREFIX(_dispatch_stub_756)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_755)
-	.type	GL_PREFIX(_dispatch_stub_755), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_755))
-GL_PREFIX(_dispatch_stub_755):
+	.globl	GL_PREFIX(_dispatch_stub_757)
+	.type	GL_PREFIX(_dispatch_stub_757), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_757))
+GL_PREFIX(_dispatch_stub_757):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6040(%rax), %r11
+	movq	6056(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28512,13 +28602,13 @@ GL_PREFIX(_dispatch_stub_755):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6040(%rax), %r11
+	movq	6056(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6040(%rax), %r11
+	movq	6056(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28528,19 +28618,19 @@ GL_PREFIX(_dispatch_stub_755):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6040(%rax), %r11
+	movq	6056(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_755), .-GL_PREFIX(_dispatch_stub_755)
+	.size	GL_PREFIX(_dispatch_stub_757), .-GL_PREFIX(_dispatch_stub_757)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_756)
-	.type	GL_PREFIX(_dispatch_stub_756), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_756))
-GL_PREFIX(_dispatch_stub_756):
+	.globl	GL_PREFIX(_dispatch_stub_758)
+	.type	GL_PREFIX(_dispatch_stub_758), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_758))
+GL_PREFIX(_dispatch_stub_758):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6048(%rax), %r11
+	movq	6064(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28550,13 +28640,13 @@ GL_PREFIX(_dispatch_stub_756):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6048(%rax), %r11
+	movq	6064(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6048(%rax), %r11
+	movq	6064(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28566,40 +28656,40 @@ GL_PREFIX(_dispatch_stub_756):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6048(%rax), %r11
+	movq	6064(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_756), .-GL_PREFIX(_dispatch_stub_756)
+	.size	GL_PREFIX(_dispatch_stub_758), .-GL_PREFIX(_dispatch_stub_758)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_757)
-	.type	GL_PREFIX(_dispatch_stub_757), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_757))
-GL_PREFIX(_dispatch_stub_757):
+	.globl	GL_PREFIX(_dispatch_stub_759)
+	.type	GL_PREFIX(_dispatch_stub_759), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_759))
+GL_PREFIX(_dispatch_stub_759):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6056(%rax), %r11
+	movq	6072(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6056(%rax), %r11
+	movq	6072(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6056(%rax), %r11
+	movq	6072(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6056(%rax), %r11
+	movq	6072(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_757), .-GL_PREFIX(_dispatch_stub_757)
+	.size	GL_PREFIX(_dispatch_stub_759), .-GL_PREFIX(_dispatch_stub_759)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(GetProgramNamedParameterdvNV)
@@ -28607,7 +28697,7 @@ GL_PREFIX(_dispatch_stub_757):
 GL_PREFIX(GetProgramNamedParameterdvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6064(%rax), %r11
+	movq	6080(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28621,13 +28711,13 @@ GL_PREFIX(GetProgramNamedParameterdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6064(%rax), %r11
+	movq	6080(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6064(%rax), %r11
+	movq	6080(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28641,7 +28731,7 @@ GL_PREFIX(GetProgramNamedParameterdvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6064(%rax), %r11
+	movq	6080(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramNamedParameterdvNV), .-GL_PREFIX(GetProgramNamedParameterdvNV)
@@ -28652,7 +28742,7 @@ GL_PREFIX(GetProgramNamedParameterdvNV):
 GL_PREFIX(GetProgramNamedParameterfvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6072(%rax), %r11
+	movq	6088(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28666,13 +28756,13 @@ GL_PREFIX(GetProgramNamedParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6072(%rax), %r11
+	movq	6088(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6072(%rax), %r11
+	movq	6088(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28686,7 +28776,7 @@ GL_PREFIX(GetProgramNamedParameterfvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6072(%rax), %r11
+	movq	6088(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetProgramNamedParameterfvNV), .-GL_PREFIX(GetProgramNamedParameterfvNV)
@@ -28697,7 +28787,7 @@ GL_PREFIX(GetProgramNamedParameterfvNV):
 GL_PREFIX(ProgramNamedParameter4dNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6080(%rax), %r11
+	movq	6096(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$56, %rsp
@@ -28717,13 +28807,13 @@ GL_PREFIX(ProgramNamedParameter4dNV):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	6080(%rax), %r11
+	movq	6096(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6080(%rax), %r11
+	movq	6096(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$56, %rsp
@@ -28743,7 +28833,7 @@ GL_PREFIX(ProgramNamedParameter4dNV):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	6080(%rax), %r11
+	movq	6096(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramNamedParameter4dNV), .-GL_PREFIX(ProgramNamedParameter4dNV)
@@ -28754,7 +28844,7 @@ GL_PREFIX(ProgramNamedParameter4dNV):
 GL_PREFIX(ProgramNamedParameter4dvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6088(%rax), %r11
+	movq	6104(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28768,13 +28858,13 @@ GL_PREFIX(ProgramNamedParameter4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6088(%rax), %r11
+	movq	6104(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6088(%rax), %r11
+	movq	6104(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28788,7 +28878,7 @@ GL_PREFIX(ProgramNamedParameter4dvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6088(%rax), %r11
+	movq	6104(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramNamedParameter4dvNV), .-GL_PREFIX(ProgramNamedParameter4dvNV)
@@ -28799,7 +28889,7 @@ GL_PREFIX(ProgramNamedParameter4dvNV):
 GL_PREFIX(ProgramNamedParameter4fNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6096(%rax), %r11
+	movq	6112(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	subq	$56, %rsp
@@ -28819,13 +28909,13 @@ GL_PREFIX(ProgramNamedParameter4fNV):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	6096(%rax), %r11
+	movq	6112(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6096(%rax), %r11
+	movq	6112(%rax), %r11
 	jmp	*%r11
 1:
 	subq	$56, %rsp
@@ -28845,7 +28935,7 @@ GL_PREFIX(ProgramNamedParameter4fNV):
 	movq	8(%rsp), %rsi
 	movq	(%rsp), %rdi
 	addq	$56, %rsp
-	movq	6096(%rax), %r11
+	movq	6112(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramNamedParameter4fNV), .-GL_PREFIX(ProgramNamedParameter4fNV)
@@ -28856,7 +28946,7 @@ GL_PREFIX(ProgramNamedParameter4fNV):
 GL_PREFIX(ProgramNamedParameter4fvNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6104(%rax), %r11
+	movq	6120(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28870,13 +28960,13 @@ GL_PREFIX(ProgramNamedParameter4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6104(%rax), %r11
+	movq	6120(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6104(%rax), %r11
+	movq	6120(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28890,19 +28980,19 @@ GL_PREFIX(ProgramNamedParameter4fvNV):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6104(%rax), %r11
+	movq	6120(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProgramNamedParameter4fvNV), .-GL_PREFIX(ProgramNamedParameter4fvNV)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_764)
-	.type	GL_PREFIX(_dispatch_stub_764), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_764))
-GL_PREFIX(_dispatch_stub_764):
+	.globl	GL_PREFIX(_dispatch_stub_766)
+	.type	GL_PREFIX(_dispatch_stub_766), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_766))
+GL_PREFIX(_dispatch_stub_766):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6112(%rax), %r11
+	movq	6128(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28912,13 +29002,13 @@ GL_PREFIX(_dispatch_stub_764):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6112(%rax), %r11
+	movq	6128(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6112(%rax), %r11
+	movq	6128(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28928,19 +29018,19 @@ GL_PREFIX(_dispatch_stub_764):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6112(%rax), %r11
+	movq	6128(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_764), .-GL_PREFIX(_dispatch_stub_764)
+	.size	GL_PREFIX(_dispatch_stub_766), .-GL_PREFIX(_dispatch_stub_766)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_765)
-	.type	GL_PREFIX(_dispatch_stub_765), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_765))
-GL_PREFIX(_dispatch_stub_765):
+	.globl	GL_PREFIX(_dispatch_stub_767)
+	.type	GL_PREFIX(_dispatch_stub_767), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_767))
+GL_PREFIX(_dispatch_stub_767):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6120(%rax), %r11
+	movq	6136(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28950,13 +29040,13 @@ GL_PREFIX(_dispatch_stub_765):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6120(%rax), %r11
+	movq	6136(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6120(%rax), %r11
+	movq	6136(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -28966,10 +29056,10 @@ GL_PREFIX(_dispatch_stub_765):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6120(%rax), %r11
+	movq	6136(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_765), .-GL_PREFIX(_dispatch_stub_765)
+	.size	GL_PREFIX(_dispatch_stub_767), .-GL_PREFIX(_dispatch_stub_767)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(BindFramebufferEXT)
@@ -28977,7 +29067,7 @@ GL_PREFIX(_dispatch_stub_765):
 GL_PREFIX(BindFramebufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6128(%rax), %r11
+	movq	6144(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -28987,13 +29077,13 @@ GL_PREFIX(BindFramebufferEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6128(%rax), %r11
+	movq	6144(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6128(%rax), %r11
+	movq	6144(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29003,7 +29093,7 @@ GL_PREFIX(BindFramebufferEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6128(%rax), %r11
+	movq	6144(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindFramebufferEXT), .-GL_PREFIX(BindFramebufferEXT)
@@ -29014,7 +29104,7 @@ GL_PREFIX(BindFramebufferEXT):
 GL_PREFIX(BindRenderbufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6136(%rax), %r11
+	movq	6152(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29024,13 +29114,13 @@ GL_PREFIX(BindRenderbufferEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6136(%rax), %r11
+	movq	6152(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6136(%rax), %r11
+	movq	6152(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29040,7 +29130,7 @@ GL_PREFIX(BindRenderbufferEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6136(%rax), %r11
+	movq	6152(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BindRenderbufferEXT), .-GL_PREFIX(BindRenderbufferEXT)
@@ -29051,25 +29141,25 @@ GL_PREFIX(BindRenderbufferEXT):
 GL_PREFIX(CheckFramebufferStatusEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6144(%rax), %r11
+	movq	6160(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6144(%rax), %r11
+	movq	6160(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6144(%rax), %r11
+	movq	6160(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6144(%rax), %r11
+	movq	6160(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(CheckFramebufferStatusEXT), .-GL_PREFIX(CheckFramebufferStatusEXT)
@@ -29080,7 +29170,7 @@ GL_PREFIX(CheckFramebufferStatusEXT):
 GL_PREFIX(DeleteFramebuffersEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6152(%rax), %r11
+	movq	6168(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29090,13 +29180,13 @@ GL_PREFIX(DeleteFramebuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6152(%rax), %r11
+	movq	6168(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6152(%rax), %r11
+	movq	6168(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29106,7 +29196,7 @@ GL_PREFIX(DeleteFramebuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6152(%rax), %r11
+	movq	6168(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteFramebuffersEXT), .-GL_PREFIX(DeleteFramebuffersEXT)
@@ -29117,7 +29207,7 @@ GL_PREFIX(DeleteFramebuffersEXT):
 GL_PREFIX(DeleteRenderbuffersEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6160(%rax), %r11
+	movq	6176(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29127,13 +29217,13 @@ GL_PREFIX(DeleteRenderbuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6160(%rax), %r11
+	movq	6176(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6160(%rax), %r11
+	movq	6176(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29143,7 +29233,7 @@ GL_PREFIX(DeleteRenderbuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6160(%rax), %r11
+	movq	6176(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DeleteRenderbuffersEXT), .-GL_PREFIX(DeleteRenderbuffersEXT)
@@ -29154,7 +29244,7 @@ GL_PREFIX(DeleteRenderbuffersEXT):
 GL_PREFIX(FramebufferRenderbufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6168(%rax), %r11
+	movq	6184(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29168,13 +29258,13 @@ GL_PREFIX(FramebufferRenderbufferEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6168(%rax), %r11
+	movq	6184(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6168(%rax), %r11
+	movq	6184(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29188,7 +29278,7 @@ GL_PREFIX(FramebufferRenderbufferEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6168(%rax), %r11
+	movq	6184(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferRenderbufferEXT), .-GL_PREFIX(FramebufferRenderbufferEXT)
@@ -29199,7 +29289,7 @@ GL_PREFIX(FramebufferRenderbufferEXT):
 GL_PREFIX(FramebufferTexture1DEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6176(%rax), %r11
+	movq	6192(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29213,13 +29303,13 @@ GL_PREFIX(FramebufferTexture1DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6176(%rax), %r11
+	movq	6192(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6176(%rax), %r11
+	movq	6192(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29233,7 +29323,7 @@ GL_PREFIX(FramebufferTexture1DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6176(%rax), %r11
+	movq	6192(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferTexture1DEXT), .-GL_PREFIX(FramebufferTexture1DEXT)
@@ -29244,7 +29334,7 @@ GL_PREFIX(FramebufferTexture1DEXT):
 GL_PREFIX(FramebufferTexture2DEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6184(%rax), %r11
+	movq	6200(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29258,13 +29348,13 @@ GL_PREFIX(FramebufferTexture2DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6184(%rax), %r11
+	movq	6200(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6184(%rax), %r11
+	movq	6200(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29278,7 +29368,7 @@ GL_PREFIX(FramebufferTexture2DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6184(%rax), %r11
+	movq	6200(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferTexture2DEXT), .-GL_PREFIX(FramebufferTexture2DEXT)
@@ -29289,7 +29379,7 @@ GL_PREFIX(FramebufferTexture2DEXT):
 GL_PREFIX(FramebufferTexture3DEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6192(%rax), %r11
+	movq	6208(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29307,13 +29397,13 @@ GL_PREFIX(FramebufferTexture3DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6192(%rax), %r11
+	movq	6208(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6192(%rax), %r11
+	movq	6208(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29331,7 +29421,7 @@ GL_PREFIX(FramebufferTexture3DEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6192(%rax), %r11
+	movq	6208(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferTexture3DEXT), .-GL_PREFIX(FramebufferTexture3DEXT)
@@ -29342,7 +29432,7 @@ GL_PREFIX(FramebufferTexture3DEXT):
 GL_PREFIX(GenFramebuffersEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6200(%rax), %r11
+	movq	6216(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29352,13 +29442,13 @@ GL_PREFIX(GenFramebuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6200(%rax), %r11
+	movq	6216(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6200(%rax), %r11
+	movq	6216(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29368,7 +29458,7 @@ GL_PREFIX(GenFramebuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6200(%rax), %r11
+	movq	6216(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenFramebuffersEXT), .-GL_PREFIX(GenFramebuffersEXT)
@@ -29379,7 +29469,7 @@ GL_PREFIX(GenFramebuffersEXT):
 GL_PREFIX(GenRenderbuffersEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6208(%rax), %r11
+	movq	6224(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29389,13 +29479,13 @@ GL_PREFIX(GenRenderbuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6208(%rax), %r11
+	movq	6224(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6208(%rax), %r11
+	movq	6224(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29405,7 +29495,7 @@ GL_PREFIX(GenRenderbuffersEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6208(%rax), %r11
+	movq	6224(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenRenderbuffersEXT), .-GL_PREFIX(GenRenderbuffersEXT)
@@ -29416,25 +29506,25 @@ GL_PREFIX(GenRenderbuffersEXT):
 GL_PREFIX(GenerateMipmapEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6216(%rax), %r11
+	movq	6232(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6216(%rax), %r11
+	movq	6232(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6216(%rax), %r11
+	movq	6232(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6216(%rax), %r11
+	movq	6232(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GenerateMipmapEXT), .-GL_PREFIX(GenerateMipmapEXT)
@@ -29445,7 +29535,7 @@ GL_PREFIX(GenerateMipmapEXT):
 GL_PREFIX(GetFramebufferAttachmentParameterivEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6224(%rax), %r11
+	movq	6240(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29459,13 +29549,13 @@ GL_PREFIX(GetFramebufferAttachmentParameterivEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6224(%rax), %r11
+	movq	6240(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6224(%rax), %r11
+	movq	6240(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29479,7 +29569,7 @@ GL_PREFIX(GetFramebufferAttachmentParameterivEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6224(%rax), %r11
+	movq	6240(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetFramebufferAttachmentParameterivEXT), .-GL_PREFIX(GetFramebufferAttachmentParameterivEXT)
@@ -29490,7 +29580,7 @@ GL_PREFIX(GetFramebufferAttachmentParameterivEXT):
 GL_PREFIX(GetRenderbufferParameterivEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6232(%rax), %r11
+	movq	6248(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29500,13 +29590,13 @@ GL_PREFIX(GetRenderbufferParameterivEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6232(%rax), %r11
+	movq	6248(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6232(%rax), %r11
+	movq	6248(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29516,7 +29606,7 @@ GL_PREFIX(GetRenderbufferParameterivEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6232(%rax), %r11
+	movq	6248(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetRenderbufferParameterivEXT), .-GL_PREFIX(GetRenderbufferParameterivEXT)
@@ -29527,25 +29617,25 @@ GL_PREFIX(GetRenderbufferParameterivEXT):
 GL_PREFIX(IsFramebufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6240(%rax), %r11
+	movq	6256(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6240(%rax), %r11
+	movq	6256(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6240(%rax), %r11
+	movq	6256(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6240(%rax), %r11
+	movq	6256(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsFramebufferEXT), .-GL_PREFIX(IsFramebufferEXT)
@@ -29556,25 +29646,25 @@ GL_PREFIX(IsFramebufferEXT):
 GL_PREFIX(IsRenderbufferEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6248(%rax), %r11
+	movq	6264(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6248(%rax), %r11
+	movq	6264(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6248(%rax), %r11
+	movq	6264(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6248(%rax), %r11
+	movq	6264(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsRenderbufferEXT), .-GL_PREFIX(IsRenderbufferEXT)
@@ -29585,7 +29675,7 @@ GL_PREFIX(IsRenderbufferEXT):
 GL_PREFIX(RenderbufferStorageEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6256(%rax), %r11
+	movq	6272(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29599,13 +29689,13 @@ GL_PREFIX(RenderbufferStorageEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6256(%rax), %r11
+	movq	6272(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6256(%rax), %r11
+	movq	6272(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29619,19 +29709,19 @@ GL_PREFIX(RenderbufferStorageEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6256(%rax), %r11
+	movq	6272(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(RenderbufferStorageEXT), .-GL_PREFIX(RenderbufferStorageEXT)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_783)
-	.type	GL_PREFIX(_dispatch_stub_783), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_783))
-GL_PREFIX(_dispatch_stub_783):
+	.globl	GL_PREFIX(_dispatch_stub_785)
+	.type	GL_PREFIX(_dispatch_stub_785), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_785))
+GL_PREFIX(_dispatch_stub_785):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6264(%rax), %r11
+	movq	6280(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29649,13 +29739,13 @@ GL_PREFIX(_dispatch_stub_783):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6264(%rax), %r11
+	movq	6280(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6264(%rax), %r11
+	movq	6280(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29673,19 +29763,19 @@ GL_PREFIX(_dispatch_stub_783):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6264(%rax), %r11
+	movq	6280(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_783), .-GL_PREFIX(_dispatch_stub_783)
+	.size	GL_PREFIX(_dispatch_stub_785), .-GL_PREFIX(_dispatch_stub_785)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_784)
-	.type	GL_PREFIX(_dispatch_stub_784), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_784))
-GL_PREFIX(_dispatch_stub_784):
+	.globl	GL_PREFIX(_dispatch_stub_786)
+	.type	GL_PREFIX(_dispatch_stub_786), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_786))
+GL_PREFIX(_dispatch_stub_786):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6272(%rax), %r11
+	movq	6288(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29695,13 +29785,13 @@ GL_PREFIX(_dispatch_stub_784):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6272(%rax), %r11
+	movq	6288(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6272(%rax), %r11
+	movq	6288(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29711,19 +29801,19 @@ GL_PREFIX(_dispatch_stub_784):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6272(%rax), %r11
+	movq	6288(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_784), .-GL_PREFIX(_dispatch_stub_784)
+	.size	GL_PREFIX(_dispatch_stub_786), .-GL_PREFIX(_dispatch_stub_786)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_785)
-	.type	GL_PREFIX(_dispatch_stub_785), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_785))
-GL_PREFIX(_dispatch_stub_785):
+	.globl	GL_PREFIX(_dispatch_stub_787)
+	.type	GL_PREFIX(_dispatch_stub_787), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_787))
+GL_PREFIX(_dispatch_stub_787):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6280(%rax), %r11
+	movq	6296(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29733,13 +29823,13 @@ GL_PREFIX(_dispatch_stub_785):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6280(%rax), %r11
+	movq	6296(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6280(%rax), %r11
+	movq	6296(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29749,10 +29839,10 @@ GL_PREFIX(_dispatch_stub_785):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6280(%rax), %r11
+	movq	6296(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_785), .-GL_PREFIX(_dispatch_stub_785)
+	.size	GL_PREFIX(_dispatch_stub_787), .-GL_PREFIX(_dispatch_stub_787)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(FramebufferTextureLayerEXT)
@@ -29760,7 +29850,7 @@ GL_PREFIX(_dispatch_stub_785):
 GL_PREFIX(FramebufferTextureLayerEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6288(%rax), %r11
+	movq	6304(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29774,13 +29864,13 @@ GL_PREFIX(FramebufferTextureLayerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6288(%rax), %r11
+	movq	6304(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6288(%rax), %r11
+	movq	6304(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29794,7 +29884,7 @@ GL_PREFIX(FramebufferTextureLayerEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6288(%rax), %r11
+	movq	6304(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(FramebufferTextureLayerEXT), .-GL_PREFIX(FramebufferTextureLayerEXT)
@@ -29805,7 +29895,7 @@ GL_PREFIX(FramebufferTextureLayerEXT):
 GL_PREFIX(ColorMaskIndexedEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6296(%rax), %r11
+	movq	6312(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29819,13 +29909,13 @@ GL_PREFIX(ColorMaskIndexedEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6296(%rax), %r11
+	movq	6312(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6296(%rax), %r11
+	movq	6312(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29839,7 +29929,7 @@ GL_PREFIX(ColorMaskIndexedEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6296(%rax), %r11
+	movq	6312(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ColorMaskIndexedEXT), .-GL_PREFIX(ColorMaskIndexedEXT)
@@ -29850,7 +29940,7 @@ GL_PREFIX(ColorMaskIndexedEXT):
 GL_PREFIX(DisableIndexedEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6304(%rax), %r11
+	movq	6320(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29860,13 +29950,13 @@ GL_PREFIX(DisableIndexedEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6304(%rax), %r11
+	movq	6320(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6304(%rax), %r11
+	movq	6320(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29876,7 +29966,7 @@ GL_PREFIX(DisableIndexedEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6304(%rax), %r11
+	movq	6320(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(DisableIndexedEXT), .-GL_PREFIX(DisableIndexedEXT)
@@ -29887,7 +29977,7 @@ GL_PREFIX(DisableIndexedEXT):
 GL_PREFIX(EnableIndexedEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6312(%rax), %r11
+	movq	6328(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29897,13 +29987,13 @@ GL_PREFIX(EnableIndexedEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6312(%rax), %r11
+	movq	6328(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6312(%rax), %r11
+	movq	6328(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29913,7 +30003,7 @@ GL_PREFIX(EnableIndexedEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6312(%rax), %r11
+	movq	6328(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EnableIndexedEXT), .-GL_PREFIX(EnableIndexedEXT)
@@ -29924,7 +30014,7 @@ GL_PREFIX(EnableIndexedEXT):
 GL_PREFIX(GetBooleanIndexedvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6320(%rax), %r11
+	movq	6336(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29934,13 +30024,13 @@ GL_PREFIX(GetBooleanIndexedvEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6320(%rax), %r11
+	movq	6336(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6320(%rax), %r11
+	movq	6336(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29950,7 +30040,7 @@ GL_PREFIX(GetBooleanIndexedvEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6320(%rax), %r11
+	movq	6336(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetBooleanIndexedvEXT), .-GL_PREFIX(GetBooleanIndexedvEXT)
@@ -29961,7 +30051,7 @@ GL_PREFIX(GetBooleanIndexedvEXT):
 GL_PREFIX(GetIntegerIndexedvEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6328(%rax), %r11
+	movq	6344(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -29971,13 +30061,13 @@ GL_PREFIX(GetIntegerIndexedvEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6328(%rax), %r11
+	movq	6344(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6328(%rax), %r11
+	movq	6344(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -29987,7 +30077,7 @@ GL_PREFIX(GetIntegerIndexedvEXT):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6328(%rax), %r11
+	movq	6344(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetIntegerIndexedvEXT), .-GL_PREFIX(GetIntegerIndexedvEXT)
@@ -29998,7 +30088,7 @@ GL_PREFIX(GetIntegerIndexedvEXT):
 GL_PREFIX(IsEnabledIndexedEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6336(%rax), %r11
+	movq	6352(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30008,13 +30098,13 @@ GL_PREFIX(IsEnabledIndexedEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6336(%rax), %r11
+	movq	6352(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6336(%rax), %r11
+	movq	6352(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30024,7 +30114,7 @@ GL_PREFIX(IsEnabledIndexedEXT):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6336(%rax), %r11
+	movq	6352(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(IsEnabledIndexedEXT), .-GL_PREFIX(IsEnabledIndexedEXT)
@@ -30035,7 +30125,7 @@ GL_PREFIX(IsEnabledIndexedEXT):
 GL_PREFIX(BeginConditionalRenderNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6344(%rax), %r11
+	movq	6360(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30045,13 +30135,13 @@ GL_PREFIX(BeginConditionalRenderNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6344(%rax), %r11
+	movq	6360(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6344(%rax), %r11
+	movq	6360(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30061,7 +30151,7 @@ GL_PREFIX(BeginConditionalRenderNV):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6344(%rax), %r11
+	movq	6360(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(BeginConditionalRenderNV), .-GL_PREFIX(BeginConditionalRenderNV)
@@ -30072,66 +30162,349 @@ GL_PREFIX(BeginConditionalRenderNV):
 GL_PREFIX(EndConditionalRenderNV):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6352(%rax), %r11
+	movq	6368(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rbp
 	call	_x86_64_get_dispatch@PLT
 	popq	%rbp
-	movq	6352(%rax), %r11
+	movq	6368(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6352(%rax), %r11
+	movq	6368(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rbp
 	call	_glapi_get_dispatch
 	popq	%rbp
-	movq	6352(%rax), %r11
+	movq	6368(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EndConditionalRenderNV), .-GL_PREFIX(EndConditionalRenderNV)
 
 	.p2align	4,,15
+	.globl	GL_PREFIX(BeginTransformFeedbackEXT)
+	.type	GL_PREFIX(BeginTransformFeedbackEXT), @function
+GL_PREFIX(BeginTransformFeedbackEXT):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	6376(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	call	_x86_64_get_dispatch@PLT
+	popq	%rdi
+	movq	6376(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	6376(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	call	_glapi_get_dispatch
+	popq	%rdi
+	movq	6376(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(BeginTransformFeedbackEXT), .-GL_PREFIX(BeginTransformFeedbackEXT)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(BindBufferBaseEXT)
+	.type	GL_PREFIX(BindBufferBaseEXT), @function
+GL_PREFIX(BindBufferBaseEXT):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	6384(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	call	_x86_64_get_dispatch@PLT
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6384(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	6384(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	call	_glapi_get_dispatch
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6384(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(BindBufferBaseEXT), .-GL_PREFIX(BindBufferBaseEXT)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(BindBufferOffsetEXT)
+	.type	GL_PREFIX(BindBufferOffsetEXT), @function
+GL_PREFIX(BindBufferOffsetEXT):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	6392(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%rbp
+	call	_x86_64_get_dispatch@PLT
+	popq	%rbp
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6392(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	6392(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%rbp
+	call	_glapi_get_dispatch
+	popq	%rbp
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6392(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(BindBufferOffsetEXT), .-GL_PREFIX(BindBufferOffsetEXT)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(BindBufferRangeEXT)
+	.type	GL_PREFIX(BindBufferRangeEXT), @function
+GL_PREFIX(BindBufferRangeEXT):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	6400(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
+	call	_x86_64_get_dispatch@PLT
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6400(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	6400(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
+	call	_glapi_get_dispatch
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6400(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(BindBufferRangeEXT), .-GL_PREFIX(BindBufferRangeEXT)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(EndTransformFeedbackEXT)
+	.type	GL_PREFIX(EndTransformFeedbackEXT), @function
+GL_PREFIX(EndTransformFeedbackEXT):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	6408(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rbp
+	call	_x86_64_get_dispatch@PLT
+	popq	%rbp
+	movq	6408(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	6408(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rbp
+	call	_glapi_get_dispatch
+	popq	%rbp
+	movq	6408(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(EndTransformFeedbackEXT), .-GL_PREFIX(EndTransformFeedbackEXT)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(GetTransformFeedbackVaryingEXT)
+	.type	GL_PREFIX(GetTransformFeedbackVaryingEXT), @function
+GL_PREFIX(GetTransformFeedbackVaryingEXT):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	6416(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
+	pushq	%r9
+	pushq	%rbp
+	call	_x86_64_get_dispatch@PLT
+	popq	%rbp
+	popq	%r9
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6416(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	6416(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%r8
+	pushq	%r9
+	pushq	%rbp
+	call	_glapi_get_dispatch
+	popq	%rbp
+	popq	%r9
+	popq	%r8
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6416(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(GetTransformFeedbackVaryingEXT), .-GL_PREFIX(GetTransformFeedbackVaryingEXT)
+
+	.p2align	4,,15
+	.globl	GL_PREFIX(TransformFeedbackVaryingsEXT)
+	.type	GL_PREFIX(TransformFeedbackVaryingsEXT), @function
+GL_PREFIX(TransformFeedbackVaryingsEXT):
+#if defined(GLX_USE_TLS)
+	call	_x86_64_get_dispatch@PLT
+	movq	6424(%rax), %r11
+	jmp	*%r11
+#elif defined(PTHREADS)
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%rbp
+	call	_x86_64_get_dispatch@PLT
+	popq	%rbp
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6424(%rax), %r11
+	jmp	*%r11
+#else
+	movq	_glapi_Dispatch(%rip), %rax
+	testq	%rax, %rax
+	je	1f
+	movq	6424(%rax), %r11
+	jmp	*%r11
+1:
+	pushq	%rdi
+	pushq	%rsi
+	pushq	%rdx
+	pushq	%rcx
+	pushq	%rbp
+	call	_glapi_get_dispatch
+	popq	%rbp
+	popq	%rcx
+	popq	%rdx
+	popq	%rsi
+	popq	%rdi
+	movq	6424(%rax), %r11
+	jmp	*%r11
+#endif /* defined(GLX_USE_TLS) */
+	.size	GL_PREFIX(TransformFeedbackVaryingsEXT), .-GL_PREFIX(TransformFeedbackVaryingsEXT)
+
+	.p2align	4,,15
 	.globl	GL_PREFIX(ProvokingVertexEXT)
 	.type	GL_PREFIX(ProvokingVertexEXT), @function
 GL_PREFIX(ProvokingVertexEXT):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6360(%rax), %r11
+	movq	6432(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
 	call	_x86_64_get_dispatch@PLT
 	popq	%rdi
-	movq	6360(%rax), %r11
+	movq	6432(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6360(%rax), %r11
+	movq	6432(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
 	call	_glapi_get_dispatch
 	popq	%rdi
-	movq	6360(%rax), %r11
+	movq	6432(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ProvokingVertexEXT), .-GL_PREFIX(ProvokingVertexEXT)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_796)
-	.type	GL_PREFIX(_dispatch_stub_796), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_796))
-GL_PREFIX(_dispatch_stub_796):
+	.globl	GL_PREFIX(_dispatch_stub_805)
+	.type	GL_PREFIX(_dispatch_stub_805), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_805))
+GL_PREFIX(_dispatch_stub_805):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6368(%rax), %r11
+	movq	6440(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30141,13 +30514,13 @@ GL_PREFIX(_dispatch_stub_796):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6368(%rax), %r11
+	movq	6440(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6368(%rax), %r11
+	movq	6440(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30157,19 +30530,19 @@ GL_PREFIX(_dispatch_stub_796):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6368(%rax), %r11
+	movq	6440(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_796), .-GL_PREFIX(_dispatch_stub_796)
+	.size	GL_PREFIX(_dispatch_stub_805), .-GL_PREFIX(_dispatch_stub_805)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_797)
-	.type	GL_PREFIX(_dispatch_stub_797), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_797))
-GL_PREFIX(_dispatch_stub_797):
+	.globl	GL_PREFIX(_dispatch_stub_806)
+	.type	GL_PREFIX(_dispatch_stub_806), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_806))
+GL_PREFIX(_dispatch_stub_806):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6376(%rax), %r11
+	movq	6448(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30179,13 +30552,13 @@ GL_PREFIX(_dispatch_stub_797):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6376(%rax), %r11
+	movq	6448(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6376(%rax), %r11
+	movq	6448(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30195,10 +30568,10 @@ GL_PREFIX(_dispatch_stub_797):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6376(%rax), %r11
+	movq	6448(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_797), .-GL_PREFIX(_dispatch_stub_797)
+	.size	GL_PREFIX(_dispatch_stub_806), .-GL_PREFIX(_dispatch_stub_806)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(GetObjectParameterivAPPLE)
@@ -30206,7 +30579,7 @@ GL_PREFIX(_dispatch_stub_797):
 GL_PREFIX(GetObjectParameterivAPPLE):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6384(%rax), %r11
+	movq	6456(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30220,13 +30593,13 @@ GL_PREFIX(GetObjectParameterivAPPLE):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6384(%rax), %r11
+	movq	6456(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6384(%rax), %r11
+	movq	6456(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30240,7 +30613,7 @@ GL_PREFIX(GetObjectParameterivAPPLE):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6384(%rax), %r11
+	movq	6456(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(GetObjectParameterivAPPLE), .-GL_PREFIX(GetObjectParameterivAPPLE)
@@ -30251,7 +30624,7 @@ GL_PREFIX(GetObjectParameterivAPPLE):
 GL_PREFIX(ObjectPurgeableAPPLE):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6392(%rax), %r11
+	movq	6464(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30261,13 +30634,13 @@ GL_PREFIX(ObjectPurgeableAPPLE):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6392(%rax), %r11
+	movq	6464(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6392(%rax), %r11
+	movq	6464(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30277,7 +30650,7 @@ GL_PREFIX(ObjectPurgeableAPPLE):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6392(%rax), %r11
+	movq	6464(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ObjectPurgeableAPPLE), .-GL_PREFIX(ObjectPurgeableAPPLE)
@@ -30288,7 +30661,7 @@ GL_PREFIX(ObjectPurgeableAPPLE):
 GL_PREFIX(ObjectUnpurgeableAPPLE):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6400(%rax), %r11
+	movq	6472(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30298,13 +30671,13 @@ GL_PREFIX(ObjectUnpurgeableAPPLE):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6400(%rax), %r11
+	movq	6472(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6400(%rax), %r11
+	movq	6472(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30314,19 +30687,19 @@ GL_PREFIX(ObjectUnpurgeableAPPLE):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6400(%rax), %r11
+	movq	6472(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(ObjectUnpurgeableAPPLE), .-GL_PREFIX(ObjectUnpurgeableAPPLE)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_801)
-	.type	GL_PREFIX(_dispatch_stub_801), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_801))
-GL_PREFIX(_dispatch_stub_801):
+	.globl	GL_PREFIX(_dispatch_stub_810)
+	.type	GL_PREFIX(_dispatch_stub_810), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_810))
+GL_PREFIX(_dispatch_stub_810):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6408(%rax), %r11
+	movq	6480(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30340,13 +30713,13 @@ GL_PREFIX(_dispatch_stub_801):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6408(%rax), %r11
+	movq	6480(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6408(%rax), %r11
+	movq	6480(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30360,19 +30733,19 @@ GL_PREFIX(_dispatch_stub_801):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6408(%rax), %r11
+	movq	6480(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_801), .-GL_PREFIX(_dispatch_stub_801)
+	.size	GL_PREFIX(_dispatch_stub_810), .-GL_PREFIX(_dispatch_stub_810)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_802)
-	.type	GL_PREFIX(_dispatch_stub_802), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_802))
-GL_PREFIX(_dispatch_stub_802):
+	.globl	GL_PREFIX(_dispatch_stub_811)
+	.type	GL_PREFIX(_dispatch_stub_811), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_811))
+GL_PREFIX(_dispatch_stub_811):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6416(%rax), %r11
+	movq	6488(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30386,13 +30759,13 @@ GL_PREFIX(_dispatch_stub_802):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6416(%rax), %r11
+	movq	6488(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6416(%rax), %r11
+	movq	6488(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30406,19 +30779,19 @@ GL_PREFIX(_dispatch_stub_802):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6416(%rax), %r11
+	movq	6488(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_802), .-GL_PREFIX(_dispatch_stub_802)
+	.size	GL_PREFIX(_dispatch_stub_811), .-GL_PREFIX(_dispatch_stub_811)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_803)
-	.type	GL_PREFIX(_dispatch_stub_803), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_803))
-GL_PREFIX(_dispatch_stub_803):
+	.globl	GL_PREFIX(_dispatch_stub_812)
+	.type	GL_PREFIX(_dispatch_stub_812), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_812))
+GL_PREFIX(_dispatch_stub_812):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6424(%rax), %r11
+	movq	6496(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30432,13 +30805,13 @@ GL_PREFIX(_dispatch_stub_803):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6424(%rax), %r11
+	movq	6496(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6424(%rax), %r11
+	movq	6496(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30452,19 +30825,19 @@ GL_PREFIX(_dispatch_stub_803):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6424(%rax), %r11
+	movq	6496(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_803), .-GL_PREFIX(_dispatch_stub_803)
+	.size	GL_PREFIX(_dispatch_stub_812), .-GL_PREFIX(_dispatch_stub_812)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_804)
-	.type	GL_PREFIX(_dispatch_stub_804), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_804))
-GL_PREFIX(_dispatch_stub_804):
+	.globl	GL_PREFIX(_dispatch_stub_813)
+	.type	GL_PREFIX(_dispatch_stub_813), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_813))
+GL_PREFIX(_dispatch_stub_813):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6432(%rax), %r11
+	movq	6504(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30474,13 +30847,13 @@ GL_PREFIX(_dispatch_stub_804):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6432(%rax), %r11
+	movq	6504(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6432(%rax), %r11
+	movq	6504(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30490,19 +30863,19 @@ GL_PREFIX(_dispatch_stub_804):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6432(%rax), %r11
+	movq	6504(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_804), .-GL_PREFIX(_dispatch_stub_804)
+	.size	GL_PREFIX(_dispatch_stub_813), .-GL_PREFIX(_dispatch_stub_813)
 
 	.p2align	4,,15
-	.globl	GL_PREFIX(_dispatch_stub_805)
-	.type	GL_PREFIX(_dispatch_stub_805), @function
-	HIDDEN(GL_PREFIX(_dispatch_stub_805))
-GL_PREFIX(_dispatch_stub_805):
+	.globl	GL_PREFIX(_dispatch_stub_814)
+	.type	GL_PREFIX(_dispatch_stub_814), @function
+	HIDDEN(GL_PREFIX(_dispatch_stub_814))
+GL_PREFIX(_dispatch_stub_814):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6440(%rax), %r11
+	movq	6512(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30512,13 +30885,13 @@ GL_PREFIX(_dispatch_stub_805):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6440(%rax), %r11
+	movq	6512(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6440(%rax), %r11
+	movq	6512(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30528,10 +30901,10 @@ GL_PREFIX(_dispatch_stub_805):
 	popq	%rdx
 	popq	%rsi
 	popq	%rdi
-	movq	6440(%rax), %r11
+	movq	6512(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
-	.size	GL_PREFIX(_dispatch_stub_805), .-GL_PREFIX(_dispatch_stub_805)
+	.size	GL_PREFIX(_dispatch_stub_814), .-GL_PREFIX(_dispatch_stub_814)
 
 	.p2align	4,,15
 	.globl	GL_PREFIX(EGLImageTargetRenderbufferStorageOES)
@@ -30539,7 +30912,7 @@ GL_PREFIX(_dispatch_stub_805):
 GL_PREFIX(EGLImageTargetRenderbufferStorageOES):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6448(%rax), %r11
+	movq	6520(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30549,13 +30922,13 @@ GL_PREFIX(EGLImageTargetRenderbufferStorageOES):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6448(%rax), %r11
+	movq	6520(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6448(%rax), %r11
+	movq	6520(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30565,7 +30938,7 @@ GL_PREFIX(EGLImageTargetRenderbufferStorageOES):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6448(%rax), %r11
+	movq	6520(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EGLImageTargetRenderbufferStorageOES), .-GL_PREFIX(EGLImageTargetRenderbufferStorageOES)
@@ -30576,7 +30949,7 @@ GL_PREFIX(EGLImageTargetRenderbufferStorageOES):
 GL_PREFIX(EGLImageTargetTexture2DOES):
 #if defined(GLX_USE_TLS)
 	call	_x86_64_get_dispatch@PLT
-	movq	6456(%rax), %r11
+	movq	6528(%rax), %r11
 	jmp	*%r11
 #elif defined(PTHREADS)
 	pushq	%rdi
@@ -30586,13 +30959,13 @@ GL_PREFIX(EGLImageTargetTexture2DOES):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6456(%rax), %r11
+	movq	6528(%rax), %r11
 	jmp	*%r11
 #else
 	movq	_glapi_Dispatch(%rip), %rax
 	testq	%rax, %rax
 	je	1f
-	movq	6456(%rax), %r11
+	movq	6528(%rax), %r11
 	jmp	*%r11
 1:
 	pushq	%rdi
@@ -30602,7 +30975,7 @@ GL_PREFIX(EGLImageTargetTexture2DOES):
 	popq	%rbp
 	popq	%rsi
 	popq	%rdi
-	movq	6456(%rax), %r11
+	movq	6528(%rax), %r11
 	jmp	*%r11
 #endif /* defined(GLX_USE_TLS) */
 	.size	GL_PREFIX(EGLImageTargetTexture2DOES), .-GL_PREFIX(EGLImageTargetTexture2DOES)
@@ -30680,6 +31053,10 @@ GL_PREFIX(EGLImageTargetTexture2DOES):
 	.globl GL_PREFIX(MultiTexCoord4iv) ; .set GL_PREFIX(MultiTexCoord4iv), GL_PREFIX(MultiTexCoord4ivARB)
 	.globl GL_PREFIX(MultiTexCoord4s) ; .set GL_PREFIX(MultiTexCoord4s), GL_PREFIX(MultiTexCoord4sARB)
 	.globl GL_PREFIX(MultiTexCoord4sv) ; .set GL_PREFIX(MultiTexCoord4sv), GL_PREFIX(MultiTexCoord4svARB)
+	.globl GL_PREFIX(DrawArraysInstancedARB) ; .set GL_PREFIX(DrawArraysInstancedARB), GL_PREFIX(DrawArraysInstanced)
+	.globl GL_PREFIX(DrawArraysInstancedEXT) ; .set GL_PREFIX(DrawArraysInstancedEXT), GL_PREFIX(DrawArraysInstanced)
+	.globl GL_PREFIX(DrawElementsInstancedARB) ; .set GL_PREFIX(DrawElementsInstancedARB), GL_PREFIX(DrawElementsInstanced)
+	.globl GL_PREFIX(DrawElementsInstancedEXT) ; .set GL_PREFIX(DrawElementsInstancedEXT), GL_PREFIX(DrawElementsInstanced)
 	.globl GL_PREFIX(LoadTransposeMatrixd) ; .set GL_PREFIX(LoadTransposeMatrixd), GL_PREFIX(LoadTransposeMatrixdARB)
 	.globl GL_PREFIX(LoadTransposeMatrixf) ; .set GL_PREFIX(LoadTransposeMatrixf), GL_PREFIX(LoadTransposeMatrixfARB)
 	.globl GL_PREFIX(MultTransposeMatrixd) ; .set GL_PREFIX(MultTransposeMatrixd), GL_PREFIX(MultTransposeMatrixdARB)
@@ -30861,9 +31238,9 @@ GL_PREFIX(EGLImageTargetTexture2DOES):
 	.globl GL_PREFIX(IsProgramARB) ; .set GL_PREFIX(IsProgramARB), GL_PREFIX(IsProgramNV)
 	.globl GL_PREFIX(PointParameteri) ; .set GL_PREFIX(PointParameteri), GL_PREFIX(PointParameteriNV)
 	.globl GL_PREFIX(PointParameteriv) ; .set GL_PREFIX(PointParameteriv), GL_PREFIX(PointParameterivNV)
-	.globl GL_PREFIX(DeleteVertexArrays) ; .set GL_PREFIX(DeleteVertexArrays), GL_PREFIX(_dispatch_stub_755)
-	.globl GL_PREFIX(IsVertexArray) ; .set GL_PREFIX(IsVertexArray), GL_PREFIX(_dispatch_stub_757)
-	.globl GL_PREFIX(BlendEquationSeparate) ; .set GL_PREFIX(BlendEquationSeparate), GL_PREFIX(_dispatch_stub_765)
+	.globl GL_PREFIX(DeleteVertexArrays) ; .set GL_PREFIX(DeleteVertexArrays), GL_PREFIX(_dispatch_stub_757)
+	.globl GL_PREFIX(IsVertexArray) ; .set GL_PREFIX(IsVertexArray), GL_PREFIX(_dispatch_stub_759)
+	.globl GL_PREFIX(BlendEquationSeparate) ; .set GL_PREFIX(BlendEquationSeparate), GL_PREFIX(_dispatch_stub_767)
 	.globl GL_PREFIX(BindFramebuffer) ; .set GL_PREFIX(BindFramebuffer), GL_PREFIX(BindFramebufferEXT)
 	.globl GL_PREFIX(BindRenderbuffer) ; .set GL_PREFIX(BindRenderbuffer), GL_PREFIX(BindRenderbufferEXT)
 	.globl GL_PREFIX(CheckFramebufferStatus) ; .set GL_PREFIX(CheckFramebufferStatus), GL_PREFIX(CheckFramebufferStatusEXT)
@@ -30881,8 +31258,14 @@ GL_PREFIX(EGLImageTargetTexture2DOES):
 	.globl GL_PREFIX(IsFramebuffer) ; .set GL_PREFIX(IsFramebuffer), GL_PREFIX(IsFramebufferEXT)
 	.globl GL_PREFIX(IsRenderbuffer) ; .set GL_PREFIX(IsRenderbuffer), GL_PREFIX(IsRenderbufferEXT)
 	.globl GL_PREFIX(RenderbufferStorage) ; .set GL_PREFIX(RenderbufferStorage), GL_PREFIX(RenderbufferStorageEXT)
-	.globl GL_PREFIX(BlitFramebuffer) ; .set GL_PREFIX(BlitFramebuffer), GL_PREFIX(_dispatch_stub_783)
+	.globl GL_PREFIX(BlitFramebuffer) ; .set GL_PREFIX(BlitFramebuffer), GL_PREFIX(_dispatch_stub_785)
 	.globl GL_PREFIX(FramebufferTextureLayer) ; .set GL_PREFIX(FramebufferTextureLayer), GL_PREFIX(FramebufferTextureLayerEXT)
+	.globl GL_PREFIX(BeginTransformFeedback) ; .set GL_PREFIX(BeginTransformFeedback), GL_PREFIX(BeginTransformFeedbackEXT)
+	.globl GL_PREFIX(BindBufferBase) ; .set GL_PREFIX(BindBufferBase), GL_PREFIX(BindBufferBaseEXT)
+	.globl GL_PREFIX(BindBufferRange) ; .set GL_PREFIX(BindBufferRange), GL_PREFIX(BindBufferRangeEXT)
+	.globl GL_PREFIX(EndTransformFeedback) ; .set GL_PREFIX(EndTransformFeedback), GL_PREFIX(EndTransformFeedbackEXT)
+	.globl GL_PREFIX(GetTransformFeedbackVarying) ; .set GL_PREFIX(GetTransformFeedbackVarying), GL_PREFIX(GetTransformFeedbackVaryingEXT)
+	.globl GL_PREFIX(TransformFeedbackVaryings) ; .set GL_PREFIX(TransformFeedbackVaryings), GL_PREFIX(TransformFeedbackVaryingsEXT)
 	.globl GL_PREFIX(ProvokingVertex) ; .set GL_PREFIX(ProvokingVertex), GL_PREFIX(ProvokingVertexEXT)
 
 #if defined(GLX_USE_TLS) && defined(__linux__)
diff --git a/src/mesa/x86/glapi_x86.S b/src/mesa/x86/glapi_x86.S
index b1730d25a0d..317f595454a 100644
--- a/src/mesa/x86/glapi_x86.S
+++ b/src/mesa/x86/glapi_x86.S
@@ -581,6 +581,8 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(UniformMatrix3x4fv, _gloffset_UniformMatrix3x4fv, UniformMatrix3x4fv@16)
 	GL_STUB(UniformMatrix4x2fv, _gloffset_UniformMatrix4x2fv, UniformMatrix4x2fv@16)
 	GL_STUB(UniformMatrix4x3fv, _gloffset_UniformMatrix4x3fv, UniformMatrix4x3fv@16)
+	GL_STUB(DrawArraysInstanced, _gloffset_DrawArraysInstanced, DrawArraysInstanced@16)
+	GL_STUB(DrawElementsInstanced, _gloffset_DrawElementsInstanced, DrawElementsInstanced@20)
 	GL_STUB(LoadTransposeMatrixdARB, _gloffset_LoadTransposeMatrixdARB, LoadTransposeMatrixdARB@4)
 	GL_STUB(LoadTransposeMatrixfARB, _gloffset_LoadTransposeMatrixfARB, LoadTransposeMatrixfARB@4)
 	GL_STUB(MultTransposeMatrixdARB, _gloffset_MultTransposeMatrixdARB, MultTransposeMatrixdARB@4)
@@ -729,22 +731,22 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(DrawRangeElementsBaseVertex, _gloffset_DrawRangeElementsBaseVertex, DrawRangeElementsBaseVertex@28)
 	GL_STUB(MultiDrawElementsBaseVertex, _gloffset_MultiDrawElementsBaseVertex, MultiDrawElementsBaseVertex@24)
 	GL_STUB(PolygonOffsetEXT, _gloffset_PolygonOffsetEXT, PolygonOffsetEXT@8)
-	GL_STUB(_dispatch_stub_578, _gloffset_GetPixelTexGenParameterfvSGIS, _dispatch_stub_578@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_578, _dispatch_stub_578@8))
-	GL_STUB(_dispatch_stub_579, _gloffset_GetPixelTexGenParameterivSGIS, _dispatch_stub_579@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_579, _dispatch_stub_579@8))
-	GL_STUB(_dispatch_stub_580, _gloffset_PixelTexGenParameterfSGIS, _dispatch_stub_580@8)
+	GL_STUB(_dispatch_stub_580, _gloffset_GetPixelTexGenParameterfvSGIS, _dispatch_stub_580@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_580, _dispatch_stub_580@8))
-	GL_STUB(_dispatch_stub_581, _gloffset_PixelTexGenParameterfvSGIS, _dispatch_stub_581@8)
+	GL_STUB(_dispatch_stub_581, _gloffset_GetPixelTexGenParameterivSGIS, _dispatch_stub_581@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_581, _dispatch_stub_581@8))
-	GL_STUB(_dispatch_stub_582, _gloffset_PixelTexGenParameteriSGIS, _dispatch_stub_582@8)
+	GL_STUB(_dispatch_stub_582, _gloffset_PixelTexGenParameterfSGIS, _dispatch_stub_582@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_582, _dispatch_stub_582@8))
-	GL_STUB(_dispatch_stub_583, _gloffset_PixelTexGenParameterivSGIS, _dispatch_stub_583@8)
+	GL_STUB(_dispatch_stub_583, _gloffset_PixelTexGenParameterfvSGIS, _dispatch_stub_583@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_583, _dispatch_stub_583@8))
-	GL_STUB(_dispatch_stub_584, _gloffset_SampleMaskSGIS, _dispatch_stub_584@8)
+	GL_STUB(_dispatch_stub_584, _gloffset_PixelTexGenParameteriSGIS, _dispatch_stub_584@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_584, _dispatch_stub_584@8))
-	GL_STUB(_dispatch_stub_585, _gloffset_SamplePatternSGIS, _dispatch_stub_585@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_585, _dispatch_stub_585@4))
+	GL_STUB(_dispatch_stub_585, _gloffset_PixelTexGenParameterivSGIS, _dispatch_stub_585@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_585, _dispatch_stub_585@8))
+	GL_STUB(_dispatch_stub_586, _gloffset_SampleMaskSGIS, _dispatch_stub_586@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_586, _dispatch_stub_586@8))
+	GL_STUB(_dispatch_stub_587, _gloffset_SamplePatternSGIS, _dispatch_stub_587@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_587, _dispatch_stub_587@4))
 	GL_STUB(ColorPointerEXT, _gloffset_ColorPointerEXT, ColorPointerEXT@20)
 	GL_STUB(EdgeFlagPointerEXT, _gloffset_EdgeFlagPointerEXT, EdgeFlagPointerEXT@12)
 	GL_STUB(IndexPointerEXT, _gloffset_IndexPointerEXT, IndexPointerEXT@16)
@@ -755,10 +757,10 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(PointParameterfvEXT, _gloffset_PointParameterfvEXT, PointParameterfvEXT@8)
 	GL_STUB(LockArraysEXT, _gloffset_LockArraysEXT, LockArraysEXT@8)
 	GL_STUB(UnlockArraysEXT, _gloffset_UnlockArraysEXT, UnlockArraysEXT@0)
-	GL_STUB(_dispatch_stub_596, _gloffset_CullParameterdvEXT, _dispatch_stub_596@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_596, _dispatch_stub_596@8))
-	GL_STUB(_dispatch_stub_597, _gloffset_CullParameterfvEXT, _dispatch_stub_597@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_597, _dispatch_stub_597@8))
+	GL_STUB(_dispatch_stub_598, _gloffset_CullParameterdvEXT, _dispatch_stub_598@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_598, _dispatch_stub_598@8))
+	GL_STUB(_dispatch_stub_599, _gloffset_CullParameterfvEXT, _dispatch_stub_599@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_599, _dispatch_stub_599@8))
 	GL_STUB(SecondaryColor3bEXT, _gloffset_SecondaryColor3bEXT, SecondaryColor3bEXT@12)
 	GL_STUB(SecondaryColor3bvEXT, _gloffset_SecondaryColor3bvEXT, SecondaryColor3bvEXT@4)
 	GL_STUB(SecondaryColor3dEXT, _gloffset_SecondaryColor3dEXT, SecondaryColor3dEXT@24)
@@ -783,8 +785,8 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(FogCoorddvEXT, _gloffset_FogCoorddvEXT, FogCoorddvEXT@4)
 	GL_STUB(FogCoordfEXT, _gloffset_FogCoordfEXT, FogCoordfEXT@4)
 	GL_STUB(FogCoordfvEXT, _gloffset_FogCoordfvEXT, FogCoordfvEXT@4)
-	GL_STUB(_dispatch_stub_622, _gloffset_PixelTexGenSGIX, _dispatch_stub_622@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_622, _dispatch_stub_622@4))
+	GL_STUB(_dispatch_stub_624, _gloffset_PixelTexGenSGIX, _dispatch_stub_624@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_624, _dispatch_stub_624@4))
 	GL_STUB(BlendFuncSeparateEXT, _gloffset_BlendFuncSeparateEXT, BlendFuncSeparateEXT@16)
 	GL_STUB(FlushVertexArrayRangeNV, _gloffset_FlushVertexArrayRangeNV, FlushVertexArrayRangeNV@0)
 	GL_STUB(VertexArrayRangeNV, _gloffset_VertexArrayRangeNV, VertexArrayRangeNV@8)
@@ -826,24 +828,24 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(WindowPos4ivMESA, _gloffset_WindowPos4ivMESA, WindowPos4ivMESA@4)
 	GL_STUB(WindowPos4sMESA, _gloffset_WindowPos4sMESA, WindowPos4sMESA@16)
 	GL_STUB(WindowPos4svMESA, _gloffset_WindowPos4svMESA, WindowPos4svMESA@4)
-	GL_STUB(_dispatch_stub_664, _gloffset_MultiModeDrawArraysIBM, _dispatch_stub_664@20)
-	HIDDEN(GL_PREFIX(_dispatch_stub_664, _dispatch_stub_664@20))
-	GL_STUB(_dispatch_stub_665, _gloffset_MultiModeDrawElementsIBM, _dispatch_stub_665@24)
-	HIDDEN(GL_PREFIX(_dispatch_stub_665, _dispatch_stub_665@24))
-	GL_STUB(_dispatch_stub_666, _gloffset_DeleteFencesNV, _dispatch_stub_666@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_666, _dispatch_stub_666@8))
-	GL_STUB(_dispatch_stub_667, _gloffset_FinishFenceNV, _dispatch_stub_667@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_667, _dispatch_stub_667@4))
-	GL_STUB(_dispatch_stub_668, _gloffset_GenFencesNV, _dispatch_stub_668@8)
+	GL_STUB(_dispatch_stub_666, _gloffset_MultiModeDrawArraysIBM, _dispatch_stub_666@20)
+	HIDDEN(GL_PREFIX(_dispatch_stub_666, _dispatch_stub_666@20))
+	GL_STUB(_dispatch_stub_667, _gloffset_MultiModeDrawElementsIBM, _dispatch_stub_667@24)
+	HIDDEN(GL_PREFIX(_dispatch_stub_667, _dispatch_stub_667@24))
+	GL_STUB(_dispatch_stub_668, _gloffset_DeleteFencesNV, _dispatch_stub_668@8)
 	HIDDEN(GL_PREFIX(_dispatch_stub_668, _dispatch_stub_668@8))
-	GL_STUB(_dispatch_stub_669, _gloffset_GetFenceivNV, _dispatch_stub_669@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_669, _dispatch_stub_669@12))
-	GL_STUB(_dispatch_stub_670, _gloffset_IsFenceNV, _dispatch_stub_670@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_670, _dispatch_stub_670@4))
-	GL_STUB(_dispatch_stub_671, _gloffset_SetFenceNV, _dispatch_stub_671@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_671, _dispatch_stub_671@8))
-	GL_STUB(_dispatch_stub_672, _gloffset_TestFenceNV, _dispatch_stub_672@4)
+	GL_STUB(_dispatch_stub_669, _gloffset_FinishFenceNV, _dispatch_stub_669@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_669, _dispatch_stub_669@4))
+	GL_STUB(_dispatch_stub_670, _gloffset_GenFencesNV, _dispatch_stub_670@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_670, _dispatch_stub_670@8))
+	GL_STUB(_dispatch_stub_671, _gloffset_GetFenceivNV, _dispatch_stub_671@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_671, _dispatch_stub_671@12))
+	GL_STUB(_dispatch_stub_672, _gloffset_IsFenceNV, _dispatch_stub_672@4)
 	HIDDEN(GL_PREFIX(_dispatch_stub_672, _dispatch_stub_672@4))
+	GL_STUB(_dispatch_stub_673, _gloffset_SetFenceNV, _dispatch_stub_673@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_673, _dispatch_stub_673@8))
+	GL_STUB(_dispatch_stub_674, _gloffset_TestFenceNV, _dispatch_stub_674@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_674, _dispatch_stub_674@4))
 	GL_STUB(AreProgramsResidentNV, _gloffset_AreProgramsResidentNV, AreProgramsResidentNV@12)
 	GL_STUB(BindProgramNV, _gloffset_BindProgramNV, BindProgramNV@8)
 	GL_STUB(DeleteProgramsNV, _gloffset_DeleteProgramsNV, DeleteProgramsNV@8)
@@ -924,26 +926,26 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(SetFragmentShaderConstantATI, _gloffset_SetFragmentShaderConstantATI, SetFragmentShaderConstantATI@8)
 	GL_STUB(PointParameteriNV, _gloffset_PointParameteriNV, PointParameteriNV@8)
 	GL_STUB(PointParameterivNV, _gloffset_PointParameterivNV, PointParameterivNV@8)
-	GL_STUB(_dispatch_stub_753, _gloffset_ActiveStencilFaceEXT, _dispatch_stub_753@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_753, _dispatch_stub_753@4))
-	GL_STUB(_dispatch_stub_754, _gloffset_BindVertexArrayAPPLE, _dispatch_stub_754@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_754, _dispatch_stub_754@4))
-	GL_STUB(_dispatch_stub_755, _gloffset_DeleteVertexArraysAPPLE, _dispatch_stub_755@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_755, _dispatch_stub_755@8))
-	GL_STUB(_dispatch_stub_756, _gloffset_GenVertexArraysAPPLE, _dispatch_stub_756@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_756, _dispatch_stub_756@8))
-	GL_STUB(_dispatch_stub_757, _gloffset_IsVertexArrayAPPLE, _dispatch_stub_757@4)
-	HIDDEN(GL_PREFIX(_dispatch_stub_757, _dispatch_stub_757@4))
+	GL_STUB(_dispatch_stub_755, _gloffset_ActiveStencilFaceEXT, _dispatch_stub_755@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_755, _dispatch_stub_755@4))
+	GL_STUB(_dispatch_stub_756, _gloffset_BindVertexArrayAPPLE, _dispatch_stub_756@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_756, _dispatch_stub_756@4))
+	GL_STUB(_dispatch_stub_757, _gloffset_DeleteVertexArraysAPPLE, _dispatch_stub_757@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_757, _dispatch_stub_757@8))
+	GL_STUB(_dispatch_stub_758, _gloffset_GenVertexArraysAPPLE, _dispatch_stub_758@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_758, _dispatch_stub_758@8))
+	GL_STUB(_dispatch_stub_759, _gloffset_IsVertexArrayAPPLE, _dispatch_stub_759@4)
+	HIDDEN(GL_PREFIX(_dispatch_stub_759, _dispatch_stub_759@4))
 	GL_STUB(GetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV, GetProgramNamedParameterdvNV@16)
 	GL_STUB(GetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV, GetProgramNamedParameterfvNV@16)
 	GL_STUB(ProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV, ProgramNamedParameter4dNV@44)
 	GL_STUB(ProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV, ProgramNamedParameter4dvNV@16)
 	GL_STUB(ProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV, ProgramNamedParameter4fNV@28)
 	GL_STUB(ProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV, ProgramNamedParameter4fvNV@16)
-	GL_STUB(_dispatch_stub_764, _gloffset_DepthBoundsEXT, _dispatch_stub_764@16)
-	HIDDEN(GL_PREFIX(_dispatch_stub_764, _dispatch_stub_764@16))
-	GL_STUB(_dispatch_stub_765, _gloffset_BlendEquationSeparateEXT, _dispatch_stub_765@8)
-	HIDDEN(GL_PREFIX(_dispatch_stub_765, _dispatch_stub_765@8))
+	GL_STUB(_dispatch_stub_766, _gloffset_DepthBoundsEXT, _dispatch_stub_766@16)
+	HIDDEN(GL_PREFIX(_dispatch_stub_766, _dispatch_stub_766@16))
+	GL_STUB(_dispatch_stub_767, _gloffset_BlendEquationSeparateEXT, _dispatch_stub_767@8)
+	HIDDEN(GL_PREFIX(_dispatch_stub_767, _dispatch_stub_767@8))
 	GL_STUB(BindFramebufferEXT, _gloffset_BindFramebufferEXT, BindFramebufferEXT@8)
 	GL_STUB(BindRenderbufferEXT, _gloffset_BindRenderbufferEXT, BindRenderbufferEXT@8)
 	GL_STUB(CheckFramebufferStatusEXT, _gloffset_CheckFramebufferStatusEXT, CheckFramebufferStatusEXT@4)
@@ -961,12 +963,12 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(IsFramebufferEXT, _gloffset_IsFramebufferEXT, IsFramebufferEXT@4)
 	GL_STUB(IsRenderbufferEXT, _gloffset_IsRenderbufferEXT, IsRenderbufferEXT@4)
 	GL_STUB(RenderbufferStorageEXT, _gloffset_RenderbufferStorageEXT, RenderbufferStorageEXT@16)
-	GL_STUB(_dispatch_stub_783, _gloffset_BlitFramebufferEXT, _dispatch_stub_783@40)
-	HIDDEN(GL_PREFIX(_dispatch_stub_783, _dispatch_stub_783@40))
-	GL_STUB(_dispatch_stub_784, _gloffset_BufferParameteriAPPLE, _dispatch_stub_784@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_784, _dispatch_stub_784@12))
-	GL_STUB(_dispatch_stub_785, _gloffset_FlushMappedBufferRangeAPPLE, _dispatch_stub_785@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_785, _dispatch_stub_785@12))
+	GL_STUB(_dispatch_stub_785, _gloffset_BlitFramebufferEXT, _dispatch_stub_785@40)
+	HIDDEN(GL_PREFIX(_dispatch_stub_785, _dispatch_stub_785@40))
+	GL_STUB(_dispatch_stub_786, _gloffset_BufferParameteriAPPLE, _dispatch_stub_786@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_786, _dispatch_stub_786@12))
+	GL_STUB(_dispatch_stub_787, _gloffset_FlushMappedBufferRangeAPPLE, _dispatch_stub_787@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_787, _dispatch_stub_787@12))
 	GL_STUB(FramebufferTextureLayerEXT, _gloffset_FramebufferTextureLayerEXT, FramebufferTextureLayerEXT@20)
 	GL_STUB(ColorMaskIndexedEXT, _gloffset_ColorMaskIndexedEXT, ColorMaskIndexedEXT@20)
 	GL_STUB(DisableIndexedEXT, _gloffset_DisableIndexedEXT, DisableIndexedEXT@8)
@@ -976,24 +978,31 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(IsEnabledIndexedEXT, _gloffset_IsEnabledIndexedEXT, IsEnabledIndexedEXT@8)
 	GL_STUB(BeginConditionalRenderNV, _gloffset_BeginConditionalRenderNV, BeginConditionalRenderNV@8)
 	GL_STUB(EndConditionalRenderNV, _gloffset_EndConditionalRenderNV, EndConditionalRenderNV@0)
+	GL_STUB(BeginTransformFeedbackEXT, _gloffset_BeginTransformFeedbackEXT, BeginTransformFeedbackEXT@4)
+	GL_STUB(BindBufferBaseEXT, _gloffset_BindBufferBaseEXT, BindBufferBaseEXT@12)
+	GL_STUB(BindBufferOffsetEXT, _gloffset_BindBufferOffsetEXT, BindBufferOffsetEXT@16)
+	GL_STUB(BindBufferRangeEXT, _gloffset_BindBufferRangeEXT, BindBufferRangeEXT@20)
+	GL_STUB(EndTransformFeedbackEXT, _gloffset_EndTransformFeedbackEXT, EndTransformFeedbackEXT@0)
+	GL_STUB(GetTransformFeedbackVaryingEXT, _gloffset_GetTransformFeedbackVaryingEXT, GetTransformFeedbackVaryingEXT@28)
+	GL_STUB(TransformFeedbackVaryingsEXT, _gloffset_TransformFeedbackVaryingsEXT, TransformFeedbackVaryingsEXT@16)
 	GL_STUB(ProvokingVertexEXT, _gloffset_ProvokingVertexEXT, ProvokingVertexEXT@4)
-	GL_STUB(_dispatch_stub_796, _gloffset_GetTexParameterPointervAPPLE, _dispatch_stub_796@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_796, _dispatch_stub_796@12))
-	GL_STUB(_dispatch_stub_797, _gloffset_TextureRangeAPPLE, _dispatch_stub_797@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_797, _dispatch_stub_797@12))
+	GL_STUB(_dispatch_stub_805, _gloffset_GetTexParameterPointervAPPLE, _dispatch_stub_805@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_805, _dispatch_stub_805@12))
+	GL_STUB(_dispatch_stub_806, _gloffset_TextureRangeAPPLE, _dispatch_stub_806@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_806, _dispatch_stub_806@12))
 	GL_STUB(GetObjectParameterivAPPLE, _gloffset_GetObjectParameterivAPPLE, GetObjectParameterivAPPLE@16)
 	GL_STUB(ObjectPurgeableAPPLE, _gloffset_ObjectPurgeableAPPLE, ObjectPurgeableAPPLE@12)
 	GL_STUB(ObjectUnpurgeableAPPLE, _gloffset_ObjectUnpurgeableAPPLE, ObjectUnpurgeableAPPLE@12)
-	GL_STUB(_dispatch_stub_801, _gloffset_StencilFuncSeparateATI, _dispatch_stub_801@16)
-	HIDDEN(GL_PREFIX(_dispatch_stub_801, _dispatch_stub_801@16))
-	GL_STUB(_dispatch_stub_802, _gloffset_ProgramEnvParameters4fvEXT, _dispatch_stub_802@16)
-	HIDDEN(GL_PREFIX(_dispatch_stub_802, _dispatch_stub_802@16))
-	GL_STUB(_dispatch_stub_803, _gloffset_ProgramLocalParameters4fvEXT, _dispatch_stub_803@16)
-	HIDDEN(GL_PREFIX(_dispatch_stub_803, _dispatch_stub_803@16))
-	GL_STUB(_dispatch_stub_804, _gloffset_GetQueryObjecti64vEXT, _dispatch_stub_804@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_804, _dispatch_stub_804@12))
-	GL_STUB(_dispatch_stub_805, _gloffset_GetQueryObjectui64vEXT, _dispatch_stub_805@12)
-	HIDDEN(GL_PREFIX(_dispatch_stub_805, _dispatch_stub_805@12))
+	GL_STUB(_dispatch_stub_810, _gloffset_StencilFuncSeparateATI, _dispatch_stub_810@16)
+	HIDDEN(GL_PREFIX(_dispatch_stub_810, _dispatch_stub_810@16))
+	GL_STUB(_dispatch_stub_811, _gloffset_ProgramEnvParameters4fvEXT, _dispatch_stub_811@16)
+	HIDDEN(GL_PREFIX(_dispatch_stub_811, _dispatch_stub_811@16))
+	GL_STUB(_dispatch_stub_812, _gloffset_ProgramLocalParameters4fvEXT, _dispatch_stub_812@16)
+	HIDDEN(GL_PREFIX(_dispatch_stub_812, _dispatch_stub_812@16))
+	GL_STUB(_dispatch_stub_813, _gloffset_GetQueryObjecti64vEXT, _dispatch_stub_813@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_813, _dispatch_stub_813@12))
+	GL_STUB(_dispatch_stub_814, _gloffset_GetQueryObjectui64vEXT, _dispatch_stub_814@12)
+	HIDDEN(GL_PREFIX(_dispatch_stub_814, _dispatch_stub_814@12))
 	GL_STUB(EGLImageTargetRenderbufferStorageOES, _gloffset_EGLImageTargetRenderbufferStorageOES, EGLImageTargetRenderbufferStorageOES@8)
 	GL_STUB(EGLImageTargetTexture2DOES, _gloffset_EGLImageTargetTexture2DOES, EGLImageTargetTexture2DOES@8)
 	GL_STUB_ALIAS(ArrayElementEXT, _gloffset_ArrayElement, ArrayElementEXT@4, ArrayElement, ArrayElement@4)
@@ -1069,6 +1078,10 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB_ALIAS(MultiTexCoord4iv, _gloffset_MultiTexCoord4ivARB, MultiTexCoord4iv@8, MultiTexCoord4ivARB, MultiTexCoord4ivARB@8)
 	GL_STUB_ALIAS(MultiTexCoord4s, _gloffset_MultiTexCoord4sARB, MultiTexCoord4s@20, MultiTexCoord4sARB, MultiTexCoord4sARB@20)
 	GL_STUB_ALIAS(MultiTexCoord4sv, _gloffset_MultiTexCoord4svARB, MultiTexCoord4sv@8, MultiTexCoord4svARB, MultiTexCoord4svARB@8)
+	GL_STUB_ALIAS(DrawArraysInstancedARB, _gloffset_DrawArraysInstanced, DrawArraysInstancedARB@16, DrawArraysInstanced, DrawArraysInstanced@16)
+	GL_STUB_ALIAS(DrawArraysInstancedEXT, _gloffset_DrawArraysInstanced, DrawArraysInstancedEXT@16, DrawArraysInstanced, DrawArraysInstanced@16)
+	GL_STUB_ALIAS(DrawElementsInstancedARB, _gloffset_DrawElementsInstanced, DrawElementsInstancedARB@20, DrawElementsInstanced, DrawElementsInstanced@20)
+	GL_STUB_ALIAS(DrawElementsInstancedEXT, _gloffset_DrawElementsInstanced, DrawElementsInstancedEXT@20, DrawElementsInstanced, DrawElementsInstanced@20)
 	GL_STUB_ALIAS(LoadTransposeMatrixd, _gloffset_LoadTransposeMatrixdARB, LoadTransposeMatrixd@4, LoadTransposeMatrixdARB, LoadTransposeMatrixdARB@4)
 	GL_STUB_ALIAS(LoadTransposeMatrixf, _gloffset_LoadTransposeMatrixfARB, LoadTransposeMatrixf@4, LoadTransposeMatrixfARB, LoadTransposeMatrixfARB@4)
 	GL_STUB_ALIAS(MultTransposeMatrixd, _gloffset_MultTransposeMatrixdARB, MultTransposeMatrixd@4, MultTransposeMatrixdARB, MultTransposeMatrixdARB@4)
@@ -1250,9 +1263,9 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB_ALIAS(IsProgramARB, _gloffset_IsProgramNV, IsProgramARB@4, IsProgramNV, IsProgramNV@4)
 	GL_STUB_ALIAS(PointParameteri, _gloffset_PointParameteriNV, PointParameteri@8, PointParameteriNV, PointParameteriNV@8)
 	GL_STUB_ALIAS(PointParameteriv, _gloffset_PointParameterivNV, PointParameteriv@8, PointParameterivNV, PointParameterivNV@8)
-	GL_STUB_ALIAS(DeleteVertexArrays, _gloffset_DeleteVertexArraysAPPLE, DeleteVertexArrays@8, _dispatch_stub_755, _dispatch_stub_755@8)
-	GL_STUB_ALIAS(IsVertexArray, _gloffset_IsVertexArrayAPPLE, IsVertexArray@4, _dispatch_stub_757, _dispatch_stub_757@4)
-	GL_STUB_ALIAS(BlendEquationSeparate, _gloffset_BlendEquationSeparateEXT, BlendEquationSeparate@8, _dispatch_stub_765, _dispatch_stub_765@8)
+	GL_STUB_ALIAS(DeleteVertexArrays, _gloffset_DeleteVertexArraysAPPLE, DeleteVertexArrays@8, _dispatch_stub_757, _dispatch_stub_757@8)
+	GL_STUB_ALIAS(IsVertexArray, _gloffset_IsVertexArrayAPPLE, IsVertexArray@4, _dispatch_stub_759, _dispatch_stub_759@4)
+	GL_STUB_ALIAS(BlendEquationSeparate, _gloffset_BlendEquationSeparateEXT, BlendEquationSeparate@8, _dispatch_stub_767, _dispatch_stub_767@8)
 	GL_STUB_ALIAS(BindFramebuffer, _gloffset_BindFramebufferEXT, BindFramebuffer@8, BindFramebufferEXT, BindFramebufferEXT@8)
 	GL_STUB_ALIAS(BindRenderbuffer, _gloffset_BindRenderbufferEXT, BindRenderbuffer@8, BindRenderbufferEXT, BindRenderbufferEXT@8)
 	GL_STUB_ALIAS(CheckFramebufferStatus, _gloffset_CheckFramebufferStatusEXT, CheckFramebufferStatus@4, CheckFramebufferStatusEXT, CheckFramebufferStatusEXT@4)
@@ -1270,8 +1283,14 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB_ALIAS(IsFramebuffer, _gloffset_IsFramebufferEXT, IsFramebuffer@4, IsFramebufferEXT, IsFramebufferEXT@4)
 	GL_STUB_ALIAS(IsRenderbuffer, _gloffset_IsRenderbufferEXT, IsRenderbuffer@4, IsRenderbufferEXT, IsRenderbufferEXT@4)
 	GL_STUB_ALIAS(RenderbufferStorage, _gloffset_RenderbufferStorageEXT, RenderbufferStorage@16, RenderbufferStorageEXT, RenderbufferStorageEXT@16)
-	GL_STUB_ALIAS(BlitFramebuffer, _gloffset_BlitFramebufferEXT, BlitFramebuffer@40, _dispatch_stub_783, _dispatch_stub_783@40)
+	GL_STUB_ALIAS(BlitFramebuffer, _gloffset_BlitFramebufferEXT, BlitFramebuffer@40, _dispatch_stub_785, _dispatch_stub_785@40)
 	GL_STUB_ALIAS(FramebufferTextureLayer, _gloffset_FramebufferTextureLayerEXT, FramebufferTextureLayer@20, FramebufferTextureLayerEXT, FramebufferTextureLayerEXT@20)
+	GL_STUB_ALIAS(BeginTransformFeedback, _gloffset_BeginTransformFeedbackEXT, BeginTransformFeedback@4, BeginTransformFeedbackEXT, BeginTransformFeedbackEXT@4)
+	GL_STUB_ALIAS(BindBufferBase, _gloffset_BindBufferBaseEXT, BindBufferBase@12, BindBufferBaseEXT, BindBufferBaseEXT@12)
+	GL_STUB_ALIAS(BindBufferRange, _gloffset_BindBufferRangeEXT, BindBufferRange@20, BindBufferRangeEXT, BindBufferRangeEXT@20)
+	GL_STUB_ALIAS(EndTransformFeedback, _gloffset_EndTransformFeedbackEXT, EndTransformFeedback@0, EndTransformFeedbackEXT, EndTransformFeedbackEXT@0)
+	GL_STUB_ALIAS(GetTransformFeedbackVarying, _gloffset_GetTransformFeedbackVaryingEXT, GetTransformFeedbackVarying@28, GetTransformFeedbackVaryingEXT, GetTransformFeedbackVaryingEXT@28)
+	GL_STUB_ALIAS(TransformFeedbackVaryings, _gloffset_TransformFeedbackVaryingsEXT, TransformFeedbackVaryings@16, TransformFeedbackVaryingsEXT, TransformFeedbackVaryingsEXT@16)
 	GL_STUB_ALIAS(ProvokingVertex, _gloffset_ProvokingVertexEXT, ProvokingVertex@4, ProvokingVertexEXT, ProvokingVertexEXT@4)
 
 		GLOBL	GLNAME(gl_dispatch_functions_end)