Add CopySubBufferMESA support

19 files changed, 266 insertions, 102 deletions

diff --git a/src/agl/glitz_agl_context.c b/src/agl/glitz_agl_context.c
index 7105fd3..14b54fb 100644
--- a/src/agl/glitz_agl_context.c
+++ b/src/agl/glitz_agl_context.c
@@ -302,6 +302,7 @@ glitz_agl_context_get (glitz_agl_thread_info_t *thread_info,
     context->backend.attach_notify = _glitz_agl_notify_dummy;
     context->backend.detach_notify = _glitz_agl_notify_dummy;
     context->backend.swap_buffers = glitz_agl_swap_buffers;
+    context->backend.copy_sub_buffer = glitz_agl_copy_sub_buffer;
 
     context->backend.create_context = _glitz_agl_create_context;
     context->backend.destroy_context = _glitz_agl_context_destroy;
diff --git a/src/agl/glitz_agl_drawable.c b/src/agl/glitz_agl_drawable.c
index 991efae..04b1a7b 100644
--- a/src/agl/glitz_agl_drawable.c
+++ b/src/agl/glitz_agl_drawable.c
@@ -247,3 +247,13 @@ glitz_agl_swap_buffers (void *abstract_drawable)
 
     return 1;
 }
+
+glitz_bool_t
+glitz_agl_copy_sub_buffer (void *abstract_drawable,
+			   int  x,
+			   int  y,
+			   int  width,
+			   int  height)
+{
+    return 0;
+}
diff --git a/src/agl/glitz_aglint.h b/src/agl/glitz_aglint.h
index 1a058b0..e25a81f 100644
--- a/src/agl/glitz_aglint.h
+++ b/src/agl/glitz_aglint.h
@@ -131,6 +131,13 @@ extern glitz_bool_t __internal_linkage
 glitz_agl_swap_buffers (void *abstract_drawable);
 
 extern glitz_bool_t __internal_linkage
+glitz_agl_copy_sub_buffer (void *abstract_drawable,
+			   int  x,
+			   int  y,
+			   int  width,
+			   int  height);
+
+extern glitz_bool_t __internal_linkage
 glitz_agl_drawable_update_size (glitz_agl_drawable_t *drawable,
 				int                  width,
 				int                  height);
diff --git a/src/egl/glitz_egl_context.c b/src/egl/glitz_egl_context.c
index 8110dc2..9ccb557 100644
--- a/src/egl/glitz_egl_context.c
+++ b/src/egl/glitz_egl_context.c
@@ -199,6 +199,7 @@ glitz_egl_context_get (glitz_egl_screen_info_t *screen_info,
     context->backend.attach_notify = _glitz_egl_notify_dummy;
     context->backend.detach_notify = _glitz_egl_notify_dummy;
     context->backend.swap_buffers = glitz_egl_swap_buffers;
+    context->backend.copy_sub_buffer = glitz_egl_copy_sub_buffer;
 
     context->backend.create_context = _glitz_egl_create_context;
     context->backend.destroy_context = _glitz_egl_context_destroy;
diff --git a/src/egl/glitz_egl_surface.c b/src/egl/glitz_egl_surface.c
index 440b3d1..6a20688 100644
--- a/src/egl/glitz_egl_surface.c
+++ b/src/egl/glitz_egl_surface.c
@@ -242,3 +242,13 @@ glitz_egl_swap_buffers (void *abstract_drawable)
 
     return 1;
 }
+
+glitz_bool_t
+glitz_egl_copy_sub_buffer (void *abstract_drawable,
+			   int  x,
+			   int  y,
+			   int  width,
+			   int  height)
+{
+    return 0;
+}
diff --git a/src/egl/glitz_eglint.h b/src/egl/glitz_eglint.h
index f97896f..9ed052f 100644
--- a/src/egl/glitz_eglint.h
+++ b/src/egl/glitz_eglint.h
@@ -161,6 +161,13 @@ glitz_egl_destroy (void *abstract_drawable);
 extern glitz_bool_t __internal_linkage
 glitz_egl_swap_buffers (void *abstract_drawable);
 
