diff --git a/cogl/cogl-atlas-texture.c b/cogl/cogl-atlas-texture.c
index 8aacb072e..c37908adb 100644
--- a/cogl/cogl-atlas-texture.c
+++ b/cogl/cogl-atlas-texture.c
@@ -632,24 +632,6 @@ _cogl_atlas_texture_get_gl_format (CoglTexture *tex)
   return _cogl_texture_gl_get_format (atlas_tex->sub_texture);
 }
 
-static int
-_cogl_atlas_texture_get_width (CoglTexture *tex)
-{
-  CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
-
-  /* Forward on to the sub texture */
-  return cogl_texture_get_width (atlas_tex->sub_texture);
-}
-
-static int
-_cogl_atlas_texture_get_height (CoglTexture *tex)
-{
-  CoglAtlasTexture *atlas_tex = COGL_ATLAS_TEXTURE (tex);
-
-  /* Forward on to the sub texture */
-  return cogl_texture_get_height (atlas_tex->sub_texture);
-}
-
 static CoglBool
 _cogl_atlas_texture_can_use_format (CoglPixelFormat format)
 {
@@ -716,6 +698,7 @@ _cogl_atlas_texture_new_with_size (CoglContext *ctx,
 
   _cogl_texture_init (COGL_TEXTURE (atlas_tex),
                       ctx,
+                      width, height,
                       &cogl_atlas_texture_vtable);
 
   atlas_tex->sub_texture = NULL;
@@ -871,8 +854,6 @@ cogl_atlas_texture_vtable =
     _cogl_atlas_texture_gl_flush_legacy_texobj_wrap_modes,
     _cogl_atlas_texture_get_format,
     _cogl_atlas_texture_get_gl_format,
-    _cogl_atlas_texture_get_width,
-    _cogl_atlas_texture_get_height,
     _cogl_atlas_texture_get_type,
     NULL, /* is_foreign */
     NULL /* set_auto_mipmap */
diff --git a/cogl/cogl-sub-texture-private.h b/cogl/cogl-sub-texture-private.h
index 3b66e3bdd..32380b11b 100644
--- a/cogl/cogl-sub-texture-private.h
+++ b/cogl/cogl-sub-texture-private.h
@@ -44,14 +44,12 @@ struct _CoglSubTexture
      is created */
   CoglTexture *full_texture;
 
-  /* The region represented by this sub-texture. This is the region of
-     full_texture which won't necessarily be the same as the region
-     passed to _cogl_sub_texture_new if next_texture is actually
-     already a sub texture */
-  int         sub_x;
-  int         sub_y;
-  int         sub_width;
-  int         sub_height;
+  /* The offset of the region represented by this sub-texture. This is
+   * the offset in full_texture which won't necessarily be the same as
+   * the offset passed to _cogl_sub_texture_new if next_texture is
+   * actually already a sub texture */
+  int sub_x;
+  int sub_y;
 };
 
 #endif /* __COGL_SUB_TEXTURE_PRIVATE_H */
diff --git a/cogl/cogl-sub-texture.c b/cogl/cogl-sub-texture.c
index a66f48efb..18447f83e 100644
--- a/cogl/cogl-sub-texture.c
+++ b/cogl/cogl-sub-texture.c
@@ -52,6 +52,8 @@ static void
 _cogl_sub_texture_unmap_quad (CoglSubTexture *sub_tex,
                               float *coords)
 {
+  CoglTexture *tex = COGL_TEXTURE (sub_tex);
+
   /* NB: coords[] come in as non-normalized if sub_tex->full_texture
    * is a CoglTextureRectangle otherwhise they are normalized. The
    * coordinates we write out though must always be normalized.
@@ -61,19 +63,19 @@ _cogl_sub_texture_unmap_quad (CoglSubTexture *sub_tex,
    */
   if (cogl_is_texture_rectangle (sub_tex->full_texture))
     {
-      coords[0] = (coords[0] - sub_tex->sub_x) / sub_tex->sub_width;
-      coords[1] = (coords[1] - sub_tex->sub_y) / sub_tex->sub_height;
-      coords[2] = (coords[2] - sub_tex->sub_x) / sub_tex->sub_width;
-      coords[3] = (coords[3] - sub_tex->sub_y) / sub_tex->sub_height;
+      coords[0] = (coords[0] - sub_tex->sub_x) / tex->width;
+      coords[1] = (coords[1] - sub_tex->sub_y) / tex->height;
+      coords[2] = (coords[2] - sub_tex->sub_x) / tex->width;
+      coords[3] = (coords[3] - sub_tex->sub_y) / tex->height;
     }
   else
     {
       float width = cogl_texture_get_width (sub_tex->full_texture);
       float height = cogl_texture_get_height (sub_tex->full_texture);
-      coords[0] = (coords[0] * width - sub_tex->sub_x) / sub_tex->sub_width;
-      coords[1] = (coords[1] * height - sub_tex->sub_y) / sub_tex->sub_height;
-      coords[2] = (coords[2] * width - sub_tex->sub_x) / sub_tex->sub_width;
-      coords[3] = (coords[3] * height - sub_tex->sub_y) / sub_tex->sub_height;
+      coords[0] = (coords[0] * width - sub_tex->sub_x) / tex->width;
+      coords[1] = (coords[1] * height - sub_tex->sub_y) / tex->height;
+      coords[2] = (coords[2] * width - sub_tex->sub_x) / tex->width;
+      coords[3] = (coords[3] * height - sub_tex->sub_y) / tex->height;
     }
 }
 
@@ -81,6 +83,8 @@ static void
 _cogl_sub_texture_map_quad (CoglSubTexture *sub_tex,
                             float *coords)
 {
+  CoglTexture *tex = COGL_TEXTURE (sub_tex);
+
   /* NB: coords[] always come in as normalized coordinates but may go
    * out as non-normalized if sub_tex->full_texture is a
    * CoglTextureRectangle.
@@ -91,19 +95,19 @@ _cogl_sub_texture_map_quad (CoglSubTexture *sub_tex,
 
   if (cogl_is_texture_rectangle (sub_tex->full_texture))
     {
-      coords[0] = coords[0] * sub_tex->sub_width + sub_tex->sub_x;
-      coords[1] = coords[1] * sub_tex->sub_height + sub_tex->sub_y;
-      coords[2] = coords[2] * sub_tex->sub_width + sub_tex->sub_x;
-      coords[3] = coords[3] * sub_tex->sub_height + sub_tex->sub_y;
+      coords[0] = coords[0] * tex->width + sub_tex->sub_x;
+      coords[1] = coords[1] * tex->height + sub_tex->sub_y;
+      coords[2] = coords[2] * tex->width + sub_tex->sub_x;
+      coords[3] = coords[3] * tex->height + sub_tex->sub_y;
     }
   else
     {
       float width = cogl_texture_get_width (sub_tex->full_texture);
       float height = cogl_texture_get_height (sub_tex->full_texture);
-      coords[0] = (coords[0] * sub_tex->sub_width + sub_tex->sub_x) / width;
-      coords[1] = (coords[1] * sub_tex->sub_height + sub_tex->sub_y) / height;
-      coords[2] = (coords[2] * sub_tex->sub_width + sub_tex->sub_x) / width;
-      coords[3] = (coords[3] * sub_tex->sub_height + sub_tex->sub_y) / height;
+      coords[0] = (coords[0] * tex->width + sub_tex->sub_x) / width;
+      coords[1] = (coords[1] * tex->height + sub_tex->sub_y) / height;
+      coords[2] = (coords[2] * tex->width + sub_tex->sub_x) / width;
+      coords[3] = (coords[3] * tex->height + sub_tex->sub_y) / height;
     }
 }
 
@@ -230,7 +234,8 @@ cogl_sub_texture_new (CoglContext *ctx,
 
   tex = COGL_TEXTURE (sub_tex);
 
-  _cogl_texture_init (tex, ctx, &cogl_sub_texture_vtable);
+  _cogl_texture_init (tex, ctx, sub_width, sub_height,
+                      &cogl_sub_texture_vtable);
 
   /* If the next texture is also a sub texture we can avoid one level
      of indirection by referencing the full texture of that texture
@@ -250,8 +255,6 @@ cogl_sub_texture_new (CoglContext *ctx,
 
   sub_tex->sub_x = sub_x;
   sub_tex->sub_y = sub_y;
-  sub_tex->sub_width = sub_width;
-  sub_tex->sub_height = sub_height;
 
   return _cogl_sub_texture_object_new (sub_tex);
 }
@@ -285,9 +288,9 @@ _cogl_sub_texture_can_hardware_repeat (CoglTexture *tex)
 
   /* We can hardware repeat if the subtexture actually represents all of the
      of the full texture */
-  return (sub_tex->sub_width ==
+  return (tex->width ==
           cogl_texture_get_width (sub_tex->full_texture) &&
-          sub_tex->sub_height ==
+          tex->height ==
           cogl_texture_get_height (sub_tex->full_texture) &&
           _cogl_texture_can_hardware_repeat (sub_tex->full_texture));
 }
@@ -301,9 +304,9 @@ _cogl_sub_texture_transform_coords_to_gl (CoglTexture *tex,
 
   /* This won't work if the sub texture is not the size of the full
      texture and the coordinates are outside the range [0,1] */
-  *s = ((*s * sub_tex->sub_width + sub_tex->sub_x) /
+  *s = ((*s * tex->width + sub_tex->sub_x) /
         cogl_texture_get_width (sub_tex->full_texture));
-  *t = ((*t * sub_tex->sub_height + sub_tex->sub_y) /
+  *t = ((*t * tex->height + sub_tex->sub_y) /
         cogl_texture_get_height (sub_tex->full_texture));
 
   _cogl_texture_transform_coords_to_gl (sub_tex->full_texture, s, t);
@@ -418,22 +421,6 @@ _cogl_sub_texture_get_gl_format (CoglTexture *tex)
   return _cogl_texture_gl_get_format (sub_tex->full_texture);
 }
 
-static int
-_cogl_sub_texture_get_width (CoglTexture *tex)
-{
-  CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
-
-  return sub_tex->sub_width;
-}
-
-static int
-_cogl_sub_texture_get_height (CoglTexture *tex)
-{
-  CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
-
-  return sub_tex->sub_height;
-}
-
 static CoglTextureType
 _cogl_sub_texture_get_type (CoglTexture *tex)
 {
@@ -461,8 +448,6 @@ cogl_sub_texture_vtable =
     _cogl_sub_texture_gl_flush_legacy_texobj_wrap_modes,
     _cogl_sub_texture_get_format,
     _cogl_sub_texture_get_gl_format,
-    _cogl_sub_texture_get_width,
-    _cogl_sub_texture_get_height,
     _cogl_sub_texture_get_type,
     NULL, /* is_foreign */
     NULL /* set_auto_mipmap */
diff --git a/cogl/cogl-texture-2d-private.h b/cogl/cogl-texture-2d-private.h
index 39c9f2566..3ae8ded3e 100644
--- a/cogl/cogl-texture-2d-private.h
+++ b/cogl/cogl-texture-2d-private.h
@@ -40,8 +40,6 @@ struct _CoglTexture2D
   /* The internal format of the GL texture represented as a
      CoglPixelFormat */
   CoglPixelFormat format;
-  int width;
-  int height;
 
   CoglBool auto_mipmap;
   CoglBool mipmaps_dirty;
diff --git a/cogl/cogl-texture-2d-sliced-private.h b/cogl/cogl-texture-2d-sliced-private.h
index 9a43bdf7a..5bc4e5f83 100644
--- a/cogl/cogl-texture-2d-sliced-private.h
+++ b/cogl/cogl-texture-2d-sliced-private.h
@@ -33,14 +33,11 @@
 
 struct _CoglTexture2DSliced
 {
-  CoglTexture       _parent;
-  GArray           *slice_x_spans;
-  GArray           *slice_y_spans;
-  GArray           *slice_textures;
-  int               max_waste;
-
-  int               width;
-  int               height;
+  CoglTexture _parent;
+  GArray *slice_x_spans;
+  GArray *slice_y_spans;
+  GArray *slice_textures;
+  int max_waste;
 };
 
 CoglTexture2DSliced *
diff --git a/cogl/cogl-texture-2d-sliced.c b/cogl/cogl-texture-2d-sliced.c
index b6eacb7e0..51997bd3a 100644
--- a/cogl/cogl-texture-2d-sliced.c
+++ b/cogl/cogl-texture-2d-sliced.c
@@ -112,8 +112,8 @@ _cogl_texture_2d_sliced_foreach_sub_texture_in_region (
 
   data.callback = callback;
   data.user_data = user_data;
-  data.x_normalize_factor = 1.0f / tex_2ds->width;
-  data.y_normalize_factor = 1.0f / tex_2ds->height;
+  data.x_normalize_factor = 1.0f / tex->width;
+  data.y_normalize_factor = 1.0f / tex->height;
 
   un_normalized_coords[0] = virtual_tx_1 * data.x_normalize_factor;
   un_normalized_coords[1] = virtual_ty_1 * data.y_normalize_factor;
@@ -428,6 +428,7 @@ _cogl_texture_2d_sliced_upload_subregion_to_gl (CoglTexture2DSliced *tex_2ds,
                                                 GLuint source_gl_type,
                                                 CoglError **error)
 {
+  CoglTexture *tex = COGL_TEXTURE (tex_2ds);
   CoglSpan *x_span;
   CoglSpan *y_span;
   CoglSpanIter x_iter;
@@ -449,7 +450,7 @@ _cogl_texture_2d_sliced_upload_subregion_to_gl (CoglTexture2DSliced *tex_2ds,
        _cogl_span_iter_begin (&y_iter,
                               (CoglSpan *)tex_2ds->slice_y_spans->data,
                               tex_2ds->slice_y_spans->len,
-                              tex_2ds->height,
+                              tex->height,
                               dst_y,
                               dst_y + height,
                               COGL_PIPELINE_WRAP_MODE_REPEAT);
@@ -467,7 +468,7 @@ _cogl_texture_2d_sliced_upload_subregion_to_gl (CoglTexture2DSliced *tex_2ds,
            _cogl_span_iter_begin (&x_iter,
                                   (CoglSpan *)tex_2ds->slice_x_spans->data,
                                   tex_2ds->slice_x_spans->len,
-                                  tex_2ds->width,
+                                  tex->width,
                                   dst_x,
                                   dst_x + width,
                                   COGL_PIPELINE_WRAP_MODE_REPEAT);
@@ -866,7 +867,7 @@ _cogl_texture_2d_sliced_init_base (CoglContext *ctx,
 {
   CoglTexture *tex = COGL_TEXTURE (tex_2ds);
 
-  _cogl_texture_init (tex, ctx, &cogl_texture_2d_sliced_vtable);
+  _cogl_texture_init (tex, ctx, width, height, &cogl_texture_2d_sliced_vtable);
 
   tex_2ds->slice_x_spans = NULL;
   tex_2ds->slice_y_spans = NULL;
@@ -880,9 +881,6 @@ _cogl_texture_2d_sliced_init_base (CoglContext *ctx,
                                               internal_format))
     return FALSE;
 
-  tex_2ds->width = width;
-  tex_2ds->height = height;
-
   return TRUE;
 }
 
@@ -1052,10 +1050,9 @@ _cogl_texture_2d_sliced_new_from_foreign (CoglContext *ctx,
   tex_2ds = g_new0 (CoglTexture2DSliced, 1);
 
   tex = COGL_TEXTURE (tex_2ds);
-  tex->vtable = &cogl_texture_2d_sliced_vtable;
+  _cogl_texture_init (tex, ctx, gl_width, gl_height,
+                      &cogl_texture_2d_sliced_vtable);
 
-  tex_2ds->width = gl_width - x_pot_waste;
-  tex_2ds->height = gl_height - y_pot_waste;
   tex_2ds->max_waste = 0;
 
   /* Create slice arrays */
@@ -1163,8 +1160,8 @@ _cogl_texture_2d_sliced_transform_coords_to_gl (CoglTexture *tex,
   x_span = &g_array_index (tex_2ds->slice_x_spans, CoglSpan, 0);
   y_span = &g_array_index (tex_2ds->slice_y_spans, CoglSpan, 0);
 
-  *s *= tex_2ds->width / (float)x_span->size;
-  *t *= tex_2ds->height / (float)y_span->size;
+  *s *= tex->width / (float)x_span->size;
+  *t *= tex->height / (float)y_span->size;
 
   /* Let the child texture further transform the coords */
   slice_tex = g_array_index (tex_2ds->slice_textures, CoglTexture2D *, 0);
@@ -1356,18 +1353,6 @@ _cogl_texture_2d_sliced_get_gl_format (CoglTexture *tex)
   return _cogl_texture_gl_get_format (COGL_TEXTURE (slice_tex));
 }
 
-static int
-_cogl_texture_2d_sliced_get_width (CoglTexture *tex)
-{
-  return COGL_TEXTURE_2D_SLICED (tex)->width;
-}
-
-static int
-_cogl_texture_2d_sliced_get_height (CoglTexture *tex)
-{
-  return COGL_TEXTURE_2D_SLICED (tex)->height;
-}
-
 static CoglTextureType
 _cogl_texture_2d_sliced_get_type (CoglTexture *tex)
 {
@@ -1393,8 +1378,6 @@ cogl_texture_2d_sliced_vtable =
     _cogl_texture_2d_sliced_gl_flush_legacy_texobj_wrap_modes,
     _cogl_texture_2d_sliced_get_format,
     _cogl_texture_2d_sliced_get_gl_format,
-    _cogl_texture_2d_sliced_get_width,
-    _cogl_texture_2d_sliced_get_height,
     _cogl_texture_2d_sliced_get_type,
     _cogl_texture_2d_sliced_is_foreign,
     NULL /* set_auto_mipmap */
diff --git a/cogl/cogl-texture-2d.c b/cogl/cogl-texture-2d.c
index 9df370d48..74ab1ab83 100644
--- a/cogl/cogl-texture-2d.c
+++ b/cogl/cogl-texture-2d.c
@@ -112,10 +112,8 @@ _cogl_texture_2d_create_base (CoglContext *ctx,
   CoglTexture2D *tex_2d = g_new (CoglTexture2D, 1);
   CoglTexture *tex = COGL_TEXTURE (tex_2d);
 
-  _cogl_texture_init (tex, ctx, &cogl_texture_2d_vtable);
+  _cogl_texture_init (tex, ctx, width, height, &cogl_texture_2d_vtable);
 
-  tex_2d->width = width;
-  tex_2d->height = height;
   tex_2d->mipmaps_dirty = TRUE;
   tex_2d->auto_mipmap = TRUE;
 
@@ -382,12 +380,11 @@ _cogl_texture_2d_is_sliced (CoglTexture *tex)
 static CoglBool
 _cogl_texture_2d_can_hardware_repeat (CoglTexture *tex)
 {
-  CoglTexture2D *tex_2d = COGL_TEXTURE_2D (tex);
   CoglContext *ctx = tex->context;
 
   if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT) ||
-      (_cogl_util_is_pot (tex_2d->width) &&
-       _cogl_util_is_pot (tex_2d->height)))
+      (_cogl_util_is_pot (tex->width) &&
+       _cogl_util_is_pot (tex->height)))
     return TRUE;
   else
     return FALSE;
@@ -537,18 +534,6 @@ _cogl_texture_2d_get_gl_format (CoglTexture *tex)
   return COGL_TEXTURE_2D (tex)->gl_internal_format;
 }
 
-static int
-_cogl_texture_2d_get_width (CoglTexture *tex)
-{
-  return COGL_TEXTURE_2D (tex)->width;
-}
-
-static int
-_cogl_texture_2d_get_height (CoglTexture *tex)
-{
-  return COGL_TEXTURE_2D (tex)->height;
-}
-
 static CoglBool
 _cogl_texture_2d_is_foreign (CoglTexture *tex)
 {
@@ -580,8 +565,6 @@ cogl_texture_2d_vtable =
     _cogl_texture_2d_gl_flush_legacy_texobj_wrap_modes,
     _cogl_texture_2d_get_format,
     _cogl_texture_2d_get_gl_format,
-    _cogl_texture_2d_get_width,
-    _cogl_texture_2d_get_height,
     _cogl_texture_2d_get_type,
     _cogl_texture_2d_is_foreign,
     _cogl_texture_2d_set_auto_mipmap
diff --git a/cogl/cogl-texture-3d-private.h b/cogl/cogl-texture-3d-private.h
index 7df5b9f51..88f702665 100644
--- a/cogl/cogl-texture-3d-private.h
+++ b/cogl/cogl-texture-3d-private.h
@@ -37,8 +37,6 @@ struct _CoglTexture3D
   /* The internal format of the texture represented as a
      CoglPixelFormat */
   CoglPixelFormat format;
-  int width;
-  int height;
   int depth;
   CoglBool auto_mipmap;
   CoglBool mipmaps_dirty;
diff --git a/cogl/cogl-texture-3d.c b/cogl/cogl-texture-3d.c
index e7a9051be..ab7c7e1a7 100644
--- a/cogl/cogl-texture-3d.c
+++ b/cogl/cogl-texture-3d.c
@@ -120,10 +120,8 @@ _cogl_texture_3d_create_base (CoglContext *ctx,
   CoglTexture3D *tex_3d = g_new (CoglTexture3D, 1);
   CoglTexture *tex = COGL_TEXTURE (tex_3d);
 
-  _cogl_texture_init (tex, ctx, &cogl_texture_3d_vtable);
+  _cogl_texture_init (tex, ctx, width, height, &cogl_texture_3d_vtable);
 
-  tex_3d->width = width;
-  tex_3d->height = height;
   tex_3d->depth = depth;
   tex_3d->mipmaps_dirty = TRUE;
   tex_3d->auto_mipmap = TRUE;
@@ -639,18 +637,6 @@ _cogl_texture_3d_get_gl_format (CoglTexture *tex)
   return COGL_TEXTURE_3D (tex)->gl_format;
 }
 
-static int
-_cogl_texture_3d_get_width (CoglTexture *tex)
-{
-  return COGL_TEXTURE_3D (tex)->width;
-}
-
-static int
-_cogl_texture_3d_get_height (CoglTexture *tex)
-{
-  return COGL_TEXTURE_3D (tex)->height;
-}
-
 static CoglTextureType
 _cogl_texture_3d_get_type (CoglTexture *tex)
 {
@@ -676,8 +662,6 @@ cogl_texture_3d_vtable =
     _cogl_texture_3d_gl_flush_legacy_texobj_wrap_modes,
     _cogl_texture_3d_get_format,
     _cogl_texture_3d_get_gl_format,
-    _cogl_texture_3d_get_width,
-    _cogl_texture_3d_get_height,
     _cogl_texture_3d_get_type,
     NULL, /* is_foreign */
     _cogl_texture_3d_set_auto_mipmap
diff --git a/cogl/cogl-texture-private.h b/cogl/cogl-texture-private.h
index 25087c2f5..6ff48605b 100644
--- a/cogl/cogl-texture-private.h
+++ b/cogl/cogl-texture-private.h
@@ -126,8 +126,6 @@ struct _CoglTextureVtable
 
   CoglPixelFormat (* get_format) (CoglTexture *tex);
   GLenum (* get_gl_format) (CoglTexture *tex);
-  int (* get_width) (CoglTexture *tex);
-  int (* get_height) (CoglTexture *tex);
 
   CoglTextureType (* get_type) (CoglTexture *tex);
 
@@ -144,6 +142,8 @@ struct _CoglTexture
   CoglContext *context;
   GList *framebuffers;
   int max_level;
+  int width;
+  int height;
   const CoglTextureVtable *vtable;
 };
 
@@ -177,6 +177,8 @@ struct _CoglTexturePixel
 void
 _cogl_texture_init (CoglTexture *texture,
                     CoglContext *ctx,
+                    int width,
+                    int height,
                     const CoglTextureVtable *vtable);
 
 void
diff --git a/cogl/cogl-texture-rectangle-private.h b/cogl/cogl-texture-rectangle-private.h
index 366d58c44..e6592a547 100644
--- a/cogl/cogl-texture-rectangle-private.h
+++ b/cogl/cogl-texture-rectangle-private.h
@@ -35,8 +35,6 @@ struct _CoglTextureRectangle
   /* The internal format of the texture represented as a
      CoglPixelFormat */
   CoglPixelFormat format;
-  int width;
-  int height;
 
   /* TODO: factor out these OpenGL specific members into some form
    * of driver private state. */
diff --git a/cogl/cogl-texture-rectangle.c b/cogl/cogl-texture-rectangle.c
index 28dcd575b..ee4cfcf0e 100644
--- a/cogl/cogl-texture-rectangle.c
+++ b/cogl/cogl-texture-rectangle.c
@@ -171,10 +171,7 @@ _cogl_texture_rectangle_create_base (CoglContext *ctx,
   CoglTextureRectangle *tex_rect = g_new (CoglTextureRectangle, 1);
   CoglTexture *tex = COGL_TEXTURE (tex_rect);
 
-  _cogl_texture_init (tex, ctx, &cogl_texture_rectangle_vtable);
-
-  tex_rect->width = width;
-  tex_rect->height = height;
+  _cogl_texture_init (tex, ctx, width, height, &cogl_texture_rectangle_vtable);
 
   /* We default to GL_LINEAR for both filters */
   tex_rect->gl_legacy_texobj_min_filter = GL_LINEAR;
@@ -462,17 +459,14 @@ _cogl_texture_rectangle_transform_coords_to_gl (CoglTexture *tex,
                                                 float *s,
                                                 float *t)
 {
-  CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
-
-  *s *= tex_rect->width;
-  *t *= tex_rect->height;
+  *s *= tex->width;
+  *t *= tex->height;
 }
 
 static CoglTransformResult
 _cogl_texture_rectangle_transform_quad_coords_to_gl (CoglTexture *tex,
                                                      float *coords)
 {
-  CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
   CoglBool need_repeat = FALSE;
   int i;
 
@@ -480,7 +474,7 @@ _cogl_texture_rectangle_transform_quad_coords_to_gl (CoglTexture *tex,
     {
       if (coords[i] < 0.0f || coords[i] > 1.0f)
         need_repeat = TRUE;
-      coords[i] *= (i & 1) ? tex_rect->height : tex_rect->width;
+      coords[i] *= (i & 1) ? tex->height : tex->width;
     }
 
   return (need_repeat ? COGL_TRANSFORM_SOFTWARE_REPEAT
@@ -614,7 +608,7 @@ _cogl_texture_rectangle_get_data (CoglTexture *tex,
 
   ctx->texture_driver->prep_gl_for_pixels_download (ctx,
                                                     rowstride,
-                                                    tex_rect->width,
+                                                    tex->width,
                                                     bpp);
 
   _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
@@ -639,18 +633,6 @@ _cogl_texture_rectangle_get_gl_format (CoglTexture *tex)
   return COGL_TEXTURE_RECTANGLE (tex)->gl_format;
 }
 
-static int
-_cogl_texture_rectangle_get_width (CoglTexture *tex)
-{
-  return COGL_TEXTURE_RECTANGLE (tex)->width;
-}
-
-static int
-_cogl_texture_rectangle_get_height (CoglTexture *tex)
-{
-  return COGL_TEXTURE_RECTANGLE (tex)->height;
-}
-
 static CoglBool
 _cogl_texture_rectangle_is_foreign (CoglTexture *tex)
 {
@@ -682,8 +664,6 @@ cogl_texture_rectangle_vtable =
     _cogl_texture_rectangle_gl_flush_legacy_texobj_wrap_modes,
     _cogl_texture_rectangle_get_format,
     _cogl_texture_rectangle_get_gl_format,
-    _cogl_texture_rectangle_get_width,
-    _cogl_texture_rectangle_get_height,
     _cogl_texture_rectangle_get_type,
     _cogl_texture_rectangle_is_foreign,
     _cogl_texture_rectangle_set_auto_mipmap
diff --git a/cogl/cogl-texture.c b/cogl/cogl-texture.c
index a78af53b5..28d1f4cc9 100644
--- a/cogl/cogl-texture.c
+++ b/cogl/cogl-texture.c
@@ -131,10 +131,14 @@ cogl_texture_unref (void *object)
 void
 _cogl_texture_init (CoglTexture *texture,
                     CoglContext *context,
+                    int width,
+                    int height,
                     const CoglTextureVtable *vtable)
 {
   texture->context = context;
   texture->max_level = 0;
+  texture->width = width;
+  texture->height = height;
   texture->vtable = vtable;
   texture->framebuffers = NULL;
 }
@@ -295,13 +299,13 @@ cogl_texture_new_from_sub_texture (CoglTexture *full_texture,
 unsigned int
 cogl_texture_get_width (CoglTexture *texture)
 {
-  return texture->vtable->get_width (texture);
+  return texture->width;
 }
 
 unsigned int
 cogl_texture_get_height (CoglTexture *texture)
 {
-  return texture->vtable->get_height (texture);
+  return texture->height;
 }
 
 CoglPixelFormat
diff --git a/cogl/driver/gl/cogl-texture-2d-gl.c b/cogl/driver/gl/cogl-texture-2d-gl.c
index cf4649289..4f57eed61 100644
--- a/cogl/driver/gl/cogl-texture-2d-gl.c
+++ b/cogl/driver/gl/cogl-texture-2d-gl.c
@@ -607,6 +607,7 @@ _cogl_texture_2d_gl_get_data (CoglTexture2D *tex_2d,
 {
   CoglContext *ctx = COGL_TEXTURE (tex_2d)->context;
   int bpp;
+  int width = COGL_TEXTURE (tex_2d)->width;
   GLenum gl_format;
   GLenum gl_type;
 
@@ -620,7 +621,7 @@ _cogl_texture_2d_gl_get_data (CoglTexture2D *tex_2d,
 
   ctx->texture_driver->prep_gl_for_pixels_download (ctx,
                                                     rowstride,
-                                                    tex_2d->width,
+                                                    width,
                                                     bpp);
 
   _cogl_bind_gl_texture_transient (GL_TEXTURE_2D,
diff --git a/cogl/winsys/cogl-texture-pixmap-x11-private.h b/cogl/winsys/cogl-texture-pixmap-x11-private.h
index 1c21ea0aa..b99dfa6f4 100644
--- a/cogl/winsys/cogl-texture-pixmap-x11-private.h
+++ b/cogl/winsys/cogl-texture-pixmap-x11-private.h
@@ -57,8 +57,6 @@ struct _CoglTexturePixmapX11
 
   unsigned int depth;
   Visual *visual;
-  unsigned int width;
-  unsigned int height;
 
   XImage *image;
 
diff --git a/cogl/winsys/cogl-texture-pixmap-x11.c b/cogl/winsys/cogl-texture-pixmap-x11.c
index d26fe7fd9..2b66414ea 100644
--- a/cogl/winsys/cogl-texture-pixmap-x11.c
+++ b/cogl/winsys/cogl-texture-pixmap-x11.c
@@ -125,6 +125,7 @@ static void
 process_damage_event (CoglTexturePixmapX11 *tex_pixmap,
                       XDamageNotifyEvent *damage_event)
 {
+  CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
   Display *display;
   enum { DO_NOTHING, NEEDS_SUBTRACT, NEED_BOUNDING_BOX } handle_mode;
   const CoglWinsysVtable *winsys;
@@ -167,8 +168,8 @@ process_damage_event (CoglTexturePixmapX11 *tex_pixmap,
      need to request the bounding box of the region because we're
      going to update the whole texture anyway. */
   if (cogl_damage_rectangle_is_whole (&tex_pixmap->damage_rect,
-                                      tex_pixmap->width,
-                                      tex_pixmap->height))
+                                      tex->width,
+                                      tex->height))
     {
       if (handle_mode != DO_NOTHING)
         XDamageSubtract (display, tex_pixmap->damage, None, None);
@@ -283,24 +284,16 @@ cogl_texture_pixmap_x11_new (CoglContext *ctxt,
   Display *display = cogl_xlib_renderer_get_display (ctxt->display->renderer);
   Window pixmap_root_window;
   int pixmap_x, pixmap_y;
+  unsigned int pixmap_width, pixmap_height;
   unsigned int pixmap_border_width;
   CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
   XWindowAttributes window_attributes;
   int damage_base;
   const CoglWinsysVtable *winsys;
 
-  _cogl_texture_init (tex, ctxt, &cogl_texture_pixmap_x11_vtable);
-
-  tex_pixmap->pixmap = pixmap;
-  tex_pixmap->image = NULL;
-  tex_pixmap->shm_info.shmid = -1;
-  tex_pixmap->tex = NULL;
-  tex_pixmap->damage_owned = FALSE;
-  tex_pixmap->damage = 0;
-
   if (!XGetGeometry (display, pixmap, &pixmap_root_window,
                      &pixmap_x, &pixmap_y,
-                     &tex_pixmap->width, &tex_pixmap->height,
+                     &pixmap_width, &pixmap_height,
                      &pixmap_border_width, &tex_pixmap->depth))
     {
       g_free (tex_pixmap);
@@ -311,6 +304,16 @@ cogl_texture_pixmap_x11_new (CoglContext *ctxt,
       return NULL;
     }
 
+  _cogl_texture_init (tex, ctxt, pixmap_width, pixmap_height,
+                      &cogl_texture_pixmap_x11_vtable);
+
+  tex_pixmap->pixmap = pixmap;
+  tex_pixmap->image = NULL;
+  tex_pixmap->shm_info.shmid = -1;
+  tex_pixmap->tex = NULL;
+  tex_pixmap->damage_owned = FALSE;
+  tex_pixmap->damage = 0;
+
   /* We need a visual to use for shared memory images so we'll query
      it from the pixmap's root window */
   if (!XGetWindowAttributes (display, pixmap_root_window, &window_attributes))
@@ -342,9 +345,9 @@ cogl_texture_pixmap_x11_new (CoglContext *ctxt,
 
   /* Assume the entire pixmap is damaged to begin with */
   tex_pixmap->damage_rect.x1 = 0;
-  tex_pixmap->damage_rect.x2 = tex_pixmap->width;
+  tex_pixmap->damage_rect.x2 = tex->width;
   tex_pixmap->damage_rect.y1 = 0;
-  tex_pixmap->damage_rect.y2 = tex_pixmap->height;
+  tex_pixmap->damage_rect.y2 = tex->height;
 
   winsys = _cogl_texture_pixmap_x11_get_winsys (tex_pixmap);
   if (winsys->texture_pixmap_x11_create)
@@ -366,6 +369,7 @@ cogl_texture_pixmap_x11_new (CoglContext *ctxt,
 static void
 try_alloc_shm (CoglTexturePixmapX11 *tex_pixmap)
 {
+  CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
   XImage *dummy_image;
   Display *display;
 
@@ -392,8 +396,8 @@ try_alloc_shm (CoglTexturePixmapX11 *tex_pixmap)
                      ZPixmap,
                      NULL,
                      NULL, /* shminfo, */
-                     tex_pixmap->width,
-                     tex_pixmap->height);
+                     tex->width,
+                     tex->height);
   if (!dummy_image)
     goto failed_image_create;
 
@@ -479,6 +483,7 @@ cogl_texture_pixmap_x11_set_damage_object (CoglTexturePixmapX11 *tex_pixmap,
 static void
 _cogl_texture_pixmap_x11_update_image_texture (CoglTexturePixmapX11 *tex_pixmap)
 {
+  CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
   Display *display;
   Visual *visual;
   CoglPixelFormat image_format;
@@ -514,8 +519,8 @@ _cogl_texture_pixmap_x11_update_image_texture (CoglTexturePixmapX11 *tex_pixmap)
                         ? COGL_PIXEL_FORMAT_RGBA_8888_PRE
                         : COGL_PIXEL_FORMAT_RGB_888);
 
-      tex_pixmap->tex = cogl_texture_new_with_size (tex_pixmap->width,
-                                                    tex_pixmap->height,
+      tex_pixmap->tex = cogl_texture_new_with_size (tex->width,
+                                                    tex->height,
                                                     COGL_TEXTURE_NONE,
                                                     texture_format);
     }
@@ -540,7 +545,7 @@ _cogl_texture_pixmap_x11_update_image_texture (CoglTexturePixmapX11 *tex_pixmap)
           tex_pixmap->image = XGetImage (display,
                                          tex_pixmap->pixmap,
                                          0, 0,
-                                         tex_pixmap->width, tex_pixmap->height,
+                                         tex->width, tex->height,
                                          AllPlanes, ZPixmap);
           image = tex_pixmap->image;
           src_x = x;
@@ -773,8 +778,8 @@ _cogl_texture_pixmap_x11_foreach_sub_texture_in_region
   if (cogl_is_texture_rectangle (child_tex))
     {
       NormalizeCoordsWrapperData data;
-      int width = tex_pixmap->width;
-      int height = tex_pixmap->height;
+      int width = tex->width;
+      int height = tex->height;
 
       virtual_tx_1 *= width;
       virtual_ty_1 *= height;
@@ -945,22 +950,6 @@ _cogl_texture_pixmap_x11_get_gl_format (CoglTexture *tex)
   return _cogl_texture_gl_get_format (child_tex);
 }
 
-static int
-_cogl_texture_pixmap_x11_get_width (CoglTexture *tex)
-{
-  CoglTexturePixmapX11 *tex_pixmap = COGL_TEXTURE_PIXMAP_X11 (tex);
-
-  return tex_pixmap->width;
-}
-
-static int
-_cogl_texture_pixmap_x11_get_height (CoglTexture *tex)
-{
-  CoglTexturePixmapX11 *tex_pixmap = COGL_TEXTURE_PIXMAP_X11 (tex);
-
-  return tex_pixmap->height;
-}
-
 static CoglTextureType
 _cogl_texture_pixmap_x11_get_type (CoglTexture *tex)
 {
@@ -1027,8 +1016,6 @@ cogl_texture_pixmap_x11_vtable =
     _cogl_texture_pixmap_x11_gl_flush_legacy_texobj_wrap_modes,
     _cogl_texture_pixmap_x11_get_format,
     _cogl_texture_pixmap_x11_get_gl_format,
-    _cogl_texture_pixmap_x11_get_width,
-    _cogl_texture_pixmap_x11_get_height,
     _cogl_texture_pixmap_x11_get_type,
     NULL, /* is_foreign */
     NULL /* set_auto_mipmap */
diff --git a/cogl/winsys/cogl-winsys-egl-x11.c b/cogl/winsys/cogl-winsys-egl-x11.c
index fca7609f1..3e91b9935 100644
--- a/cogl/winsys/cogl-winsys-egl-x11.c
+++ b/cogl/winsys/cogl-winsys-egl-x11.c
@@ -686,15 +686,13 @@ _cogl_winsys_poll_dispatch (CoglContext *context,
 static CoglBool
 _cogl_winsys_texture_pixmap_x11_create (CoglTexturePixmapX11 *tex_pixmap)
 {
+  CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
+  CoglContext *ctx = tex->context;
   CoglTexturePixmapEGL *egl_tex_pixmap;
   EGLint attribs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
   CoglPixelFormat texture_format;
   CoglRendererEGL *egl_renderer;
 
-  /* FIXME: It should be possible to get to a CoglContext from any
-   * CoglTexture pointer. */
-  _COGL_GET_CONTEXT (ctx, FALSE);
-
   egl_renderer = ctx->display->renderer->winsys;
 
   if (!(egl_renderer->private_features &
@@ -725,8 +723,8 @@ _cogl_winsys_texture_pixmap_x11_create (CoglTexturePixmapX11 *tex_pixmap)
 
   egl_tex_pixmap->texture = COGL_TEXTURE (
     _cogl_egl_texture_2d_new_from_image (ctx,
-                                         tex_pixmap->width,
-                                         tex_pixmap->height,
+                                         tex->width,
+                                         tex->height,
                                          texture_format,
                                          egl_tex_pixmap->image,
                                          NULL));
diff --git a/cogl/winsys/cogl-winsys-glx.c b/cogl/winsys/cogl-winsys-glx.c
index 6df9c4809..2bfa19085 100644
--- a/cogl/winsys/cogl-winsys-glx.c
+++ b/cogl/winsys/cogl-winsys-glx.c
@@ -1931,6 +1931,7 @@ static CoglBool
 _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
                                         CoglBool needs_mipmap)
 {
+  CoglTexture *tex = COGL_TEXTURE (tex_pixmap);
   CoglContext *ctx = COGL_TEXTURE (tex_pixmap)->context;
   CoglTexturePixmapGLX *glx_tex_pixmap = tex_pixmap->winsys;
   CoglGLXRenderer *glx_renderer;
@@ -1955,8 +1956,8 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
         {
           glx_tex_pixmap->glx_tex = COGL_TEXTURE (
             cogl_texture_rectangle_new_with_size (ctx,
-                                                  tex_pixmap->width,
-                                                  tex_pixmap->height,
+                                                  tex->width,
+                                                  tex->height,
                                                   texture_format,
                                                   &error));
 
@@ -1977,8 +1978,8 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
         {
           glx_tex_pixmap->glx_tex = COGL_TEXTURE (
             cogl_texture_2d_new_with_size (ctx,
-                                           tex_pixmap->width,
-                                           tex_pixmap->height,
+                                           tex->width,
+                                           tex->height,
                                            texture_format,
                                            NULL));