+extern glitz_bool_t __internal_linkage
+glitz_egl_copy_sub_buffer (void *abstract_drawable,
+			   int  x,
+			   int  y,
+			   int  width,
+			   int  height);
+
 /* Avoid unnecessary PLT entries. */
 
 slim_hidden_proto(glitz_egl_init)
diff --git a/src/glitz.h b/src/glitz.h
index 669b60a..72d0334 100644
--- a/src/glitz.h
+++ b/src/glitz.h
@@ -129,6 +129,7 @@ typedef enum {
 #define GLITZ_FEATURE_PACKED_PIXELS_MASK            (1L << 14)
 #define GLITZ_FEATURE_MULTI_DRAW_ARRAYS_MASK        (1L << 15)
 #define GLITZ_FEATURE_FRAMEBUFFER_OBJECT_MASK       (1L << 16)
+#define GLITZ_FEATURE_COPY_SUB_BUFFER_MASK          (1L << 17)
 
 
 /* glitz_format.c */
diff --git a/src/glitz_drawable.c b/src/glitz_drawable.c
index cef6787..ea7543e 100644
--- a/src/glitz_drawable.c
+++ b/src/glitz_drawable.c
@@ -195,125 +195,157 @@ glitz_drawable_swap_buffer_region (glitz_drawable_t *drawable,
 				   glitz_box_t      *box,
 				   int              n_box)
 {
-    if (drawable->format->d.doublebuffer && n_box)
-    {
-	glitz_box_t	rect;
-	glitz_surface_t *surface = NULL;
-	int		x_pos, y_pos;
-	int		x, y, w, h;
+    glitz_box_t	    rect;
+    glitz_surface_t *surface = NULL;
+    int		    x_pos, y_pos;
+    int		    x, y, w, h;
+
+    GLITZ_GL_DRAWABLE (drawable);
 
-	GLITZ_GL_DRAWABLE (drawable);
+    if (!drawable->format->d.doublebuffer || !n_box)
+	return;
 
-	if (n_box == 1)
+    /* try swap buffers (fastest) */
+    if (n_box == 1)
+    {
+	rect.x1 = x_origin + box->x1;
+	rect.y1 = y_origin + box->y1;
+	rect.x2 = x_origin + box->x2;
+	rect.y2 = y_origin + box->y2;
+
+	if (rect.x1 <= 0	       &&
+	    rect.y1 <= 0	       &&
+	    rect.x2 >= drawable->width &&
+	    rect.x2 >= drawable->height)
 	{
-	    rect.x1 = x_origin + box->x1;
-	    rect.y1 = y_origin + box->y1;
-	    rect.x2 = x_origin + box->x2;
-	    rect.y2 = y_origin + box->y2;
-
-	    if (rect.x1 <= 0		   &&
-		rect.y1 <= 0		   &&
-		rect.x2 >= drawable->width &&
-		rect.x2 >= drawable->height)
+	    if (drawable->backend->swap_buffers (drawable))
 	    {
-		if (drawable->backend->swap_buffers (drawable))
+		if (drawable->front)
 		{
-		    if (drawable->front)
-		    {
-			REGION_EMPTY (&drawable->front->drawable_damage);
-			glitz_surface_damage (drawable->front, NULL,
-					      GLITZ_DAMAGE_TEXTURE_MASK |
-					      GLITZ_DAMAGE_SOLID_MASK);
-		    }
-		    return;
+		    REGION_EMPTY (&drawable->front->drawable_damage);
+		    glitz_surface_damage (drawable->front, NULL,
+					  GLITZ_DAMAGE_TEXTURE_MASK |
+					  GLITZ_DAMAGE_SOLID_MASK);
 		}
+		return;
 	    }
 	}
+    }
+
+    /* try copy sub buffer (almost as fast) */
+    while (n_box)
+    {
+	rect.x1 = x_origin + box->x1;
+	rect.y1 = y_origin + box->y1;
+	rect.x2 = x_origin + box->x2;
+	rect.y2 = y_origin + box->y2;
 
-	if (drawable->front)
+	if (rect.x1 < rect.x2 && rect.y1 < rect.y2)
 	{
-	    if (glitz_surface_push_current (drawable->front,
-					    GLITZ_DRAWABLE_CURRENT))
-		surface = drawable->front;
+	    x = rect.x1;
+	    y = drawable->height - rect.y2;
+	    w = rect.x2 - rect.x1;
+	    h = rect.y2 - rect.y1;
+
+	    if (!drawable->backend->copy_sub_buffer (drawable, x, y, w, h))
+		break;
+
+	    if (drawable->front)
+		glitz_surface_damage (drawable->front, &rect,
+				      GLITZ_DAMAGE_TEXTURE_MASK |
+				      GLITZ_DAMAGE_SOLID_MASK);
 	}
 
-	if (!surface)
+	n_box--;
+	box++;
+    }
+
+    if (!n_box)
+	return;
+
+    /* do copy pixels (slow) */
+    if (drawable->front)
+    {
+	if (glitz_surface_push_current (drawable->front,
+					GLITZ_DRAWABLE_CURRENT))
+	    surface = drawable->front;
+    }
+    if (!surface)
+    {
+	if (drawable->backend->push_current (drawable, NULL,
+					     GLITZ_DRAWABLE_CURRENT))
 	{
-	    if (drawable->backend->push_current (drawable, NULL,
-						 GLITZ_DRAWABLE_CURRENT))
-	    {
-		drawable->update_all = 1;
-
-		gl->viewport (0, 0, drawable->width, drawable->height);
-		gl->matrix_mode (GLITZ_GL_PROJECTION);
-		gl->load_identity ();
-		gl->ortho (0.0, drawable->width, 0.0,
-			   drawable->height, -1.0, 1.0);
-		gl->matrix_mode (GLITZ_GL_MODELVIEW);
-		gl->load_identity ();
-		gl->scale_f (1.0f, -1.0f, 1.0f);
-		gl->translate_f (0.0f, -drawable->height, 0.0f);
-	    }
-	    else
-	    {
-		drawable->backend->pop_current (drawable);
-		return;
-	    }
+	    drawable->update_all = 1;
+
+	    gl->viewport (0, 0, drawable->width, drawable->height);
+	    gl->matrix_mode (GLITZ_GL_PROJECTION);
+	    gl->load_identity ();
+	    gl->ortho (0.0, drawable->width, 0.0,
+		       drawable->height, -1.0, 1.0);
+	    gl->matrix_mode (GLITZ_GL_MODELVIEW);
+	    gl->load_identity ();
+	    gl->scale_f (1.0f, -1.0f, 1.0f);
+	    gl->translate_f (0.0f, -drawable->height, 0.0f);
+	}
+	else
+	{
+	    drawable->backend->pop_current (drawable);
+	    return;
 	}
+    }
+
+    gl->disable (GLITZ_GL_DITHER);
 
-	gl->disable (GLITZ_GL_DITHER);
+    drawable->backend->read_buffer (drawable, GLITZ_GL_BACK);
+    drawable->backend->draw_buffer (drawable, GLITZ_GL_FRONT);
 
-	drawable->backend->read_buffer (drawable, GLITZ_GL_BACK);
-	drawable->backend->draw_buffer (drawable, GLITZ_GL_FRONT);
+    glitz_set_operator (gl, GLITZ_OPERATOR_SRC);
 
-	glitz_set_operator (gl, GLITZ_OPERATOR_SRC);
+    x_pos = 0;
+    y_pos = 0;
 
-	x_pos = 0;
-	y_pos = 0;
+    glitz_set_raster_pos (gl, x_pos, y_pos);
 
-	glitz_set_raster_pos (gl, x_pos, y_pos);
+    while (n_box--)
+    {
+	rect.x1 = x_origin + box->x1;
+	rect.y1 = y_origin + box->y1;
+	rect.x2 = x_origin + box->x2;
+	rect.y2 = y_origin + box->y2;
 
-	while (n_box--)
+	if (rect.x1 < rect.x2 && rect.y1 < rect.y2)
 	{
-	    rect.x1 = x_origin + box->x1;
-	    rect.y1 = y_origin + box->y1;
-	    rect.x2 = x_origin + box->x2;
-	    rect.y2 = y_origin + box->y2;
+	    x = rect.x1;
+	    y = drawable->height - rect.y2;
+	    w = rect.x2 - rect.x1;
+	    h = rect.y2 - rect.y1;
 
-	    if (rect.x1 < rect.x2 && rect.y1 < rect.y2)
+	    if (x != x_pos || y != y_pos)
 	    {
-		x = rect.x1;
-		y = drawable->height - rect.y2;
-		w = rect.x2 - rect.x1;
-		h = rect.y2 - rect.y1;
-
-		if (x != x_pos || y != y_pos)
-		{
-		    gl->bitmap (0, 0, 0, 0, x - x_pos, y - y_pos, NULL);
+		gl->bitmap (0, 0, 0, 0, x - x_pos, y - y_pos, NULL);
 
-		    x_pos = x;
-		    y_pos = y;
-		}
+		x_pos = x;
+		y_pos = y;
+	    }
 
-		gl->scissor (x, y, w, h);
-		gl->copy_pixels (x, y, w, h, GLITZ_GL_COLOR);
+	    gl->scissor (x, y, w, h);
+	    gl->copy_pixels (x, y, w, h, GLITZ_GL_COLOR);
 
-		if (surface)
-		    glitz_surface_damage (surface, &rect,
-					  GLITZ_DAMAGE_TEXTURE_MASK |
-					  GLITZ_DAMAGE_SOLID_MASK);
+	    if (surface)
+		glitz_surface_damage (surface, &rect,
+				      GLITZ_DAMAGE_TEXTURE_MASK |
+				      GLITZ_DAMAGE_SOLID_MASK);
 
-		box++;
-	    }
+	    box++;
 	}
+    }
 
-	drawable->backend->gl->flush ();
+    drawable->backend->gl->flush ();
 
-	if (surface)
-	    glitz_surface_pop_current (surface);
-	else
-	    drawable->backend->pop_current (drawable);
-    }
+    if (surface)
+	glitz_surface_pop_current (surface);
+    else
+	drawable->backend->pop_current (drawable);
 }
 
 void
diff --git a/src/glitz_framebuffer.c b/src/glitz_framebuffer.c
index d39119b..1ccc877 100644
--- a/src/glitz_framebuffer.c
+++ b/src/glitz_framebuffer.c
@@ -329,6 +329,16 @@ _glitz_fbo_swap_buffers (void *abstract_drawable)
     return 0;
 }
 
+static glitz_bool_t
+_glitz_fbo_copy_sub_buffer (void *abstract_drawable,
+			    int  x,
+			    int  y,
+			    int  width,
+			    int  height)
+{
+    return 0;
+}
+
 static void
 _glitz_fbo_destroy (void *abstract_drawable)
 {
@@ -427,15 +437,16 @@ _glitz_fbo_drawable_create (glitz_drawable_t	        *other,
     backend = (glitz_backend_t *) (drawable + 1);
     *backend = *other->backend;
 
-    backend->destroy       = _glitz_fbo_destroy;
-    backend->push_current  = _glitz_fbo_push_current;
-    backend->pop_current   = _glitz_fbo_pop_current;
-    backend->attach_notify = _glitz_fbo_attach_notify;
-    backend->detach_notify = _glitz_fbo_detach_notify;
-    backend->swap_buffers  = _glitz_fbo_swap_buffers;
-    backend->make_current  = _glitz_fbo_make_current;
-    backend->draw_buffer   = _glitz_fbo_draw_buffer;
-    backend->read_buffer   = _glitz_fbo_read_buffer;
+    backend->destroy         = _glitz_fbo_destroy;
+    backend->push_current    = _glitz_fbo_push_current;
+    backend->pop_current     = _glitz_fbo_pop_current;
+    backend->attach_notify   = _glitz_fbo_attach_notify;
+    backend->detach_notify   = _glitz_fbo_detach_notify;
+    backend->swap_buffers    = _glitz_fbo_swap_buffers;
+    backend->copy_sub_buffer = _glitz_fbo_copy_sub_buffer;
+    backend->make_current    = _glitz_fbo_make_current;
+    backend->draw_buffer     = _glitz_fbo_draw_buffer;
+    backend->read_buffer     = _glitz_fbo_read_buffer;
 
     drawable->fb = 0;
 
diff --git a/src/glitzint.h b/src/glitzint.h
index e8a9763..6e24d44 100644
--- a/src/glitzint.h
+++ b/src/glitzint.h
@@ -390,6 +390,12 @@ typedef struct glitz_backend {
   glitz_bool_t
   (*swap_buffers)              (void *drawable);
 
+  glitz_bool_t
+  (*copy_sub_buffer)           (void *drawable,
+				int  x,
+				int  y,
+				int  width,
+				int  height);
 
   glitz_context_t *
   (*create_context)            (void                    *drawable,
diff --git a/src/glx/glitz_glx_context.c b/src/glx/glitz_glx_context.c
index 5614428..9646e64 100644
--- a/src/glx/glitz_glx_context.c
+++ b/src/glx/glitz_glx_context.c
@@ -279,6 +279,7 @@ glitz_glx_context_get (glitz_glx_screen_info_t *screen_info,
     context->backend.attach_notify = _glitz_glx_notify_dummy;
     context->backend.detach_notify = _glitz_glx_notify_dummy;
     context->backend.swap_buffers = glitz_glx_swap_buffers;
+    context->backend.copy_sub_buffer = glitz_glx_copy_sub_buffer;
 
     context->backend.create_context = _glitz_glx_create_context;
     context->backend.destroy_context = _glitz_glx_context_destroy;
@@ -364,6 +365,9 @@ _glitz_glx_context_initialize (glitz_glx_screen_info_t *screen_info,
 	}
     }
 
+    if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_COPY_SUB_BUFFER_MASK)
+	context->backend.feature_mask |= GLITZ_FEATURE_COPY_SUB_BUFFER_MASK;
+
     context->initialized = 1;
 }
 
diff --git a/src/glx/glitz_glx_drawable.c b/src/glx/glitz_glx_drawable.c
index d92ad14..9685c10 100644
--- a/src/glx/glitz_glx_drawable.c
+++ b/src/glx/glitz_glx_drawable.c
@@ -241,3 +241,25 @@ glitz_glx_swap_buffers (void *abstract_drawable)
 
     return 1;
 }
+
+glitz_bool_t
+glitz_glx_copy_sub_buffer (void *abstract_drawable,
+			   int  x,
+			   int  y,
+			   int  width,
+			   int  height)
+{
+    glitz_glx_drawable_t    *drawable = (glitz_glx_drawable_t *)
+	abstract_drawable;
+    glitz_glx_screen_info_t *screen_info = drawable->screen_info;
+
+    if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_COPY_SUB_BUFFER_MASK)
+    {
+	screen_info->glx.copy_sub_buffer (screen_info->display_info->display,
+					  drawable->drawable,
+					  x, y, width, height);
+	return 1;
+    }
+
+    return 0;
+}
diff --git a/src/glx/glitz_glx_extension.c b/src/glx/glitz_glx_extension.c
index 1442d61..d741d12 100644
--- a/src/glx/glitz_glx_extension.c
+++ b/src/glx/glitz_glx_extension.c
@@ -39,17 +39,28 @@ static glitz_extension_map glx_extensions[] = {
     { 0.0, NULL, 0 }
 };
 
+/* XXX: only checking for client side support right now */
+static glitz_extension_map glx_client_extensions[] = {
+    { 0.0, "GLX_MESA_copy_sub_buffer", GLITZ_GLX_FEATURE_COPY_SUB_BUFFER_MASK },
+    { 0.0, NULL, 0 }
+};
+
 void
 glitz_glx_query_extensions (glitz_glx_screen_info_t *screen_info,
 			    glitz_gl_float_t        glx_version)
 {
     const char *glx_extensions_string;
+    const char *glx_client_extensions_string;
     const char *vendor;
 
     glx_extensions_string =
 	glXQueryExtensionsString (screen_info->display_info->display,
 				  screen_info->screen);
 
+    glx_client_extensions_string =
+	glXGetClientString (screen_info->display_info->display,
+			    GLX_EXTENSIONS);
+
     vendor = glXGetClientString (screen_info->display_info->display,
 				 GLX_VENDOR);
 
@@ -68,6 +79,11 @@ glitz_glx_query_extensions (glitz_glx_screen_info_t *screen_info,
 				glx_extensions_string,
 				glx_extensions);
 
+    screen_info->glx_feature_mask |=
+	glitz_extensions_query (glx_version,
+				glx_client_extensions_string,
+				glx_client_extensions);
+
     if (vendor)
     {
 	if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_MULTISAMPLE_MASK)
diff --git a/src/glx/glitz_glx_info.c b/src/glx/glitz_glx_info.c
index 5f7f287..dbc9f2a 100644
--- a/src/glx/glitz_glx_info.c
+++ b/src/glx/glitz_glx_info.c
@@ -256,6 +256,17 @@ _glitz_glx_proc_address_lookup (glitz_glx_screen_info_t *screen_info)
 		~GLITZ_GLX_FEATURE_MAKE_CURRENT_READ_MASK;
     }
 
+    if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_COPY_SUB_BUFFER_MASK)
+    {
+	screen_info->glx.copy_sub_buffer = (glitz_glx_copy_sub_buffer_t)
+	    glitz_glx_get_proc_address ("glXCopySubBufferMESA",
+					(void *) screen_info);
+
+	if (!screen_info->glx.copy_sub_buffer)
+	    screen_info->glx_feature_mask &=
+		~GLITZ_GLX_FEATURE_COPY_SUB_BUFFER_MASK;
+    }
+
     if (screen_info->glx_feature_mask &
 	GLITZ_GLX_FEATURE_GET_PROC_ADDRESS_MASK) {
 	if (screen_info->glx_version >= 1.4f) {
diff --git a/src/glx/glitz_glxext.h b/src/glx/glitz_glxext.h
index 015e76a..49a5f0d 100644
--- a/src/glx/glitz_glxext.h
+++ b/src/glx/glitz_glxext.h
@@ -120,9 +120,7 @@ typedef GLXContext (* glitz_glx_create_new_context_t)
 #define GLX_SAMPLES_ARB                     0x186a1
 #endif
 
-typedef Bool *(* glitz_glx_bind_tex_image_t)
-    (Display *display, GLXPbuffer pbuffer, int buffer);
-typedef Bool (* glitz_glx_release_tex_image_t)
-    (Display *display, GLXPbuffer pbuffer, int buffer);
+typedef void *(* glitz_glx_copy_sub_buffer_t)
+    (Display *display, GLXDrawable draw, int x, int y, int w, int h);
 
 #endif /* GLITZ_GLXEXT_H_INCLUDED */
diff --git a/src/glx/glitz_glxint.h b/src/glx/glitz_glxint.h
index fde6719..ac58212 100644
--- a/src/glx/glitz_glxint.h
+++ b/src/glx/glitz_glxint.h
@@ -43,6 +43,7 @@
 #define GLITZ_GLX_FEATURE_GET_PROC_ADDRESS_MASK    (1L << 4)
 #define GLITZ_GLX_FEATURE_MULTISAMPLE_MASK         (1L << 5)
 #define GLITZ_GLX_FEATURE_PBUFFER_MULTISAMPLE_MASK (1L << 6)
+#define GLITZ_GLX_FEATURE_COPY_SUB_BUFFER_MASK     (1L << 7)
 
 typedef struct _glitz_glx_drawable glitz_glx_drawable_t;
 typedef struct _glitz_glx_screen_info_t glitz_glx_screen_info_t;
@@ -58,6 +59,7 @@ typedef struct _glitz_glx_static_proc_address_list_t {
     glitz_glx_query_drawable_t           query_drawable;
     glitz_glx_make_context_current_t     make_context_current;
     glitz_glx_create_new_context_t       create_new_context;
+    glitz_glx_copy_sub_buffer_t          copy_sub_buffer;
 } glitz_glx_static_proc_address_list_t;
 
 typedef struct _glitz_glx_thread_info_t {
@@ -183,6 +185,13 @@ glitz_glx_destroy (void *abstract_drawable);
 extern glitz_bool_t __internal_linkage
 glitz_glx_swap_buffers (void *abstract_drawable);
 
+extern glitz_bool_t __internal_linkage
+glitz_glx_copy_sub_buffer (void *abstract_drawable,
+			   int  x,
+			   int  y,
+			   int  width,
+			   int  height);
+
 /* Avoid unnecessary PLT entries. */
 
 slim_hidden_proto(glitz_glx_init)
diff --git a/src/wgl/glitz_wgl_context.c b/src/wgl/glitz_wgl_context.c
index ec83a4f..c112885 100644
--- a/src/wgl/glitz_wgl_context.c
+++ b/src/wgl/glitz_wgl_context.c
@@ -186,6 +186,7 @@ glitz_wgl_context_get (glitz_wgl_screen_info_t          *screen_info,
     context->backend.attach_notify = _glitz_wgl_notify_dummy;
     context->backend.detach_notify = _glitz_wgl_notify_dummy;
     context->backend.swap_buffers = glitz_wgl_swap_buffers;
+    context->backend.copy_sub_buffer = glitz_wgl_copy_sub_buffer;
 
     context->backend.create_context = _glitz_wgl_create_context;
     context->backend.destroy_context = _glitz_wgl_destroy_context;
diff --git a/src/wgl/glitz_wgl_drawable.c b/src/wgl/glitz_wgl_drawable.c
index 058f1f7..7bffd6d 100644
--- a/src/wgl/glitz_wgl_drawable.c
+++ b/src/wgl/glitz_wgl_drawable.c
@@ -226,3 +226,13 @@ glitz_wgl_swap_buffers (void *abstract_drawable)
 
     return 1;
 }
+
+glitz_bool_t
+glitz_wgl_copy_sub_buffer (void *abstract_drawable,
+			   int  x,
+			   int  y,
+			   int  width,
+			   int  height)
+{
+    return 0;
+}
diff --git a/src/wgl/glitz_wglint.h b/src/wgl/glitz_wglint.h
index 05dc2cc..2e7519e 100644
--- a/src/wgl/glitz_wglint.h
+++ b/src/wgl/glitz_wglint.h
@@ -187,6 +187,13 @@ glitz_wgl_destroy (void *abstract_drawable);
 extern glitz_bool_t __internal_linkage
 glitz_wgl_swap_buffers (void *abstract_drawable);
 
+extern glitz_bool_t __internal_linkage
+glitz_wgl_copy_sub_buffer (void *abstract_drawable,
+			   int  x,
+			   int  y,
+			   int  width,
+			   int  height);
+
 extern void __internal_linkage
 glitz_wgl_print_win32_error_string (int error_code);