Bump version to 3.33.1

Update NEWS.

.gitlab-ci.yml

@@ -7,6 +7,8 @@ stages:
 
 check-commit-log:
   stage: review
+  variables:
+    GIT_DEPTH: "100"
   script:
     - ./.gitlab-ci/check-commit-log.sh
   only:
@@ -15,7 +17,7 @@ check-commit-log:
 build-mutter:
   stage: build
   script:
-    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror
+    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
     - ninja -C build
     - ninja -C build install
   artifacts:
@@ -42,3 +44,17 @@ test-mutter:
   only:
     - merge_requests
     - /^.*$/
+
+can-build-gnome-shell:
+  stage: test
+  dependencies:
+    - build-mutter
+  before_script:
+    - meson install --no-rebuild -C build
+  script:
+    - .gitlab-ci/checkout-gnome-shell.sh
+    - meson gnome-shell gnome-shell/build --prefix /usr
+    - ninja -C gnome-shell/build install
+  only:
+    - merge_requests
+    - /^.*$/

.gitlab-ci/Dockerfile

@@ -2,16 +2,25 @@ FROM fedora:29
 
 RUN dnf -y update && dnf -y upgrade && \
     dnf install -y 'dnf-command(builddep)' && \
+    dnf install -y 'dnf-command(copr)' && \
+    dnf copr enable -y fmuellner/gnome-shell-ci && \
+
     dnf builddep -y mutter && \
 
     # Until Fedora catches up with meson build-deps
     dnf install -y meson xorg-x11-server-Xorg gnome-settings-daemon-devel egl-wayland-devel xorg-x11-server-Xwayland && \
 
     # For running unit tests
-    dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 && \
+    dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 '*/xvfb-run' gdm-lib accountsservice-libs && \
 
     # Unpackaged versions
-    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00848426-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00848426-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
+    dnf install -y https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00834984-gsettings-desktop-schemas/gsettings-desktop-schemas-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm https://copr-be.cloud.fedoraproject.org/results/jadahl/mutter-ci/fedora-29-x86_64/00834984-gsettings-desktop-schemas/gsettings-desktop-schemas-devel-3.30.1-1.20181206git918efdd69be53.fc29.x86_64.rpm && \
 
     dnf install -y intltool redhat-rpm-config make && \
+
+    # GNOME Shell
+    dnf builddep -y gnome-shell --setopt=install_weak_deps=False && \
+    dnf remove -y gnome-bluetooth-libs-devel dbus-glib-devel upower-devel python3-devel && \
+    dnf remove -y --noautoremove mutter mutter-devel && \
+
     dnf clean all

.gitlab-ci/checkout-gnome-shell.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/bash
+
+mutter_branch=$(git describe --contains --all HEAD)
+gnome_shell_target=
+
+git clone https://gitlab.gnome.org/GNOME/gnome-shell.git
+
+if [ $? -ne 0 ]; then
+  echo Checkout failed
+  exit 1
+fi
+
+cd gnome-shell
+
+if [ "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME" ]; then
+  merge_request_remote=${CI_MERGE_REQUEST_SOURCE_PROJECT_URL//mutter/gnome-shell}
+  merge_request_branch=$CI_MERGE_REQUEST_SOURCE_BRANCH_NAME
+
+  echo Looking for $merge_request_branch on remote ...
+  if git fetch -q $merge_request_remote $merge_request_branch 2>/dev/null; then
+    gnome_shell_target=FETCH_HEAD
+  else
+    gnome_shell_target=origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME
+    echo Using $gnome_shell_target instead
+  fi
+fi
+
+if [ -z "$gnome_shell_target" ]; then
+  gnome_shell_target=$(git branch -r -l origin/$mutter_branch)
+  gnome_shell_target=${gnome_shell_target:-$(git branch -r -l ${mutter_branch#remotes/})}
+  gnome_shell_target=${gnome_shell_target:-origin/master}
+  echo Using $gnome_shell_target instead
+fi
+
+git checkout -q $gnome_shell_target

NEWS

@@ -1,3 +1,58 @@
+3.33.1
+======
+* Remove unused APIs and outdated driver support
+  [Adam; !481, !468, !489, !487, !546]
+* Enable EGL_IMG_context_priority [Adam; !454]
+* Disable mouse keys with Numlock on [Olivier; #530]
+* Fix crash when restarting on X11 [Marco; #576]
+* Implement clipboard manager [Carlos; !320]
+* Fix spurious idle signals that prevent session unblank [Jonas Å.; !543]
+* Fix mapping of touchscreens that don't report dimensions [Carlos; #581]
+* Fix propagating fractional scaling factor [Robert; !537]
+* Add experimental RT scheduling support [Carlos; !460]
+* Misc. bug fixes and cleanups [Robert, Carlos, Olivier, Ray, Marco, Jonas D.,
+  Georges, Daniel V., Daniel M; !467, !504, !551, !552, #575, #556, !557, !442,
+  !562, !535, !548, #586, !567, !396, !422, !507]
+
+Contributors:
+  Jonas Ådahl, Piotr Drąg, Jonas Dreßler, Olivier Fourdan, Carlos Garnacho,
+  Adam Jackson, Robert Mader, Daniel García Moreno, Florian Müllner,
+  Georges Basile Stavracas Neto, Ray Strode, Marco Trevisan (Treviño),
+  Daniel van Vugt
+
+Translators:
+  Daniel Mustieles [es], Fabio Tomat [fur], Kukuh Syafaat [id]
+
+3.32.1
+======
+* Fix fallback app menu on wayland [Florian; #493]
+* Fix elogind support [Tom; !491]
+* Fix startup notifications not timing out [Carlos; #501]
+* Fix keyboard accessibility toggle from keys
+  [Olivier, Carlos; !501, #529, !531]
+* Fix touchscreen input on rotated displays [Carlos; #514]
+* Work around hangul text input bug [Carlos; #1365]
+* Fix blurry wallpaper scaling [Daniel; !505]
+* Fix placement of window menu when using fractional scaling [Jan; #527]
+* Fix repaint issues of offscreen effects on secondary monitors [Daniel; !511]
+* Fix windows not getting focus after launch [Daniel; #505]
+* Properly advertise support for 'underscan' property [Jonas; !507]
+* Improve power-saving handling [Jonas; !506]
+* Fix moving windows by super+touch [Jonas D.; !495]
+* Misc. bug fixes and cleanups [Benjamin, Florian, Adam, Marco, Pablo,
+  Erik, Jonas, Heiher, Pekka, Daniel, Olivier, Carlos; !478, !475, !480,
+  !482, #490, !488, #491, #480, !477, !496, !492, !485, !515, !519, !521,
+  !216, !538, #541, #523]
+
+Contributors:
+  Jonas Ådahl, Pablo Barciela, Benjamin Berg, Tom Briden, Jonas Dreßler,
+  Olivier Fourdan, Carlos Garnacho, Jan Alexander Steffens (heftig), Heiher,
+  Adam Jackson, Erik Kurzinger, Florian Müllner, Pekka Paalanen,
+  Marco Trevisan (Treviño), Daniel van Vugt
+
+Translators:
+  Khaled Hosny [ar], Goran Vidović [hr], Daniel Mustieles [es]
+
 3.32.0
 ======
 * Fix deadlock when cancelling a theme sound [Andrea; !474]

clutter/clutter/clutter-actor.c

@@ -807,6 +807,9 @@ struct _ClutterActorPrivate
   gpointer create_child_data;
   GDestroyNotify create_child_notify;
 
+  guint resolution_changed_id;
+  guint font_changed_id;
+
   /* bitfields: KEEP AT THE END */
 
   /* fixed position and sizes */
@@ -5983,6 +5986,7 @@ clutter_actor_dispose (GObject *object)
 {
   ClutterActor *self = CLUTTER_ACTOR (object);
   ClutterActorPrivate *priv = self->priv;
+  ClutterBackend *backend = clutter_get_default_backend ();
 
   CLUTTER_NOTE (MISC, "Dispose actor (name='%s', ref_count:%d) of type '%s'",
 		_clutter_actor_get_debug_name (self),
@@ -6019,6 +6023,18 @@ clutter_actor_dispose (GObject *object)
       g_assert (!CLUTTER_ACTOR_IS_REALIZED (self));
     }
 
+  if (priv->resolution_changed_id)
+    {
+      g_signal_handler_disconnect (backend, priv->resolution_changed_id);
+      priv->resolution_changed_id = 0;
+    }
+
+  if (priv->font_changed_id)
+    {
+      g_signal_handler_disconnect (backend, priv->font_changed_id);
+      priv->font_changed_id = 0;
+    }
+
   g_clear_object (&priv->pango_context);
   g_clear_object (&priv->actions);
   g_clear_object (&priv->constraints);
@@ -15884,10 +15900,12 @@ clutter_actor_get_pango_context (ClutterActor *self)
     {
       priv->pango_context = clutter_actor_create_pango_context (self);
 
-      g_signal_connect_object (backend, "resolution-changed",
-                               G_CALLBACK (update_pango_context), priv->pango_context, 0);
-      g_signal_connect_object (backend, "font-changed",
-                               G_CALLBACK (update_pango_context), priv->pango_context, 0);
+      priv->resolution_changed_id =
+        g_signal_connect_object (backend, "resolution-changed",
+                                 G_CALLBACK (update_pango_context), priv->pango_context, 0);
+      priv->font_changed_id =
+        g_signal_connect_object (backend, "font-changed",
+                                 G_CALLBACK (update_pango_context), priv->pango_context, 0);
     }
   else
     update_pango_context (backend, priv->pango_context);

clutter/clutter/clutter-blur-effect.c

@@ -249,9 +249,7 @@ clutter_blur_effect_init (ClutterBlurEffect *self)
       cogl_pipeline_add_layer_snippet (klass->base_pipeline, 0, snippet);
       cogl_object_unref (snippet);
 
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
-                                            0, /* layer number */
-                                            COGL_TEXTURE_TYPE_2D);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);

clutter/clutter/clutter-brightness-contrast-effect.c

@@ -438,9 +438,7 @@ clutter_brightness_contrast_effect_init (ClutterBrightnessContrastEffect *self)
       cogl_pipeline_add_snippet (klass->base_pipeline, snippet);
       cogl_object_unref (snippet);
 
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
-                                            0, /* layer number */
-                                            COGL_TEXTURE_TYPE_2D);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);

clutter/clutter/clutter-click-action.c

@@ -355,6 +355,10 @@ on_captured_event (ClutterActor       *stage,
 
   switch (clutter_event_type (event))
     {
+    case CLUTTER_TOUCH_CANCEL:
+      clutter_click_action_release (action);
+      break;
+
     case CLUTTER_TOUCH_END:
       has_button = FALSE;
     case CLUTTER_BUTTON_RELEASE:

clutter/clutter/clutter-colorize-effect.c

@@ -293,9 +293,7 @@ clutter_colorize_effect_init (ClutterColorizeEffect *self)
       cogl_pipeline_add_snippet (klass->base_pipeline, snippet);
       cogl_object_unref (snippet);
 
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
-                                            0, /* layer number */
-                                            COGL_TEXTURE_TYPE_2D);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);

clutter/clutter/clutter-deform-effect.c

@@ -282,6 +282,7 @@ clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect)
   /* enable depth testing */
   cogl_depth_state_init (&depth_state);
   cogl_depth_state_set_test_enabled (&depth_state, TRUE);
+  cogl_depth_state_set_test_function (&depth_state, COGL_DEPTH_TEST_FUNCTION_LEQUAL);
   cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL);
 
   /* enable backface culling if we have a back material */

clutter/clutter/clutter-desaturate-effect.c

@@ -297,9 +297,7 @@ clutter_desaturate_effect_init (ClutterDesaturateEffect *self)
       cogl_pipeline_add_snippet (klass->base_pipeline, snippet);
       cogl_object_unref (snippet);
 
-      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
-                                            0, /* layer number */
-                                            COGL_TEXTURE_TYPE_2D);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline, 0);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);

clutter/clutter/clutter-enums.h

@@ -909,7 +909,6 @@ typedef enum
 
 /**
  * ClutterFeatureFlags:
- * @CLUTTER_FEATURE_TEXTURE_NPOT: Set if NPOTS textures supported.
  * @CLUTTER_FEATURE_SWAP_THROTTLE: Set if backend throttles buffer swaps.
  * @CLUTTER_FEATURE_TEXTURE_YUV: Set if YUV based textures supported.
  * @CLUTTER_FEATURE_TEXTURE_READ_PIXELS: Set if texture pixels can be read.
@@ -928,7 +927,6 @@ typedef enum
  */
 typedef enum
 {
-  CLUTTER_FEATURE_TEXTURE_NPOT           = (1 << 2),
   CLUTTER_FEATURE_SWAP_THROTTLE          = (1 << 3),
   CLUTTER_FEATURE_TEXTURE_YUV            = (1 << 4),
   CLUTTER_FEATURE_TEXTURE_READ_PIXELS    = (1 << 5),

clutter/clutter/clutter-event.c

@@ -1021,6 +1021,9 @@ clutter_event_get_event_sequence (const ClutterEvent *event)
       event->type == CLUTTER_TOUCH_END ||
       event->type == CLUTTER_TOUCH_CANCEL)
     return event->touch.sequence;
+  else if (event->type == CLUTTER_ENTER ||
+           event->type == CLUTTER_LEAVE)
+    return event->crossing.sequence;
 
   return NULL;
 }

clutter/clutter/clutter-event.h

@@ -269,6 +269,7 @@ struct _ClutterCrossingEvent
   gfloat x;
   gfloat y;
   ClutterInputDevice *device;
+  ClutterEventSequence *sequence;
   ClutterActor *related;
 };
 

clutter/clutter/clutter-feature.c

@@ -64,17 +64,13 @@ clutter_features_from_cogl (guint cogl_flags)
 {
   ClutterFeatureFlags clutter_flags = 0;
   
-  if (cogl_flags & COGL_FEATURE_TEXTURE_NPOT)
-    clutter_flags |= CLUTTER_FEATURE_TEXTURE_NPOT;
-
   if (cogl_flags & COGL_FEATURE_TEXTURE_YUV)
     clutter_flags |= CLUTTER_FEATURE_TEXTURE_YUV;
   
   if (cogl_flags & COGL_FEATURE_TEXTURE_READ_PIXELS)
     clutter_flags |= CLUTTER_FEATURE_TEXTURE_READ_PIXELS;
   
-  if (cogl_flags & COGL_FEATURE_SHADERS_GLSL)
-    clutter_flags |= CLUTTER_FEATURE_SHADERS_GLSL;
+  clutter_flags |= CLUTTER_FEATURE_SHADERS_GLSL;
   
   if (cogl_flags & COGL_FEATURE_OFFSCREEN)
     clutter_flags |= CLUTTER_FEATURE_OFFSCREEN;

clutter/clutter/clutter-input-device.c

@@ -834,6 +834,7 @@ _clutter_input_device_set_actor (ClutterInputDevice   *device,
           event->crossing.x = device->current_x;
           event->crossing.y = device->current_y;
           event->crossing.related = actor;
+          event->crossing.sequence = sequence;
           clutter_event_set_device (event, device);
 
           /* we need to make sure that this event is processed
@@ -870,6 +871,7 @@ _clutter_input_device_set_actor (ClutterInputDevice   *device,
           event->crossing.y = device->current_y;
           event->crossing.source = actor;
           event->crossing.related = old_actor;
+          event->crossing.sequence = sequence;
           clutter_event_set_device (event, device);
 
           /* see above */

clutter/clutter/clutter-main.c

@@ -2004,6 +2004,36 @@ emit_pointer_event (ClutterEvent       *event,
     }
 }
 
+static inline void
+emit_crossing_event (ClutterEvent       *event,
+                     ClutterInputDevice *device)
+{
+  ClutterMainContext *context = _clutter_context_get_default ();
+  ClutterEventSequence *sequence = clutter_event_get_event_sequence (event);
+  ClutterActor *grab_actor = NULL;
+
+  if (_clutter_event_process_filters (event))
+    return;
+
+  if (sequence)
+    {
+      if (device->sequence_grab_actors != NULL)
+        grab_actor = g_hash_table_lookup (device->sequence_grab_actors, sequence);
+    }
+  else
+    {
+      if (context->pointer_grab_actor != NULL)
+        grab_actor = context->pointer_grab_actor;
+      else if (device != NULL && device->pointer_grab_actor != NULL)
+        grab_actor = device->pointer_grab_actor;
+    }
+
+  if (grab_actor != NULL)
+    clutter_actor_event (grab_actor, event, FALSE);
+  else
+    emit_event_chain (event);
+}
+
 static inline void
 emit_touch_event (ClutterEvent       *event,
                   ClutterInputDevice *device)
@@ -2177,7 +2207,7 @@ _clutter_process_event_details (ClutterActor        *stage,
           {
             ClutterActor *actor = NULL;
 
-            emit_pointer_event (event, device);
+            emit_crossing_event (event, device);
 
             actor = _clutter_input_device_update (device, NULL, FALSE);
             if (actor != stage)
@@ -2189,12 +2219,12 @@ _clutter_process_event_details (ClutterActor        *stage,
                 crossing->crossing.related = stage;
                 crossing->crossing.source = actor;
 
-                emit_pointer_event (crossing, device);
+                emit_crossing_event (crossing, device);
                 clutter_event_free (crossing);
               }
           }
         else
-          emit_pointer_event (event, device);
+          emit_crossing_event (event, device);
         break;
 
       case CLUTTER_LEAVE:
@@ -2213,10 +2243,10 @@ _clutter_process_event_details (ClutterActor        *stage,
             crossing->crossing.related = stage;
             crossing->crossing.source = device->cursor_actor;
 
-            emit_pointer_event (crossing, device);
+            emit_crossing_event (crossing, device);
             clutter_event_free (crossing);
           }
-        emit_pointer_event (event, device);
+        emit_crossing_event (event, device);
         break;
 
       case CLUTTER_DESTROY_NOTIFY:

clutter/clutter/clutter-paint-nodes.c

@@ -75,8 +75,7 @@ _clutter_paint_node_init_types (void)
   cogl_pipeline_set_color (default_color_pipeline, &cogl_color);
 
   default_texture_pipeline = cogl_pipeline_new (ctx);
-  cogl_pipeline_set_layer_null_texture (default_texture_pipeline, 0,
-                                        COGL_TEXTURE_TYPE_2D);
+  cogl_pipeline_set_layer_null_texture (default_texture_pipeline, 0);
   cogl_pipeline_set_color (default_texture_pipeline, &cogl_color);
   cogl_pipeline_set_layer_wrap_mode (default_texture_pipeline, 0,
                                      COGL_PIPELINE_WRAP_MODE_AUTOMATIC);

clutter/clutter/deprecated/clutter-texture.c

@@ -1277,9 +1277,7 @@ clutter_texture_init (ClutterTexture *self)
 
       texture_template_pipeline = cogl_pipeline_new (ctx);
       pipeline = COGL_PIPELINE (texture_template_pipeline);
-      cogl_pipeline_set_layer_null_texture (pipeline,
-                                            0, /* layer_index */
-                                            COGL_TEXTURE_TYPE_2D);
+      cogl_pipeline_set_layer_null_texture (pipeline, 0);
     }
 
   g_assert (texture_template_pipeline != NULL);

clutter/clutter/evdev/clutter-input-device-evdev.c

@@ -855,6 +855,14 @@ emulate_pointer_motion (ClutterInputDeviceEvdev *device,
   clutter_virtual_input_device_notify_relative_motion (device->mousekeys_virtual_device,
                                                        time_us, dx_motion, dy_motion);
 }
+static gboolean
+is_numlock_active (ClutterInputDeviceEvdev *device)
+{
+  ClutterSeatEvdev *seat = device->seat;
+  return xkb_state_mod_name_is_active (seat->xkb,
+                                       "Mod2",
+                                       XKB_STATE_MODS_LOCKED);
+}
 
 static void
 enable_mousekeys (ClutterInputDeviceEvdev *device)
@@ -1013,6 +1021,10 @@ handle_mousekeys_press (ClutterEvent            *event,
   if (!(event->key.flags & CLUTTER_EVENT_FLAG_SYNTHETIC))
     stop_mousekeys_move (device);
 
+  /* Do not handle mousekeys if NumLock is ON */
+  if (is_numlock_active (device))
+    return FALSE;
+
   /* Button selection */
   switch (event->key.keyval)
     {
@@ -1084,6 +1096,10 @@ static gboolean
 handle_mousekeys_release (ClutterEvent            *event,
                           ClutterInputDeviceEvdev *device)
 {
+  /* Do not handle mousekeys if NumLock is ON */
+  if (is_numlock_active (device))
+    return FALSE;
+
   switch (event->key.keyval)
     {
     case XKB_KEY_KP_0:

clutter/clutter/x11/clutter-backend-x11.c

@@ -54,6 +54,7 @@
 #include "clutter-main.h"
 #include "clutter-private.h"
 #include "clutter-settings-private.h"
+#include "clutter-xkb-a11y-x11.h"
 
 G_DEFINE_TYPE (ClutterBackendX11, clutter_backend_x11, CLUTTER_TYPE_BACKEND)
 
@@ -276,6 +277,20 @@ clutter_backend_x11_create_device_manager (ClutterBackendX11 *backend_x11)
   _clutter_backend_add_event_translator (backend, translator);
 }
 
+static void
+on_keymap_state_change (ClutterKeymapX11 *keymap_x11,
+                        gpointer          data)
+{
+  ClutterDeviceManager *device_manager = CLUTTER_DEVICE_MANAGER (data);
+  ClutterKbdA11ySettings kbd_a11y_settings;
+
+  /* On keymaps state change, just reapply the current settings, it'll
+   * take care of enabling/disabling mousekeys based on NumLock state.
+   */
+  clutter_device_manager_get_kbd_a11y_settings (device_manager, &kbd_a11y_settings);
+  clutter_device_manager_x11_apply_kbd_a11y_settings (device_manager, &kbd_a11y_settings);
+}
+
 static void
 clutter_backend_x11_create_keymap (ClutterBackendX11 *backend_x11)
 {
@@ -292,6 +307,11 @@ clutter_backend_x11_create_keymap (ClutterBackendX11 *backend_x11)
       backend = CLUTTER_BACKEND (backend_x11);
       translator = CLUTTER_EVENT_TRANSLATOR (backend_x11->keymap);
       _clutter_backend_add_event_translator (backend, translator);
+
+      g_signal_connect (backend_x11->keymap,
+                        "state-changed",
+                        G_CALLBACK (on_keymap_state_change),
+                        backend->device_manager);
     }
 }
 

clutter/clutter/x11/clutter-xkb-a11y-x11.c

@@ -241,8 +241,13 @@ clutter_device_manager_x11_apply_kbd_a11y_settings (ClutterDeviceManager   *devi
     }
 
   /* mouse keys */
-  if (set_xkb_ctrl (desc, kbd_a11y_settings->controls,
-                    CLUTTER_A11Y_MOUSE_KEYS_ENABLED, XkbMouseKeysMask | XkbMouseKeysAccelMask))
+  if (clutter_keymap_get_num_lock_state (CLUTTER_KEYMAP (backend_x11->keymap)))
+    {
+      /* Disable mousekeys when NumLock is ON */
+      desc->ctrls->enabled_ctrls &= ~(XkbMouseKeysMask | XkbMouseKeysAccelMask);
+    }
+  else if (set_xkb_ctrl (desc, kbd_a11y_settings->controls,
+                         CLUTTER_A11Y_MOUSE_KEYS_ENABLED, XkbMouseKeysMask | XkbMouseKeysAccelMask))
     {
       gint mk_max_speed;
       gint mk_accel_time;

clutter/meson.build

@@ -1,7 +1,5 @@
 clutter_includesubdir = join_paths(pkgname, 'clutter')
 clutter_includedir = join_paths(includedir, clutter_includesubdir)
-clutter_srcdir = join_paths(top_srcdir, 'clutter')
-clutter_builddir = join_paths(builddir, 'clutter')
 
 clutter_includepath = include_directories('.', 'clutter')
 clutter_includes = [clutter_includepath, cogl_includepath]

clutter/tests/conform/meson.build

@@ -1,6 +1,3 @@
-clutter_tests_conform_srcdir = join_paths(clutter_srcdir, 'tests/conform')
-clutter_tests_conform_builddir = join_paths(clutter_builddir, 'tests/conform')
-
 clutter_tests_conform_c_args = [
   '-DG_LOG_DOMAIN="Clutter-Conform"',
   '-DCOGL_DISABLE_DEPRECATION_WARNINGS',
@@ -52,8 +49,8 @@ clutter_conform_tests += clutter_conform_tests_general_tests
 clutter_conform_tests += clutter_conform_tests_deprecated_tests
 
 test_env = environment()
-test_env.set('G_TEST_SRCDIR', clutter_tests_conform_srcdir)
-test_env.set('G_TEST_BUILDDIR', clutter_tests_conform_builddir)
+test_env.set('G_TEST_SRCDIR', meson.current_source_dir())
+test_env.set('G_TEST_BUILDDIR', meson.current_build_dir())
 test_env.set('G_ENABLE_DIAGNOSTIC', '0')
 test_env.set('CLUTTER_ENABLE_DIAGNOSTIC', '0')
 test_env.set('CLUTTER_SCALE', '1')
@@ -74,7 +71,8 @@ foreach test : clutter_conform_tests
     install: false,
   )
 
-  test('clutter/conform/@0@'.format(test), test_executable,
+  test(test, test_executable,
+    suite: ['clutter', 'clutter/conform'],
     env: test_env
   )
 endforeach

clutter/tests/interactive/meson.build

@@ -1,7 +1,5 @@
-clutter_tests_interactive_srcdir = join_paths(clutter_srcdir, 'tests/interactive')
-
+clutter_tests_interactive_srcdir = meson.current_source_dir()
 clutter_tests_interactive_includepath = include_directories('.')
-#clutter_tests_interactive_builddir = join_paths(clutter_builddir, 'tests/interactive')
 
 clutter_tests_interactive_c_args = [
   '-DTESTS_DATADIR="@0@"'.format(clutter_tests_interactive_srcdir),
@@ -31,7 +29,6 @@ clutter_tests_interactive_test_sources = [
   'test-fbo.c',
   'test-cogl-tex-tile.c',
   'test-cogl-tex-convert.c',
-  'test-cogl-tex-foreign.c',
   'test-cogl-offscreen.c',
   'test-cogl-tex-polygon.c',
   'test-cogl-multitexture.c',

clutter/tests/interactive/test-cogl-tex-foreign.c

@@ -1,276 +0,0 @@
-#include <glib.h>
-#include <gmodule.h>
-#include <stdlib.h>
-#include <clutter/clutter.h>
-#include <cogl/cogl.h>
-
-#ifndef GL_UNPACK_ALIGNMENT
-#define GL_UNPACK_ALIGNMENT 0x0CF5
-#endif
-#ifndef GL_TEXTURE_BINDING_2D
-#define GL_TEXTURE_BINDING_2D 0x8069
-#endif
-#ifndef GL_TEXTURE_2D
-#define GL_TEXTURE_2D 0x0DE1
-#endif
-#ifndef GL_RGB
-#define GL_RGB 0x1907
-#endif
-#ifndef GL_UNSIGNED_BYTE
-#define GL_UNSIGNED_BYTE 0x1401
-#endif
-#ifndef GL_TEXTURE_MAG_FILTER
-#define GL_TEXTURE_MAG_FILTER 0x2800
-#endif
-#ifndef GL_LINEAR
-#define GL_LINEAR 0x1208
-#endif
-#ifndef GL_TEXTURE_MIN_FILTER
-#define GL_TEXTURE_MIN_FILTER 0x2801
-#endif
-
-/* Coglbox declaration
- *--------------------------------------------------*/
-
-G_BEGIN_DECLS
-  
-#define TEST_TYPE_COGLBOX test_coglbox_get_type()
-
-#define TEST_COGLBOX(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
-  TEST_TYPE_COGLBOX, TestCoglboxClass))
-
-#define TEST_COGLBOX_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST ((klass), \
-  TEST_TYPE_COGLBOX, TestCoglboxClass))
-
-#define TEST_IS_COGLBOX(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
-  TEST_TYPE_COGLBOX))
-
-#define TEST_IS_COGLBOX_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
-  TEST_TYPE_COGLBOX))
-
-#define TEST_COGLBOX_GET_CLASS(obj) \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
-  TEST_TYPE_COGLBOX, TestCoglboxClass))
-
-typedef struct _TestCoglbox        TestCoglbox;
-typedef struct _TestCoglboxClass   TestCoglboxClass;
-typedef struct _TestCoglboxPrivate TestCoglboxPrivate;
-
-const char *
-test_cogl_tex_foreign_describe (void);
-
-struct _TestCoglbox
-{
-  ClutterActor           parent;
-
-  /*< private >*/
-  TestCoglboxPrivate *priv;
-};
-
-struct _TestCoglboxClass 
-{
-  ClutterActorClass parent_class;
-
-  /* padding for future expansion */
-  void (*_test_coglbox1) (void);
-  void (*_test_coglbox2) (void);
-  void (*_test_coglbox3) (void);
-  void (*_test_coglbox4) (void);
-};
-
-static GType test_coglbox_get_type (void) G_GNUC_CONST;
-
-G_END_DECLS
-
-/* Coglbox private declaration
- *--------------------------------------------------*/
-
-struct _TestCoglboxPrivate
-{
-  guint      gl_handle;
-  CoglHandle cogl_handle;
-
-  void
-  (* glGetIntegerv) (guint pname, int *params);
-  void
-  (* glPixelStorei) (guint pname, int param);
-  void
-  (* glTexParameteri) (guint target, guint pname, int param);
-  void
-  (* glTexImage2D) (guint target, int level,
-                    int internalFormat,
-                    int width, int height,
-                    int border, guint format, guint type,
-                    const void *pixels);
-  void
-  (* glGenTextures) (int n, guint *textures);
-  void
-  (* glDeleteTextures) (int n, const guint *textures);
-  void
-  (* glBindTexture) (guint target, guint texture);
-};
-
-G_DEFINE_TYPE_WITH_PRIVATE (TestCoglbox, test_coglbox, CLUTTER_TYPE_ACTOR);
-
-#define TEST_COGLBOX_GET_PRIVATE(obj) \
-(G_TYPE_INSTANCE_GET_PRIVATE ((obj), TEST_TYPE_COGLBOX, TestCoglboxPrivate))
-
-int
-test_cogl_tex_foreign_main (int argc, char *argv[]);
-
-/* Coglbox implementation
- *--------------------------------------------------*/
-
-static void
-test_coglbox_paint(ClutterActor *self)
-{
-  TestCoglboxPrivate *priv = TEST_COGLBOX_GET_PRIVATE (self);
-  gfloat texcoords[4] = { 0.3f, 0.3f, 0.7f, 0.7f };
-  
-  cogl_set_source_color4ub (0x66, 0x66, 0xdd, 0xff);
-  cogl_rectangle (0,0,400,400);
-  
-  cogl_push_matrix ();
-  
-  cogl_translate (100,100,0);
-  cogl_set_source_texture (priv->cogl_handle);
-  cogl_rectangle_with_texture_coords (0, 0, 200, 200,
-                                      texcoords[0], texcoords[1],
-                                      texcoords[2], texcoords[3]);
-  
-  cogl_pop_matrix();
-}
-
-static void
-test_coglbox_finalize (GObject *object)
-{
-  G_OBJECT_CLASS (test_coglbox_parent_class)->finalize (object);
-}
-
-static void
-test_coglbox_dispose (GObject *object)
-{
-  TestCoglboxPrivate *priv;
-  
-  priv = TEST_COGLBOX_GET_PRIVATE (object);
-  
-  cogl_handle_unref (priv->cogl_handle);
-  priv->glDeleteTextures (1, &priv->gl_handle);
-  
-  G_OBJECT_CLASS (test_coglbox_parent_class)->dispose (object);
-}
-
-static void
-test_coglbox_init (TestCoglbox *self)
-{
-  TestCoglboxPrivate *priv;
-  guchar              data[12];
-  int prev_unpack_alignment;
-  int prev_2d_texture_binding;
-  
-  self->priv = priv = TEST_COGLBOX_GET_PRIVATE(self);
-  
-  /* Prepare a 2x2 pixels texture */
-  
-  data[0] = 255; data[1]  =   0; data[2]  =   0;
-  data[3] =   0; data[4]  = 255; data[5]  =   0;
-  data[6] =   0; data[7]  =   0; data[8]  = 255;
-  data[9] =   0; data[10] =   0; data[11] =   0;
-
-  priv->glGetIntegerv = (void *) cogl_get_proc_address ("glGetIntegerv");
-  priv->glPixelStorei = (void *) cogl_get_proc_address ("glPixelStorei");
-  priv->glTexParameteri = (void *) cogl_get_proc_address ("glTexParameteri");
-  priv->glTexImage2D = (void *) cogl_get_proc_address ("glTexImage2D");
-  priv->glGenTextures = (void *) cogl_get_proc_address ("glGenTextures");
-  priv->glDeleteTextures = (void *) cogl_get_proc_address ("glDeleteTextures");
-  priv->glBindTexture = (void *) cogl_get_proc_address ("glBindTexture");
-
-  /* We are about to use OpenGL directly to create a TEXTURE_2D
-   * texture so we need to save the state that we modify so we can
-   * restore it afterwards and be sure not to interfere with any state
-   * caching that Cogl may do internally.
-   */
-  priv->glGetIntegerv (GL_UNPACK_ALIGNMENT, &prev_unpack_alignment);
-  priv->glGetIntegerv (GL_TEXTURE_BINDING_2D, &prev_2d_texture_binding);
-
-  priv->glGenTextures (1, &priv->gl_handle);
-  priv->glBindTexture (GL_TEXTURE_2D, priv->gl_handle);
-  
-  priv->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
-  priv->glTexImage2D (GL_TEXTURE_2D, 0, GL_RGB,
-		2, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
-
-  /* Now restore the original GL state as Cogl had left it */
-  priv->glPixelStorei (GL_UNPACK_ALIGNMENT, prev_unpack_alignment);
-  priv->glBindTexture (GL_TEXTURE_2D, prev_2d_texture_binding);
-  
-  priv->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  priv->glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  
-  /* Create texture from foreign */
-  
-  priv->cogl_handle =
-    cogl_texture_new_from_foreign (priv->gl_handle,
-				   GL_TEXTURE_2D,
-				   2, 2, 0, 0,
-				   COGL_PIXEL_FORMAT_RGB_888);
-  
-  if (priv->cogl_handle == COGL_INVALID_HANDLE)
-    {
-      printf ("Failed creating texture from foreign!\n");
-      return;
-    }
-}
-
-static void
-test_coglbox_class_init (TestCoglboxClass *klass)
-{
-  GObjectClass      *gobject_class = G_OBJECT_CLASS (klass);
-  ClutterActorClass *actor_class   = CLUTTER_ACTOR_CLASS (klass);
-
-  gobject_class->finalize     = test_coglbox_finalize;
-  gobject_class->dispose      = test_coglbox_dispose;  
-  actor_class->paint          = test_coglbox_paint;
-}
-
-static ClutterActor*
-test_coglbox_new (void)
-{
-  return g_object_new (TEST_TYPE_COGLBOX, NULL);
-}
-
-G_MODULE_EXPORT int
-test_cogl_tex_foreign_main (int argc, char *argv[])
-{
-  ClutterActor     *stage;
-  ClutterActor     *coglbox;
-  
-  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
-    return 1;
-  
-  /* Stage */
-  stage = clutter_stage_new ();
-  clutter_actor_set_size (stage, 400, 400);
-  clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl Foreign Textures");
-  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
-
-  /* Cogl Box */
-  coglbox = test_coglbox_new ();
-  clutter_container_add_actor (CLUTTER_CONTAINER (stage), coglbox);
-  
-  clutter_actor_show_all (stage);
-  
-  clutter_main ();
-  
-  return 0;
-}
-
-G_MODULE_EXPORT const char *
-test_cogl_tex_foreign_describe (void)
-{
-  return "Foreign textures support in Cogl.";
-}

clutter/tests/performance/meson.build

@@ -1,5 +1,5 @@
 clutter_tests_performance_c_args = [
-  '-DTESTS_DATA_DIR="@0@"'.format(join_paths(clutter_srcdir, 'tests/interactive')),
+  '-DTESTS_DATA_DIR="@0@"'.format(clutter_tests_interactive_srcdir),
   '-DG_DISABLE_SINGLE_INCLUDES',
   '-DGLIB_DISABLE_DEPRECATION_WARNINGS',
   '-DCOGL_DISABLE_DEPRECATION_WARNINGS',

cogl/cogl/cogl-atlas-texture.c

@@ -1013,12 +1013,6 @@ _cogl_atlas_texture_remove_reorganize_callback (CoglContext *ctx,
     g_hook_destroy_link (&ctx->atlas_reorganize_callbacks, hook);
 }
 
-static CoglTextureType
-_cogl_atlas_texture_get_type (CoglTexture *tex)
-{
-  return COGL_TEXTURE_TYPE_2D;
-}
-
 static const CoglTextureVtable
 cogl_atlas_texture_vtable =
   {
@@ -1040,7 +1034,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_type,
     NULL, /* is_foreign */
     NULL /* set_auto_mipmap */
   };

cogl/cogl/cogl-atlas.c

@@ -562,29 +562,21 @@ create_migration_texture (CoglContext *ctx,
   CoglTexture *tex;
   CoglError *skip_error = NULL;
 
-  if ((_cogl_util_is_pot (width) && _cogl_util_is_pot (height)) ||
-      (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC) &&
-       cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP)))
+  /* First try creating a fast-path non-sliced texture */
+  tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, width, height));
+
+  _cogl_texture_set_internal_format (tex, internal_format);
+
+  /* TODO: instead of allocating storage here it would be better
+   * if we had some api that let us just check that the size is
+   * supported by the hardware so storage could be allocated
+   * lazily when uploading data. */
+  if (!cogl_texture_allocate (tex, &skip_error))
     {
-      /* First try creating a fast-path non-sliced texture */
-      tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx,
-                                                         width, height));
-
-      _cogl_texture_set_internal_format (tex, internal_format);
-
-      /* TODO: instead of allocating storage here it would be better
-       * if we had some api that let us just check that the size is
-       * supported by the hardware so storage could be allocated
-       * lazily when uploading data. */
-      if (!cogl_texture_allocate (tex, &skip_error))
-        {
-          cogl_error_free (skip_error);
-          cogl_object_unref (tex);
-          tex = NULL;
-        }
+      cogl_error_free (skip_error);
+      cogl_object_unref (tex);
+      tex = NULL;
     }
-  else
-    tex = NULL;
 
   if (!tex)
     {

cogl/cogl/cogl-context-private.h

@@ -50,8 +50,6 @@
 #include "cogl-texture-driver.h"
 #include "cogl-pipeline-cache.h"
 #include "cogl-texture-2d.h"
-#include "cogl-texture-3d.h"
-#include "cogl-texture-rectangle.h"
 #include "cogl-sampler-cache-private.h"
 #include "cogl-gpu-info-private.h"
 #include "cogl-gl-header.h"
@@ -103,9 +101,6 @@ struct _CoglContext
   unsigned long private_features
     [COGL_FLAGS_N_LONGS_FOR_SIZE (COGL_N_PRIVATE_FEATURES)];
 
-  gboolean needs_viewport_scissor_workaround;
-  CoglFramebuffer *viewport_scissor_workaround_framebuffer;
-
   CoglPipeline *default_pipeline;
   CoglPipelineLayer *default_layer_0;
   CoglPipelineLayer *default_layer_n;
@@ -169,8 +164,6 @@ struct _CoglContext
 
   /* Textures */
   CoglTexture2D *default_gl_texture_2d_tex;
-  CoglTexture3D *default_gl_texture_3d_tex;
-  CoglTextureRectangle *default_gl_texture_rect_tex;
 
   /* Central list of all framebuffers so all journals can be flushed
    * at any time. */
@@ -269,7 +262,6 @@ struct _CoglContext
   GLuint                  current_gl_program;
 
   gboolean current_gl_dither_enabled;
-  CoglColorMask current_gl_color_mask;
   GLenum current_gl_draw_buffer;
 
   /* Clipping */
@@ -301,8 +293,6 @@ struct _CoglContext
   gboolean          buffer_map_fallback_in_use;
   size_t            buffer_map_fallback_offset;
 
-  CoglWinsysRectangleState rectangle_state;
-
   CoglSamplerCache *sampler_cache;
 
   /* FIXME: remove these when we remove the last xlib based clutter

cogl/cogl/cogl-context.c

@@ -40,8 +40,6 @@
 #include "cogl-journal-private.h"
 #include "cogl-texture-private.h"
 #include "cogl-texture-2d-private.h"
-#include "cogl-texture-3d-private.h"
-#include "cogl-texture-rectangle-private.h"
 #include "cogl-pipeline-private.h"
 #include "cogl-framebuffer-private.h"
 #include "cogl-onscreen-private.h"
@@ -106,30 +104,6 @@ _cogl_init_feature_overrides (CoglContext *ctx)
 
   if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_PBOS)))
     COGL_FLAGS_SET (ctx->private_features, COGL_PRIVATE_FEATURE_PBOS, FALSE);
-
-  if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_GLSL)))
-    {
-      ctx->feature_flags &= ~COGL_FEATURE_SHADERS_GLSL;
-      COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_GLSL, FALSE);
-      COGL_FLAGS_SET (ctx->features,
-                      COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE,
-                      FALSE);
-    }
-
-  if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_NPOT_TEXTURES)))
-    {
-      ctx->feature_flags &= ~(COGL_FEATURE_TEXTURE_NPOT |
-                              COGL_FEATURE_TEXTURE_NPOT_BASIC |
-                              COGL_FEATURE_TEXTURE_NPOT_MIPMAP |
-                              COGL_FEATURE_TEXTURE_NPOT_REPEAT);
-      COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_TEXTURE_NPOT, FALSE);
-      COGL_FLAGS_SET (ctx->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, FALSE);
-      COGL_FLAGS_SET (ctx->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, FALSE);
-      COGL_FLAGS_SET (ctx->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT, FALSE);
-    }
 }
 
 const CoglWinsysVtable *
@@ -153,10 +127,8 @@ cogl_context_new (CoglDisplay *display,
 {
   CoglContext *context;
   uint8_t white_pixel[] = { 0xff, 0xff, 0xff, 0xff };
-  CoglBitmap *white_pixel_bitmap;
   const CoglWinsysVtable *winsys;
   int i;
-  CoglError *internal_error = NULL;
 
   _cogl_init ();
 
@@ -197,9 +169,6 @@ cogl_context_new (CoglDisplay *display,
   memset (context->features, 0, sizeof (context->features));
   context->feature_flags = 0;
   memset (context->private_features, 0, sizeof (context->private_features));
-
-  context->rectangle_state = COGL_WINSYS_RECTANGLE_STATE_UNKNOWN;
-
   memset (context->winsys_features, 0, sizeof (context->winsys_features));
 
   if (!display)
@@ -265,22 +234,6 @@ cogl_context_new (CoglDisplay *display,
   /* Initialise the driver specific state */
   _cogl_init_feature_overrides (context);
 
-  /* XXX: ONGOING BUG: Intel viewport scissor
-   *
-   * Intel gen6 drivers don't currently correctly handle offset
-   * viewports, since primitives aren't clipped within the bounds of
-   * the viewport.  To workaround this we push our own clip for the
-   * viewport that will use scissoring to ensure we clip as expected.
-   *
-   * TODO: file a bug upstream!
-   */
-  if (context->gpu.driver_package == COGL_GPU_INFO_DRIVER_PACKAGE_MESA &&
-      context->gpu.architecture == COGL_GPU_INFO_ARCHITECTURE_SANDYBRIDGE &&
-      !getenv ("COGL_DISABLE_INTEL_VIEWPORT_SCISSORT_WORKAROUND"))
-    context->needs_viewport_scissor_workaround = TRUE;
-  else
-    context->needs_viewport_scissor_workaround = FALSE;
-
   context->sampler_cache = _cogl_sampler_cache_new (context);
 
   _cogl_pipeline_init_default_pipeline ();
@@ -323,8 +276,6 @@ cogl_context_new (CoglDisplay *display,
   context->legacy_state_set = 0;
 
   context->default_gl_texture_2d_tex = NULL;
-  context->default_gl_texture_3d_tex = NULL;
-  context->default_gl_texture_rect_tex = NULL;
 
   context->framebuffers = NULL;
   context->current_draw_buffer = NULL;
@@ -366,7 +317,6 @@ cogl_context_new (CoglDisplay *display,
   context->current_gl_program = 0;
 
   context->current_gl_dither_enabled = TRUE;
-  context->current_gl_color_mask = COGL_COLOR_MASK_ALL;
 
   context->gl_blend_enable_cache = FALSE;
 
@@ -453,41 +403,6 @@ cogl_context_new (CoglDisplay *display,
                                    white_pixel,
                                    NULL); /* abort on error */
 
-  /* If 3D or rectangle textures aren't supported then these will
-   * return errors that we can simply ignore. */
-  internal_error = NULL;
-  context->default_gl_texture_3d_tex =
-    cogl_texture_3d_new_from_data (context,
-                                   1, 1, 1, /* width, height, depth */
-                                   COGL_PIXEL_FORMAT_RGBA_8888_PRE,
-                                   0, /* rowstride */
-                                   0, /* image stride */
-                                   white_pixel,
-                                   &internal_error);
-  if (internal_error)
-    cogl_error_free (internal_error);
-
-  /* TODO: add cogl_texture_rectangle_new_from_data() */
-  white_pixel_bitmap =
-    cogl_bitmap_new_for_data (context,
-                              1, 1, /* width/height */
-                              COGL_PIXEL_FORMAT_RGBA_8888_PRE,
-                              4, /* rowstride */
-                              white_pixel);
-
-  internal_error = NULL;
-  context->default_gl_texture_rect_tex =
-    cogl_texture_rectangle_new_from_bitmap (white_pixel_bitmap);
-
-  /* XXX: we need to allocate the texture now because the white_pixel
-   * data is on the stack */
-  cogl_texture_allocate (COGL_TEXTURE (context->default_gl_texture_rect_tex),
-                         &internal_error);
-  if (internal_error)
-    cogl_error_free (internal_error);
-
-  cogl_object_unref (white_pixel_bitmap);
-
   cogl_push_source (context->opaque_color_pipeline);
 
   context->atlases = NULL;
@@ -526,10 +441,6 @@ _cogl_context_free (CoglContext *context)
 
   if (context->default_gl_texture_2d_tex)
     cogl_object_unref (context->default_gl_texture_2d_tex);
-  if (context->default_gl_texture_3d_tex)
-    cogl_object_unref (context->default_gl_texture_3d_tex);
-  if (context->default_gl_texture_rect_tex)
-    cogl_object_unref (context->default_gl_texture_rect_tex);
 
   if (context->opaque_color_pipeline)
     cogl_object_unref (context->opaque_color_pipeline);

cogl/cogl/cogl-context.h

@@ -174,33 +174,14 @@ cogl_is_context (void *object);
  * experimental since it's only useable with experimental API... */
 /**
  * CoglFeatureID:
- * @COGL_FEATURE_ID_TEXTURE_NPOT_BASIC: The hardware supports non power
- *     of two textures, but you also need to check the
- *     %COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP and %COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT
- *     features to know if the hardware supports npot texture mipmaps
- *     or repeat modes other than
- *     %COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE respectively.
- * @COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP: Mipmapping is supported in
- *     conjuntion with non power of two textures.
- * @COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT: Repeat modes other than
- *     %COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE are supported by the
- *     hardware.
- * @COGL_FEATURE_ID_TEXTURE_NPOT: Non power of two textures are supported
- *    by the hardware. This is a equivalent to the
- *    %COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, %COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP
- *    and %COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT features combined.
- * @COGL_FEATURE_ID_TEXTURE_RECTANGLE: Support for rectangular
- *    textures with non-normalized texture coordinates.
  * @COGL_FEATURE_ID_TEXTURE_RG: Support for
  *    %COGL_TEXTURE_COMPONENTS_RG as the internal components of a
  *    texture.
- * @COGL_FEATURE_ID_TEXTURE_3D: 3D texture support
  * @COGL_FEATURE_ID_OFFSCREEN: Offscreen rendering support
  * @COGL_FEATURE_ID_OFFSCREEN_MULTISAMPLE: Multisample support for
  *    offscreen framebuffers
  * @COGL_FEATURE_ID_ONSCREEN_MULTIPLE: Multiple onscreen framebuffers
  *    supported.
- * @COGL_FEATURE_ID_GLSL: GLSL support
  * @COGL_FEATURE_ID_UNSIGNED_INT_INDICES: Set if
  *     %COGL_INDICES_TYPE_UNSIGNED_INT is supported in
  *     cogl_indices_new().
@@ -236,13 +217,6 @@ cogl_is_context (void *object);
  */
 typedef enum _CoglFeatureID
 {
-  COGL_FEATURE_ID_TEXTURE_NPOT_BASIC = 1,
-  COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP,
-  COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT,
-  COGL_FEATURE_ID_TEXTURE_NPOT,
-  COGL_FEATURE_ID_TEXTURE_RECTANGLE,
-  COGL_FEATURE_ID_TEXTURE_3D,
-  COGL_FEATURE_ID_GLSL,
   COGL_FEATURE_ID_OFFSCREEN,
   COGL_FEATURE_ID_OFFSCREEN_MULTISAMPLE,
   COGL_FEATURE_ID_ONSCREEN_MULTIPLE,

cogl/cogl/cogl-debug-options.h

@@ -130,22 +130,11 @@ OPT (DISABLE_TEXTURING,
      "disable-texturing",
      N_("Disable texturing"),
      N_("Disable texturing any primitives"))
-OPT (DISABLE_GLSL,
-     N_("Root Cause"),
-     "disable-glsl",
-     N_("Disable GLSL"),
-     N_("Disable use of GLSL"))
 OPT (DISABLE_BLENDING,
      N_("Root Cause"),
      "disable-blending",
      N_("Disable blending"),
      N_("Disable use of blending"))
-OPT (DISABLE_NPOT_TEXTURES,
-     N_("Root Cause"),
-     "disable-npot-textures",
-     N_("Disable non-power-of-two textures"),
-     N_("Makes Cogl think that the GL driver doesn't support NPOT textures "
-        "so that it will create sliced textures or textures with waste instead."))
 OPT (DISABLE_SOFTWARE_CLIP,
      N_("Root Cause"),
      "disable-software-clip",

cogl/cogl/cogl-debug.c

@@ -77,9 +77,7 @@ static const GDebugKey cogl_behavioural_debug_keys[] = {
   { "disable-atlas", COGL_DEBUG_DISABLE_ATLAS },
   { "disable-shared-atlas", COGL_DEBUG_DISABLE_SHARED_ATLAS },
   { "disable-texturing", COGL_DEBUG_DISABLE_TEXTURING},
-  { "disable-glsl", COGL_DEBUG_DISABLE_GLSL},
   { "disable-blending", COGL_DEBUG_DISABLE_BLENDING},
-  { "disable-npot-textures", COGL_DEBUG_DISABLE_NPOT_TEXTURES},
   { "wireframe", COGL_DEBUG_WIREFRAME},
   { "disable-software-clip", COGL_DEBUG_DISABLE_SOFTWARE_CLIP},
   { "disable-program-caches", COGL_DEBUG_DISABLE_PROGRAM_CACHES},

cogl/cogl/cogl-debug.h

@@ -61,12 +61,10 @@ typedef enum
   COGL_DEBUG_DISABLE_SHARED_ATLAS,
   COGL_DEBUG_OPENGL,
   COGL_DEBUG_DISABLE_TEXTURING,
-  COGL_DEBUG_DISABLE_GLSL,
   COGL_DEBUG_SHOW_SOURCE,
   COGL_DEBUG_DISABLE_BLENDING,
   COGL_DEBUG_TEXTURE_PIXMAP,
   COGL_DEBUG_BITMAP,
-  COGL_DEBUG_DISABLE_NPOT_TEXTURES,
   COGL_DEBUG_WIREFRAME,
   COGL_DEBUG_DISABLE_SOFTWARE_CLIP,
   COGL_DEBUG_DISABLE_PROGRAM_CACHES,

cogl/cogl/cogl-framebuffer-private.h

@@ -83,11 +83,10 @@ typedef enum _CoglFramebufferStateIndex
   COGL_FRAMEBUFFER_STATE_INDEX_DITHER             = 3,
   COGL_FRAMEBUFFER_STATE_INDEX_MODELVIEW          = 4,
   COGL_FRAMEBUFFER_STATE_INDEX_PROJECTION         = 5,
-  COGL_FRAMEBUFFER_STATE_INDEX_COLOR_MASK         = 6,
-  COGL_FRAMEBUFFER_STATE_INDEX_FRONT_FACE_WINDING = 7,
-  COGL_FRAMEBUFFER_STATE_INDEX_DEPTH_WRITE        = 8,
-  COGL_FRAMEBUFFER_STATE_INDEX_STEREO_MODE        = 9,
-  COGL_FRAMEBUFFER_STATE_INDEX_MAX                = 10
+  COGL_FRAMEBUFFER_STATE_INDEX_FRONT_FACE_WINDING = 6,
+  COGL_FRAMEBUFFER_STATE_INDEX_DEPTH_WRITE        = 7,
+  COGL_FRAMEBUFFER_STATE_INDEX_STEREO_MODE        = 8,
+  COGL_FRAMEBUFFER_STATE_INDEX_MAX                = 9
 } CoglFramebufferStateIndex;
 
 typedef enum _CoglFramebufferState
@@ -98,10 +97,9 @@ typedef enum _CoglFramebufferState
   COGL_FRAMEBUFFER_STATE_DITHER             = 1<<3,
   COGL_FRAMEBUFFER_STATE_MODELVIEW          = 1<<4,
   COGL_FRAMEBUFFER_STATE_PROJECTION         = 1<<5,
-  COGL_FRAMEBUFFER_STATE_COLOR_MASK         = 1<<6,
-  COGL_FRAMEBUFFER_STATE_FRONT_FACE_WINDING = 1<<7,
-  COGL_FRAMEBUFFER_STATE_DEPTH_WRITE        = 1<<8,
-  COGL_FRAMEBUFFER_STATE_STEREO_MODE        = 1<<9
+  COGL_FRAMEBUFFER_STATE_FRONT_FACE_WINDING = 1<<6,
+  COGL_FRAMEBUFFER_STATE_DEPTH_WRITE        = 1<<7,
+  COGL_FRAMEBUFFER_STATE_STEREO_MODE        = 1<<8
 } CoglFramebufferState;
 
 #define COGL_FRAMEBUFFER_STATE_ALL ((1<<COGL_FRAMEBUFFER_STATE_INDEX_MAX) - 1)
@@ -155,7 +153,6 @@ struct _CoglFramebuffer
 
   gboolean            dither_enabled;
   gboolean            depth_writing_enabled;
-  CoglColorMask       color_mask;
   CoglStereoMode      stereo_mode;
 
   /* We journal the textured rectangles we want to submit to OpenGL so

cogl/cogl/cogl-framebuffer.c

@@ -123,8 +123,6 @@ _cogl_framebuffer_init (CoglFramebuffer *framebuffer,
 
   framebuffer->dirty_bitmasks = TRUE;
 
-  framebuffer->color_mask = COGL_COLOR_MASK_ALL;
-
   framebuffer->samples_per_pixel = 0;
 
   framebuffer->clip_stack = NULL;
@@ -191,9 +189,6 @@ _cogl_framebuffer_free (CoglFramebuffer *framebuffer)
 
   cogl_object_unref (framebuffer->journal);
 
-  if (ctx->viewport_scissor_workaround_framebuffer == framebuffer)
-    ctx->viewport_scissor_workaround_framebuffer = NULL;
-
   ctx->framebuffers = g_list_remove (ctx->framebuffers, framebuffer);
 
   if (ctx->current_draw_buffer == framebuffer)
@@ -260,13 +255,11 @@ cogl_framebuffer_clear4f (CoglFramebuffer *framebuffer,
                           float blue,
                           float alpha)
 {
-  CoglContext *ctx = framebuffer->context;
   CoglClipStack *clip_stack = _cogl_framebuffer_get_clip_stack (framebuffer);
   int scissor_x0;
   int scissor_y0;
   int scissor_x1;
   int scissor_y1;
-  gboolean saved_viewport_scissor_workaround;
 
   if (!framebuffer->depth_buffer_clear_needed &&
       (buffers & COGL_BUFFER_BIT_DEPTH))
@@ -361,31 +354,6 @@ cogl_framebuffer_clear4f (CoglFramebuffer *framebuffer,
 
   _cogl_framebuffer_flush_journal (framebuffer);
 
-  /* XXX: ONGOING BUG: Intel viewport scissor
-   *
-   * The semantics of cogl_framebuffer_clear() are that it should not
-   * be affected by the current viewport and so if we are currently
-   * applying a workaround for viewport scissoring we need to
-   * temporarily disable the workaround before clearing so any
-   * special scissoring for the workaround will be removed first.
-   *
-   * Note: we only need to disable the workaround if the current
-   * viewport doesn't match the framebuffer's size since otherwise
-   * the workaround wont affect clearing anyway.
-   */
-  if (ctx->needs_viewport_scissor_workaround &&
-      (framebuffer->viewport_x != 0 ||
-       framebuffer->viewport_y != 0 ||
-       framebuffer->viewport_width != framebuffer->width ||
-       framebuffer->viewport_height != framebuffer->height))
-    {
-      saved_viewport_scissor_workaround = TRUE;
-      ctx->needs_viewport_scissor_workaround = FALSE;
-      ctx->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_CLIP;
-    }
-  else
-    saved_viewport_scissor_workaround = FALSE;
-
   /* NB: _cogl_framebuffer_flush_state may disrupt various state (such
    * as the pipeline state) when flushing the clip stack, so should
    * always be done first when preparing to draw. */
@@ -395,16 +363,6 @@ cogl_framebuffer_clear4f (CoglFramebuffer *framebuffer,
   _cogl_framebuffer_clear_without_flush4f (framebuffer, buffers,
                                            red, green, blue, alpha);
 
-  /* XXX: ONGOING BUG: Intel viewport scissor
-   *
-   * See comment about temporarily disabling this workaround above
-   */
-  if (saved_viewport_scissor_workaround)
-    {
-      ctx->needs_viewport_scissor_workaround = TRUE;
-      ctx->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_CLIP;
-    }
-
   /* This is a debugging variable used to visually display the quad
    * batches from the journal. It is reset here to increase the
    * chances of getting the same colours for each frame during an
@@ -552,12 +510,7 @@ cogl_framebuffer_set_viewport (CoglFramebuffer *framebuffer,
   framebuffer->viewport_age++;
 
   if (context->current_draw_buffer == framebuffer)
-    {
-      context->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_VIEWPORT;
-
-      if (context->needs_viewport_scissor_workaround)
-        context->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_CLIP;
-    }
+    context->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_VIEWPORT;
 }
 
 float
@@ -831,27 +784,7 @@ _cogl_framebuffer_compare_viewport_state (CoglFramebuffer *a,
       /* NB: we render upside down to offscreen framebuffers and that
        * can affect how we setup the GL viewport... */
       a->type != b->type)
-    {
-      unsigned long differences = COGL_FRAMEBUFFER_STATE_VIEWPORT;
-      CoglContext *context = a->context;
-
-      /* XXX: ONGOING BUG: Intel viewport scissor
-       *
-       * Intel gen6 drivers don't currently correctly handle offset
-       * viewports, since primitives aren't clipped within the bounds of
-       * the viewport.  To workaround this we push our own clip for the
-       * viewport that will use scissoring to ensure we clip as expected.
-       *
-       * This workaround implies that a change in viewport state is
-       * effectively also a change in the clipping state.
-       *
-       * TODO: file a bug upstream!
-       */
-      if (G_UNLIKELY (context->needs_viewport_scissor_workaround))
-          differences |= COGL_FRAMEBUFFER_STATE_CLIP;
-
-      return differences;
-    }
+    return COGL_FRAMEBUFFER_STATE_VIEWPORT;
   else
     return 0;
 }
@@ -894,17 +827,6 @@ _cogl_framebuffer_compare_projection_state (CoglFramebuffer *a,
   return COGL_FRAMEBUFFER_STATE_PROJECTION;
 }
 
-static unsigned long
-_cogl_framebuffer_compare_color_mask_state (CoglFramebuffer *a,
-                                            CoglFramebuffer *b)
-{
-  if (cogl_framebuffer_get_color_mask (a) !=
-      cogl_framebuffer_get_color_mask (b))
-    return COGL_FRAMEBUFFER_STATE_COLOR_MASK;
-  else
-    return 0;
-}
-
 static unsigned long
 _cogl_framebuffer_compare_front_face_winding_state (CoglFramebuffer *a,
                                                     CoglFramebuffer *b)
@@ -971,10 +893,6 @@ _cogl_framebuffer_compare (CoglFramebuffer *a,
           differences |=
             _cogl_framebuffer_compare_projection_state (a, b);
           break;
-        case COGL_FRAMEBUFFER_STATE_INDEX_COLOR_MASK:
-          differences |=
-            _cogl_framebuffer_compare_color_mask_state (a, b);
-          break;
         case COGL_FRAMEBUFFER_STATE_INDEX_FRONT_FACE_WINDING:
           differences |=
             _cogl_framebuffer_compare_front_face_winding_state (a, b);
@@ -1080,29 +998,6 @@ cogl_framebuffer_get_is_stereo (CoglFramebuffer *framebuffer)
   return framebuffer->config.stereo_enabled;
 }
 
-CoglColorMask
-cogl_framebuffer_get_color_mask (CoglFramebuffer *framebuffer)
-{
-  return framebuffer->color_mask;
-}
-
-void
-cogl_framebuffer_set_color_mask (CoglFramebuffer *framebuffer,
-                                 CoglColorMask color_mask)
-{
-  if (framebuffer->color_mask == color_mask)
-    return;
-
-  /* XXX: Currently color mask changes don't go through the journal */
-  _cogl_framebuffer_flush_journal (framebuffer);
-
-  framebuffer->color_mask = color_mask;
-
-  if (framebuffer->context->current_draw_buffer == framebuffer)
-    framebuffer->context->current_draw_buffer_changes |=
-      COGL_FRAMEBUFFER_STATE_COLOR_MASK;
-}
-
 CoglStereoMode
 cogl_framebuffer_get_stereo_mode (CoglFramebuffer *framebuffer)
 {
@@ -2097,15 +1992,6 @@ get_wire_line_indices (CoglContext *ctx,
   return ret;
 }
 
-static gboolean
-remove_layer_cb (CoglPipeline *pipeline,
-                 int layer_index,
-                 void *user_data)
-{
-  cogl_pipeline_remove_layer (pipeline, layer_index);
-  return TRUE;
-}
-
 static void
 pipeline_destroyed_cb (CoglPipeline *weak_pipeline, void *user_data)
 {
@@ -2157,6 +2043,8 @@ draw_wireframe (CoglContext *ctx,
 
   if (!wire_pipeline)
     {
+      static CoglSnippet *snippet = NULL;
+
       wire_pipeline =
         _cogl_pipeline_weak_copy (pipeline, pipeline_destroyed_cb, NULL);
 
@@ -2168,29 +2056,20 @@ draw_wireframe (CoglContext *ctx,
        * vertex program and since we'd like to see the results of the
        * vertex program in the wireframe we just add a final clobber
        * of the wire color leaving the rest of the state untouched. */
-      if (cogl_has_feature (framebuffer->context, COGL_FEATURE_ID_GLSL))
-        {
-          static CoglSnippet *snippet = NULL;
 
-          /* The snippet is cached so that it will reuse the program
-           * from the pipeline cache if possible */
-          if (snippet == NULL)
-            {
-              snippet = cogl_snippet_new (COGL_SNIPPET_HOOK_FRAGMENT,
-                                          NULL,
-                                          NULL);
-              cogl_snippet_set_replace (snippet,
-                                        "cogl_color_out = "
-                                        "vec4 (0.0, 1.0, 0.0, 1.0);\n");
-            }
-
-          cogl_pipeline_add_snippet (wire_pipeline, snippet);
-        }
-      else
+      /* The snippet is cached so that it will reuse the program
+       * from the pipeline cache if possible */
+      if (snippet == NULL)
         {
-          cogl_pipeline_foreach_layer (wire_pipeline, remove_layer_cb, NULL);
-          cogl_pipeline_set_color4f (wire_pipeline, 0, 1, 0, 1);
+          snippet = cogl_snippet_new (COGL_SNIPPET_HOOK_FRAGMENT,
+                                      NULL,
+                                      NULL);
+          cogl_snippet_set_replace (snippet,
+                                    "cogl_color_out = "
+                                    "vec4 (0.0, 1.0, 0.0, 1.0);\n");
         }
+
+      cogl_pipeline_add_snippet (wire_pipeline, snippet);
     }
 
   /* temporarily disable the wireframe to avoid recursion! */

cogl/cogl/cogl-framebuffer.h

@@ -816,38 +816,6 @@ void
 cogl_framebuffer_set_depth_write_enabled (CoglFramebuffer *framebuffer,
                                           gboolean depth_write_enabled);
 
-/**
- * cogl_framebuffer_get_color_mask:
- * @framebuffer: a pointer to a #CoglFramebuffer
- *
- * Gets the current #CoglColorMask of which channels would be written to the
- * current framebuffer. Each bit set in the mask means that the
- * corresponding color would be written.
- *
- * Returns: A #CoglColorMask
- * Since: 1.8
- * Stability: unstable
- */
-CoglColorMask
-cogl_framebuffer_get_color_mask (CoglFramebuffer *framebuffer);
-
-/**
- * cogl_framebuffer_set_color_mask:
- * @framebuffer: a pointer to a #CoglFramebuffer
- * @color_mask: A #CoglColorMask of which color channels to write to
- *              the current framebuffer.
- *
- * Defines a bit mask of which color channels should be written to the
- * given @framebuffer. If a bit is set in @color_mask that means that
- * color will be written.
- *
- * Since: 1.8
- * Stability: unstable
- */
-void
-cogl_framebuffer_set_color_mask (CoglFramebuffer *framebuffer,
-                                 CoglColorMask color_mask);
-
 /**
  * cogl_framebuffer_get_stereo_mode:
  * @framebuffer: a pointer to a #CoglFramebuffer
@@ -1161,8 +1129,8 @@ cogl_framebuffer_clear4f (CoglFramebuffer *framebuffer,
  * This drawing api doesn't support high-level meta texture types such
  * as #CoglTexture2DSliced so it is the user's responsibility to
  * ensure that only low-level textures that can be directly sampled by
- * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
- * are associated with layers of the given @pipeline.
+ * a GPU such as #CoglTexture2D are associated with layers of the given
+ * @pipeline.
  *
  * <note>This api doesn't support any of the legacy global state options such
  * as cogl_set_depth_test_enabled(), cogl_set_backface_culling_enabled() or
@@ -1203,8 +1171,8 @@ cogl_framebuffer_draw_primitive (CoglFramebuffer *framebuffer,
  * This drawing api doesn't support high-level meta texture types such
  * as #CoglTexture2DSliced so it is the user's responsibility to
  * ensure that only low-level textures that can be directly sampled by
- * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
- * are associated with layers of the given @pipeline.
+ * a GPU such as #CoglTexture2D are associated with layers of the given
+ * @pipeline.
  *
  * Stability: unstable
  * Since: 1.10
@@ -1246,8 +1214,8 @@ cogl_framebuffer_vdraw_attributes (CoglFramebuffer *framebuffer,
  * This drawing api doesn't support high-level meta texture types such
  * as #CoglTexture2DSliced so it is the user's responsibility to
  * ensure that only low-level textures that can be directly sampled by
- * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
- * are associated with layers of the given @pipeline.
+ * a GPU such as #CoglTexture2D are associated with layers of the given
+ * @pipeline.
  *
  * <note>This api doesn't support any of the legacy global state options such
  * as cogl_set_depth_test_enabled(), cogl_set_backface_culling_enabled() or
@@ -1312,8 +1280,8 @@ cogl_framebuffer_draw_attributes (CoglFramebuffer *framebuffer,
  * This drawing api doesn't support high-level meta texture types such
  * as #CoglTexture2DSliced so it is the user's responsibility to
  * ensure that only low-level textures that can be directly sampled by
- * a GPU such as #CoglTexture2D, #CoglTextureRectangle or
- * #CoglTexture3D are associated with layers of the given @pipeline.
+ * a GPU such as #CoglTexture2D are associated with layers of the given
+ * @pipeline.
  *
  * <note>This api doesn't support any of the legacy global state
  * options such as cogl_set_depth_test_enabled(),
@@ -1380,8 +1348,8 @@ cogl_framebuffer_vdraw_indexed_attributes (CoglFramebuffer *framebuffer,
  * This drawing api doesn't support high-level meta texture types such
  * as #CoglTexture2DSliced so it is the user's responsibility to
  * ensure that only low-level textures that can be directly sampled by
- * a GPU such as #CoglTexture2D, #CoglTextureRectangle or
- * #CoglTexture3D are associated with layers of the given @pipeline.
+ * a GPU such as #CoglTexture2D are associated with layers of the given
+ * @pipeline.
  *
  * <note>This api doesn't support any of the legacy global state
  * options such as cogl_set_depth_test_enabled(),
@@ -1475,11 +1443,6 @@ cogl_framebuffer_draw_rectangle (CoglFramebuffer *framebuffer,
  * bottom right. To map an entire texture across the rectangle pass
  * in @s_1=0, @t_1=0, @s_2=1, @t_2=1.
  *
- * <note>Even if you have associated a #CoglTextureRectangle texture
- * with one of your @pipeline layers which normally implies working
- * with non-normalized texture coordinates this api should still be
- * passed normalized texture coordinates.</note>
- *
  * Since: 1.10
  * Stability: unstable
  */
@@ -1532,9 +1495,7 @@ cogl_framebuffer_draw_textured_rectangle (CoglFramebuffer *framebuffer,
  * <note>This api can not currently handle multiple high-level meta
  * texture layers. The first layer may be a high level meta texture
  * such as #CoglTexture2DSliced but all other layers much be low
- * level textures such as #CoglTexture2D and additionally they
- * should be textures that can be sampled using normalized coordinates
- * (so not #CoglTextureRectangle textures).</note>
+ * level textures such as #CoglTexture2D.
  *
  * The top left texture coordinate for layer 0 of any pipeline will be
  * (tex_coords[0], tex_coords[1]) and the bottom right coordinate will
@@ -1548,11 +1509,6 @@ cogl_framebuffer_draw_textured_rectangle (CoglFramebuffer *framebuffer,
  * in tex_coords[0]=0, tex_coords[1]=0, tex_coords[2]=1,
  * tex_coords[3]=1.
  *
- * <note>Even if you have associated a #CoglTextureRectangle texture
- * which normally implies working with non-normalized texture
- * coordinates this api should still be passed normalized texture
- * coordinates.</note>
- *
  * The first pair of coordinates are for the first layer (with the
  * smallest layer index) and if you supply less texture coordinates
  * than there are layers in the current source material then default
@@ -1656,11 +1612,6 @@ cogl_framebuffer_draw_rectangles (CoglFramebuffer *framebuffer,
  * in tex_coords[0]=0, tex_coords[1]=0, tex_coords[2]=1,
  * tex_coords[3]=1.
  *
- * <note>Even if you have associated a #CoglTextureRectangle texture
- * which normally implies working with non-normalized texture
- * coordinates this api should still be passed normalized texture
- * coordinates.</note>
- *
  * Since: 1.10
  * Stability: unstable
  */

cogl/cogl/cogl-gles2.h

@@ -366,9 +366,8 @@ cogl_gles2_texture_2d_new_from_handle (CoglContext *ctx,
  * GLES2 context.</note>
  *
  * <note>This function will only return %TRUE for low-level
- * #CoglTexture<!-- -->s such as #CoglTexture2D or #CoglTexture3D but
- * not for high level meta textures such as
- * #CoglTexture2DSliced</note>
+ * #CoglTexture<!-- -->s such as #CoglTexture2D but not for high level
+ * meta textures such as #CoglTexture2DSliced</note>
  *
  * <note>The handle returned should not be passed directly to a system
  * OpenGL ES 2.0 library, the handle is only intended to be used via

cogl/cogl/cogl-glsl-shader.c

@@ -100,21 +100,12 @@ _cogl_glsl_shader_set_source_with_boilerplate (CoglContext *ctx,
   strings[count] = version_string;
   lengths[count++] = -1;
 
-  if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_EMBEDDED) &&
-      cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_3D))
-    {
-      static const char texture_3d_extension[] =
-        "#extension GL_OES_texture_3D : enable\n";
-      strings[count] = texture_3d_extension;
-      lengths[count++] = sizeof (texture_3d_extension) - 1;
-    }
-
   if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_EGL_IMAGE_EXTERNAL))
     {
-      static const char texture_3d_extension[] =
+      static const char image_external_extension[] =
         "#extension GL_OES_EGL_image_external : require\n";
-      strings[count] = texture_3d_extension;
-      lengths[count++] = sizeof (texture_3d_extension) - 1;
+      strings[count] = image_external_extension;
+      lengths[count++] = sizeof (image_external_extension) - 1;
     }
 
   if (shader_gl_type == GL_VERTEX_SHADER)

cogl/cogl/cogl-meta-texture.c

@@ -36,7 +36,7 @@
 #include "cogl-matrix.h"
 #include "cogl-spans.h"
 #include "cogl-meta-texture.h"
-#include "cogl-texture-rectangle-private.h"
+#include "cogl-texture-private.h"
 
 #include <string.h>
 #include <math.h>
@@ -316,16 +316,9 @@ foreach_clamped_region (CoglMetaTexture *meta_texture,
 
   if (wrap_s == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
     {
-      float max_s_coord;
+      float max_s_coord = 1.0;
       float half_texel_width;
 
-      /* Consider that rectangle textures have non-normalized
-       * coordinates... */
-      if (cogl_is_texture_rectangle (meta_texture))
-        max_s_coord = width;
-      else
-        max_s_coord = 1.0;
-
       half_texel_width = max_s_coord / (width * 2);
 
       /* Handle any left clamped region */
@@ -375,16 +368,9 @@ foreach_clamped_region (CoglMetaTexture *meta_texture,
   if (wrap_t == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
     {
       float height = cogl_texture_get_height (COGL_TEXTURE (meta_texture));
-      float max_t_coord;
+      float max_t_coord = 1.0;
       float half_texel_height;
 
-      /* Consider that rectangle textures have non-normalized
-       * coordinates... */
-      if (cogl_is_texture_rectangle (meta_texture))
-        max_t_coord = height;
-      else
-        max_t_coord = 1.0;
-
       half_texel_height = max_t_coord / (height * 2);
 
       /* Handle any top clamped region */
@@ -466,33 +452,6 @@ normalize_meta_coords_cb (CoglTexture *slice_texture,
                   data->user_data);
 }
 
-typedef struct _UnNormalizeData
-{
-  CoglMetaTextureCallback callback;
-  void *user_data;
-  float width;
-  float height;
-} UnNormalizeData;
-
-static void
-un_normalize_slice_coords_cb (CoglTexture *slice_texture,
-                              const float *slice_coords,
-                              const float *meta_coords,
-                              void *user_data)
-{
-  UnNormalizeData *data = user_data;
-  float un_normalized_slice_coords[4] = {
-    slice_coords[0] * data->width,
-    slice_coords[1] * data->height,
-    slice_coords[2] * data->width,
-    slice_coords[3] * data->height
-  };
-
-  data->callback (slice_texture,
-                  un_normalized_slice_coords, meta_coords,
-                  data->user_data);
-}
-
 void
 cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
                                      float tx_1,
@@ -539,19 +498,16 @@ cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
    * coordinates beyond this point and only re-normalize just before
    * calling the user's callback... */
 
-  if (!cogl_is_texture_rectangle (COGL_TEXTURE (meta_texture)))
-    {
-      normalize_data.callback = callback;
-      normalize_data.user_data = user_data;
-      normalize_data.s_normalize_factor = 1.0f / width;
-      normalize_data.t_normalize_factor = 1.0f / height;
-      callback = normalize_meta_coords_cb;
-      user_data = &normalize_data;
-      tx_1 *= width;
-      ty_1 *= height;
-      tx_2 *= width;
-      ty_2 *= height;
-    }
+  normalize_data.callback = callback;
+  normalize_data.user_data = user_data;
+  normalize_data.s_normalize_factor = 1.0f / width;
+  normalize_data.t_normalize_factor = 1.0f / height;
+  callback = normalize_meta_coords_cb;
+  user_data = &normalize_data;
+  tx_1 *= width;
+  ty_1 *= height;
+  tx_2 *= width;
+  ty_2 *= height;
 
   /* XXX: at some point this wont be routed through the CoglTexture
    * vtable, instead there will be a separate CoglMetaTexture
@@ -609,21 +565,6 @@ cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
       CoglSpan x_span = { 0, width, 0 };
       CoglSpan y_span = { 0, height, 0 };
       float meta_region_coords[4] = { tx_1, ty_1, tx_2, ty_2 };
-      UnNormalizeData un_normalize_data;
-
-      /* If we are dealing with a CoglTextureRectangle then we need a shim
-       * callback that un_normalizes the slice coordinates we get from
-       * _cogl_texture_spans_foreach_in_region before passing them to
-       * the user's callback. */
-      if (cogl_is_texture_rectangle (meta_texture))
-        {
-          un_normalize_data.callback = callback;
-          un_normalize_data.user_data = user_data;
-          un_normalize_data.width = width;
-          un_normalize_data.height = height;
-          callback = un_normalize_slice_coords_cb;
-          user_data = &un_normalize_data;
-        }
 
       _cogl_texture_spans_foreach_in_region (&x_span, 1,
                                              &y_span, 1,

cogl/cogl/cogl-meta-texture.h

@@ -42,8 +42,7 @@ G_BEGIN_DECLS
 /**
  * SECTION:cogl-meta-texture
  * @short_description: Interface for high-level textures built from
- *                     low-level textures like #CoglTexture2D and
- *                     #CoglTexture3D.
+ *                     low-level textures like #CoglTexture2D.
  *
  * Cogl helps to make it easy to deal with high level textures such
  * as #CoglAtlasTexture<!-- -->s, #CoglSubTexture<!-- -->s,
@@ -52,12 +51,11 @@ G_BEGIN_DECLS
  *
  * A #CoglMetaTexture is a texture that might internally be
  * represented by one or more low-level #CoglTexture<!-- -->s
- * such as #CoglTexture2D or #CoglTexture3D. These low-level textures
- * are the only ones that a GPU really understands but because
- * applications often want more high-level texture abstractions
- * (such as storing multiple textures inside one larger "atlas"
- * texture) it's desirable to be able to deal with these
- * using a common interface.
+ * such as #CoglTexture2D. These low-level textures are the only ones
+ * that a GPU really understands but because applications often want
+ * more high-level texture abstractions (such as storing multiple
+ * textures inside one larger "atlas" texture) it's desirable to be
+ * able to deal with these using a common interface.
  *
  * For example the GPU is not able to automatically handle repeating a
  * texture that is part of a larger atlas texture but if you use

cogl/cogl/cogl-offscreen.h

@@ -75,8 +75,8 @@ GType cogl_offscreen_get_gtype (void);
  * destroy the offscreen buffer before you can use the @texture again.
  *
  * <note>This api only works with low-level #CoglTexture types such as
- * #CoglTexture2D, #CoglTexture3D and #CoglTextureRectangle, and not
- * with meta-texture types such as #CoglTexture2DSliced.</note>
+ * #CoglTexture2D and not with meta-texture types such as
+ * #CoglTexture2DSliced.</note>
  *
  * The storage for the framebuffer is actually allocated lazily
  * so this function will never return %NULL to indicate a runtime
@@ -110,8 +110,8 @@ cogl_offscreen_new_with_texture (CoglTexture *texture);
  * you can use the @texture again.
  *
  * <note>This only works with low-level #CoglTexture types such as
- * #CoglTexture2D, #CoglTexture3D and #CoglTextureRectangle, and not
- * with meta-texture types such as #CoglTexture2DSliced.</note>
+ * #CoglTexture2D and not with meta-texture types such as
+ * #CoglTexture2DSliced.</note>
  *
  * Return value: (transfer full): a newly instantiated #CoglOffscreen
  *   framebuffer or %NULL if it wasn't possible to create the

cogl/cogl/cogl-pipeline-layer-private.h

@@ -55,7 +55,6 @@ typedef enum
 {
   /* sparse state */
   COGL_PIPELINE_LAYER_STATE_UNIT_INDEX,
-  COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE_INDEX,
   COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA_INDEX,
   COGL_PIPELINE_LAYER_STATE_SAMPLER_INDEX,
   COGL_PIPELINE_LAYER_STATE_COMBINE_INDEX,
@@ -82,8 +81,6 @@ typedef enum
 {
   COGL_PIPELINE_LAYER_STATE_UNIT =
     1L<<COGL_PIPELINE_LAYER_STATE_UNIT_INDEX,
-  COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE =
-    1L<<COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE_INDEX,
   COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA =
     1L<<COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA_INDEX,
   COGL_PIPELINE_LAYER_STATE_SAMPLER =
@@ -237,11 +234,6 @@ struct _CoglPipelineLayer
   /* Each layer is directly associated with a single texture unit */
   int                        unit_index;
 
-  /* The type of the texture. This is always set even if the texture
-     is NULL and it will be used to determine what type of texture
-     lookups to use in any shaders generated by the pipeline
-     backends. */
-  CoglTextureType            texture_type;
   /* The texture for this layer, or NULL for an empty
    * layer */
   CoglTexture               *texture;
@@ -347,9 +339,6 @@ _cogl_pipeline_layer_get_texture (CoglPipelineLayer *layer);
 CoglTexture *
 _cogl_pipeline_layer_get_texture_real (CoglPipelineLayer *layer);
 
-CoglTextureType
-_cogl_pipeline_layer_get_texture_type (CoglPipelineLayer *layer);
-
 CoglPipelineFilter
 _cogl_pipeline_layer_get_min_filter (CoglPipelineLayer *layer);
 

cogl/cogl/cogl-pipeline-layer-state-private.h

@@ -50,11 +50,6 @@ CoglPipelineFilter
 _cogl_pipeline_get_layer_mag_filter (CoglPipeline *pipeline,
                                      int layer_index);
 
-gboolean
-_cogl_pipeline_layer_texture_type_equal (CoglPipelineLayer *authority0,
-                                         CoglPipelineLayer *authority1,
-                                         CoglPipelineEvalFlags flags);
-
 gboolean
 _cogl_pipeline_layer_texture_data_equal (CoglPipelineLayer *authority0,
                                          CoglPipelineLayer *authority1,
@@ -93,11 +88,6 @@ _cogl_pipeline_layer_hash_unit_state (CoglPipelineLayer *authority,
                                       CoglPipelineLayer **authorities,
                                       CoglPipelineHashState *state);
 
-void
-_cogl_pipeline_layer_hash_texture_type_state (CoglPipelineLayer *authority,
-                                              CoglPipelineLayer **authorities,
-                                              CoglPipelineHashState *state);
-
 void
 _cogl_pipeline_layer_hash_texture_data_state (CoglPipelineLayer *authority,
                                               CoglPipelineLayer **authorities,

cogl/cogl/cogl-pipeline-layer-state.c

@@ -136,87 +136,6 @@ cogl_pipeline_get_layer_texture (CoglPipeline *pipeline,
   return _cogl_pipeline_layer_get_texture (layer);
 }
 
-CoglTextureType
-_cogl_pipeline_layer_get_texture_type (CoglPipelineLayer *layer)
-{
-  CoglPipelineLayer *authority =
-    _cogl_pipeline_layer_get_authority (layer,
-                                        COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE);
-
-  return authority->texture_type;
-}
-
-static void
-_cogl_pipeline_set_layer_texture_type (CoglPipeline *pipeline,
-                                       int layer_index,
-                                       CoglTextureType texture_type)
-{
-  CoglPipelineLayerState change = COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE;
-  CoglPipelineLayer *layer;
-  CoglPipelineLayer *authority;
-  CoglPipelineLayer *new;
-
-  /* Note: this will ensure that the layer exists, creating one if it
-   * doesn't already.
-   *
-   * Note: If the layer already existed it's possibly owned by another
-   * pipeline. If the layer is created then it will be owned by
-   * pipeline. */
-  layer = _cogl_pipeline_get_layer (pipeline, layer_index);
-
-  /* Now find the ancestor of the layer that is the authority for the
-   * state we want to change */
-  authority = _cogl_pipeline_layer_get_authority (layer, change);
-
-  if (texture_type == authority->texture_type)
-    return;
-
-  new = _cogl_pipeline_layer_pre_change_notify (pipeline, layer, change);
-  if (new != layer)
-    layer = new;
-  else
-    {
-      /* If the original layer we found is currently the authority on
-       * the state we are changing see if we can revert to one of our
-       * ancestors being the authority. */
-      if (layer == authority &&
-          _cogl_pipeline_layer_get_parent (authority) != NULL)
-        {
-          CoglPipelineLayer *parent =
-            _cogl_pipeline_layer_get_parent (authority);
-          CoglPipelineLayer *old_authority =
-            _cogl_pipeline_layer_get_authority (parent, change);
-
-          if (old_authority->texture_type == texture_type)
-            {
-              layer->differences &= ~change;
-
-              g_assert (layer->owner == pipeline);
-              if (layer->differences == 0)
-                _cogl_pipeline_prune_empty_layer_difference (pipeline,
-                                                             layer);
-              goto changed;
-            }
-        }
-    }
-
-  layer->texture_type = texture_type;
-
-  /* If we weren't previously the authority on this state then we need
-   * to extended our differences mask and so it's possible that some
-   * of our ancestry will now become redundant, so we aim to reparent
-   * ourselves if that's true... */
-  if (layer != authority)
-    {
-      layer->differences |= change;
-      _cogl_pipeline_layer_prune_redundant_ancestry (layer);
-    }
-
-changed:
-
-  pipeline->dirty_real_blend_enable = TRUE;
-}
-
 static void
 _cogl_pipeline_set_layer_texture_data (CoglPipeline *pipeline,
                                        int layer_index,
@@ -301,69 +220,13 @@ cogl_pipeline_set_layer_texture (CoglPipeline *pipeline,
                                  int layer_index,
                                  CoglTexture *texture)
 {
-  /* For the convenience of fragend code we separate texture state
-   * into the "type" and the "data", and setting a layer texture
-   * updates both of these properties.
-   *
-   * One example for why this is helpful is that the fragends may
-   * cache programs they generate and want to re-use those programs
-   * with all pipelines having equivalent fragment processing state.
-   * For the sake of determining if pipelines have equivalent fragment
-   * processing state we don't need to compare that the same
-   * underlying texture objects are referenced by the pipelines but we
-   * do need to see if they use the same texture types. Making this
-   * distinction is much simpler if they are in different state
-   * groups.
-   *
-   * Note: if a NULL texture is set then we leave the type unchanged
-   * so we can avoid needlessly invalidating any associated fragment
-   * program.
-   */
-  if (texture)
-    {
-      CoglTextureType texture_type =
-        _cogl_texture_get_type (texture);
-      _cogl_pipeline_set_layer_texture_type (pipeline,
-                                             layer_index,
-                                             texture_type);
-    }
   _cogl_pipeline_set_layer_texture_data (pipeline, layer_index, texture);
 }
 
 void
 cogl_pipeline_set_layer_null_texture (CoglPipeline *pipeline,
-                                      int layer_index,
-                                      CoglTextureType texture_type)
+                                      int layer_index)
 {
-  CoglContext *ctx = _cogl_context_get_default ();
-
-  /* Disallow setting texture types that aren't supported */
-  switch (texture_type)
-    {
-    case COGL_TEXTURE_TYPE_2D:
-      break;
-
-    case COGL_TEXTURE_TYPE_3D:
-      if (ctx->default_gl_texture_3d_tex == NULL)
-        {
-          g_warning ("The default 3D texture was set on a pipeline but "
-                     "3D textures are not supported");
-          texture_type = COGL_TEXTURE_TYPE_2D;
-          return;
-        }
-      break;
-
-    case COGL_TEXTURE_TYPE_RECTANGLE:
-      if (ctx->default_gl_texture_rect_tex == NULL)
-        {
-          g_warning ("The default rectangle texture was set on a pipeline but "
-                     "rectangle textures are not supported");
-          texture_type = COGL_TEXTURE_TYPE_2D;
-        }
-      break;
-    }
-
-  _cogl_pipeline_set_layer_texture_type (pipeline, layer_index, texture_type);
   _cogl_pipeline_set_layer_texture_data (pipeline, layer_index, NULL);
 }
 
@@ -950,14 +813,6 @@ cogl_pipeline_add_layer_snippet (CoglPipeline *pipeline,
                                                snippet);
 }
 
-gboolean
-_cogl_pipeline_layer_texture_type_equal (CoglPipelineLayer *authority0,
-                                         CoglPipelineLayer *authority1,
-                                         CoglPipelineEvalFlags flags)
-{
-  return authority0->texture_type == authority1->texture_type;
-}
-
 gboolean
 _cogl_pipeline_layer_texture_data_equal (CoglPipelineLayer *authority0,
                                          CoglPipelineLayer *authority1,
@@ -966,8 +821,7 @@ _cogl_pipeline_layer_texture_data_equal (CoglPipelineLayer *authority0,
   if (authority0->texture == NULL)
     {
       if (authority1->texture == NULL)
-        return (_cogl_pipeline_layer_get_texture_type (authority0) ==
-                _cogl_pipeline_layer_get_texture_type (authority1));
+        return TRUE;
       else
         return FALSE;
     }
@@ -1647,18 +1501,6 @@ _cogl_pipeline_layer_hash_unit_state (CoglPipelineLayer *authority,
     _cogl_util_one_at_a_time_hash (state->hash, &unit, sizeof (unit));
 }
 
-void
-_cogl_pipeline_layer_hash_texture_type_state (CoglPipelineLayer *authority,
-                                              CoglPipelineLayer **authorities,
-                                              CoglPipelineHashState *state)
-{
-  CoglTextureType texture_type = authority->texture_type;
-
-  state->hash = _cogl_util_one_at_a_time_hash (state->hash,
-                                               &texture_type,
-                                               sizeof (texture_type));
-}
-
 void
 _cogl_pipeline_layer_hash_texture_data_state (CoglPipelineLayer *authority,
                                               CoglPipelineLayer **authorities,

cogl/cogl/cogl-pipeline-layer-state.h

@@ -159,13 +159,9 @@ cogl_pipeline_set_layer_texture (CoglPipeline *pipeline,
  * cogl_pipeline_set_layer_null_texture:
  * @pipeline: A #CoglPipeline
  * @layer_index: The layer number to modify
- * @texture_type: The type of the default texture to use
  *
  * Sets the texture for this layer to be the default texture for the
- * given type. This is equivalent to calling
- * cogl_pipeline_set_layer_texture() with %NULL for the texture
- * argument except that you can also specify the type of default
- * texture to use. The default texture is a 1x1 pixel white texture.
+ * given type. The default texture is a 1x1 pixel white texture.
  *
  * This function is mostly useful if you want to create a base
  * pipeline that you want to create multiple copies from using
@@ -178,8 +174,7 @@ cogl_pipeline_set_layer_texture (CoglPipeline *pipeline,
  */
 void
 cogl_pipeline_set_layer_null_texture (CoglPipeline *pipeline,
-                                      int layer_index,
-                                      CoglTextureType texture_type);
+                                      int layer_index);
 
 /**
  * cogl_pipeline_get_layer_texture:

cogl/cogl/cogl-pipeline-layer.c

@@ -187,10 +187,6 @@ _cogl_pipeline_layer_copy_differences (CoglPipelineLayer *dest,
           g_warn_if_reached ();
           break;
 
-        case COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE_INDEX:
-          dest->texture_type = src->texture_type;
-          break;
-
         case COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA_INDEX:
           dest->texture = src->texture;
           if (dest->texture)
@@ -272,7 +268,6 @@ _cogl_pipeline_layer_init_multi_property_sparse_state (
     /* XXX: avoid using a default: label so we get a warning if we
      * don't explicitly handle a newly defined state-group here. */
     case COGL_PIPELINE_LAYER_STATE_UNIT:
-    case COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE:
     case COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA:
     case COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS:
     case COGL_PIPELINE_LAYER_STATE_USER_MATRIX:
@@ -662,16 +657,6 @@ _cogl_pipeline_layer_equal (CoglPipelineLayer *layer0,
                                             layers_difference,
                                             authorities1);
 
-  if (layers_difference & COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE)
-    {
-      CoglPipelineLayerStateIndex state_index =
-        COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE_INDEX;
-      if (!_cogl_pipeline_layer_texture_type_equal (authorities0[state_index],
-                                                    authorities1[state_index],
-                                                    flags))
-        return FALSE;
-    }
-
   if (layers_difference & COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA)
     {
       CoglPipelineLayerStateIndex state_index =
@@ -767,7 +752,6 @@ _cogl_pipeline_init_default_layers (void)
   layer->unit_index = 0;
 
   layer->texture = NULL;
-  layer->texture_type = COGL_TEXTURE_TYPE_2D;
 
   layer->sampler_cache_entry =
     _cogl_sampler_cache_get_default_entry (ctx->sampler_cache);

cogl/cogl/cogl-pipeline-private.h

@@ -87,7 +87,6 @@ typedef enum
   COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE_INDEX,
   COGL_PIPELINE_STATE_POINT_SIZE_INDEX,
   COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE_INDEX,
-  COGL_PIPELINE_STATE_LOGIC_OPS_INDEX,
   COGL_PIPELINE_STATE_CULL_FACE_INDEX,
   COGL_PIPELINE_STATE_UNIFORMS_INDEX,
   COGL_PIPELINE_STATE_VERTEX_SNIPPETS_INDEX,
@@ -140,8 +139,6 @@ typedef enum _CoglPipelineState
     1L<<COGL_PIPELINE_STATE_POINT_SIZE_INDEX,
   COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE =
     1L<<COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE_INDEX,
-  COGL_PIPELINE_STATE_LOGIC_OPS =
-    1L<<COGL_PIPELINE_STATE_LOGIC_OPS_INDEX,
   COGL_PIPELINE_STATE_CULL_FACE =
     1L<<COGL_PIPELINE_STATE_CULL_FACE_INDEX,
   COGL_PIPELINE_STATE_UNIFORMS =
@@ -188,7 +185,6 @@ typedef enum _CoglPipelineState
    COGL_PIPELINE_STATE_NON_ZERO_POINT_SIZE | \
    COGL_PIPELINE_STATE_POINT_SIZE | \
    COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE | \
-   COGL_PIPELINE_STATE_LOGIC_OPS | \
    COGL_PIPELINE_STATE_CULL_FACE | \
    COGL_PIPELINE_STATE_UNIFORMS | \
    COGL_PIPELINE_STATE_VERTEX_SNIPPETS | \
@@ -200,7 +196,6 @@ typedef enum _CoglPipelineState
    COGL_PIPELINE_STATE_BLEND | \
    COGL_PIPELINE_STATE_DEPTH | \
    COGL_PIPELINE_STATE_FOG | \
-   COGL_PIPELINE_STATE_LOGIC_OPS | \
    COGL_PIPELINE_STATE_CULL_FACE | \
    COGL_PIPELINE_STATE_UNIFORMS | \
    COGL_PIPELINE_STATE_VERTEX_SNIPPETS | \
@@ -265,11 +260,6 @@ typedef struct
   float           z_far;
 } CoglPipelineFogState;
 
-typedef struct
-{
-  CoglColorMask color_mask;
-} CoglPipelineLogicOpsState;
-
 typedef struct
 {
   CoglPipelineCullFaceMode mode;
@@ -301,7 +291,6 @@ typedef struct
   float point_size;
   unsigned int non_zero_point_size : 1;
   unsigned int per_vertex_point_size : 1;
-  CoglPipelineLogicOpsState logic_ops_state;
   CoglPipelineCullFaceState cull_face_state;
   CoglPipelineUniformsState uniforms_state;
   CoglPipelineSnippetList vertex_snippets;

cogl/cogl/cogl-pipeline-state.c

@@ -218,16 +218,6 @@ _cogl_pipeline_per_vertex_point_size_equal (CoglPipeline *authority0,
           authority1->big_state->per_vertex_point_size);
 }
 
-gboolean
-_cogl_pipeline_logic_ops_state_equal (CoglPipeline *authority0,
-                                      CoglPipeline *authority1)
-{
-  CoglPipelineLogicOpsState *logic_ops_state0 = &authority0->big_state->logic_ops_state;
-  CoglPipelineLogicOpsState *logic_ops_state1 = &authority1->big_state->logic_ops_state;
-
-  return logic_ops_state0->color_mask == logic_ops_state1->color_mask;
-}
-
 gboolean
 _cogl_pipeline_cull_face_state_equal (CoglPipeline *authority0,
                                       CoglPipeline *authority1)
@@ -1203,49 +1193,6 @@ cogl_pipeline_get_depth_state (CoglPipeline *pipeline,
   *state = authority->big_state->depth_state;
 }
 
-CoglColorMask
-cogl_pipeline_get_color_mask (CoglPipeline *pipeline)
-{
-  CoglPipeline *authority;
-
-  _COGL_RETURN_VAL_IF_FAIL (cogl_is_pipeline (pipeline), 0);
-
-  authority =
-    _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_LOGIC_OPS);
-
-  return authority->big_state->logic_ops_state.color_mask;
-}
-
-void
-cogl_pipeline_set_color_mask (CoglPipeline *pipeline,
-                              CoglColorMask color_mask)
-{
-  CoglPipelineState state = COGL_PIPELINE_STATE_LOGIC_OPS;
-  CoglPipeline *authority;
-  CoglPipelineLogicOpsState *logic_ops_state;
-
-  _COGL_RETURN_IF_FAIL (cogl_is_pipeline (pipeline));
-
-  authority = _cogl_pipeline_get_authority (pipeline, state);
-
-  logic_ops_state = &authority->big_state->logic_ops_state;
-  if (logic_ops_state->color_mask == color_mask)
-    return;
-
-  /* - Flush journal primitives referencing the current state.
-   * - Make sure the pipeline has no dependants so it may be modified.
-   * - If the pipeline isn't currently an authority for the state being
-   *   changed, then initialize that state from the current authority.
-   */
-  _cogl_pipeline_pre_change_notify (pipeline, state, NULL, FALSE);
-
-  logic_ops_state = &pipeline->big_state->logic_ops_state;
-  logic_ops_state->color_mask = color_mask;
-
-  _cogl_pipeline_update_authority (pipeline, authority, state,
-                                   _cogl_pipeline_logic_ops_state_equal);
-}
-
 void
 _cogl_pipeline_set_fog_state (CoglPipeline *pipeline,
                               const CoglPipelineFogState *fog_state)
@@ -1951,15 +1898,6 @@ _cogl_pipeline_hash_per_vertex_point_size_state (CoglPipeline *authority,
                                                sizeof (per_vertex_point_size));
 }
 
-void
-_cogl_pipeline_hash_logic_ops_state (CoglPipeline *authority,
-                                     CoglPipelineHashState *state)
-{
-  CoglPipelineLogicOpsState *logic_ops_state = &authority->big_state->logic_ops_state;
-  state->hash = _cogl_util_one_at_a_time_hash (state->hash, &logic_ops_state->color_mask,
-                                               sizeof (CoglColorMask));
-}
-
 void
 _cogl_pipeline_hash_cull_face_state (CoglPipeline *authority,
                                      CoglPipelineHashState *state)

cogl/cogl/cogl-pipeline-state.h

@@ -571,38 +571,6 @@ cogl_pipeline_set_per_vertex_point_size (CoglPipeline *pipeline,
 gboolean
 cogl_pipeline_get_per_vertex_point_size (CoglPipeline *pipeline);
 
-/**
- * cogl_pipeline_get_color_mask:
- * @pipeline: a #CoglPipeline object.
- *
- * Gets the current #CoglColorMask of which channels would be written to the
- * current framebuffer. Each bit set in the mask means that the
- * corresponding color would be written.
- *
- * Returns: A #CoglColorMask
- * Since: 1.8
- * Stability: unstable
- */
-CoglColorMask
-cogl_pipeline_get_color_mask (CoglPipeline *pipeline);
-
-/**
- * cogl_pipeline_set_color_mask:
- * @pipeline: a #CoglPipeline object.
- * @color_mask: A #CoglColorMask of which color channels to write to
- *              the current framebuffer.
- *
- * Defines a bit mask of which color channels should be written to the
- * current framebuffer. If a bit is set in @color_mask that means that
- * color will be written.
- *
- * Since: 1.8
- * Stability: unstable
- */
-void
-cogl_pipeline_set_color_mask (CoglPipeline *pipeline,
-                              CoglColorMask color_mask);
-
 /**
  * cogl_pipeline_get_user_program:
  * @pipeline: a #CoglPipeline object.
@@ -658,10 +626,6 @@ cogl_pipeline_get_user_program (CoglPipeline *pipeline);
  * meantime we hope this will handle most practical GLSL and ARBfp
  * requirements.
  *
- * Also remember you need to check for either the
- * %COGL_FEATURE_SHADERS_GLSL or %COGL_FEATURE_SHADERS_ARBFP before
- * using the cogl_program or cogl_shader API.
- *
  * Since: 2.0
  * Stability: Unstable
  */

cogl/cogl/cogl-pipeline.c

@@ -99,7 +99,6 @@ _cogl_pipeline_init_default_pipeline (void)
   CoglPipelineLightingState *lighting_state = &big_state->lighting_state;
   CoglPipelineAlphaFuncState *alpha_state = &big_state->alpha_state;
   CoglPipelineBlendState *blend_state = &big_state->blend_state;
-  CoglPipelineLogicOpsState *logic_ops_state = &big_state->logic_ops_state;
   CoglPipelineCullFaceState *cull_face_state = &big_state->cull_face_state;
   CoglPipelineUniformsState *uniforms_state = &big_state->uniforms_state;
 
@@ -189,8 +188,6 @@ _cogl_pipeline_init_default_pipeline (void)
 
   big_state->point_size = 0.0f;
 
-  logic_ops_state->color_mask = COGL_COLOR_MASK_ALL;
-
   cull_face_state->mode = COGL_PIPELINE_CULL_FACE_MODE_NONE;
   cull_face_state->front_winding = COGL_WINDING_COUNTER_CLOCKWISE;
 
@@ -1030,13 +1027,6 @@ _cogl_pipeline_copy_differences (CoglPipeline *dest,
   if (differences & COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE)
     big_state->per_vertex_point_size = src->big_state->per_vertex_point_size;
 
-  if (differences & COGL_PIPELINE_STATE_LOGIC_OPS)
-    {
-      memcpy (&big_state->logic_ops_state,
-              &src->big_state->logic_ops_state,
-              sizeof (CoglPipelineLogicOpsState));
-    }
-
   if (differences & COGL_PIPELINE_STATE_CULL_FACE)
     {
       memcpy (&big_state->cull_face_state,
@@ -1150,13 +1140,6 @@ _cogl_pipeline_init_multi_property_sparse_state (CoglPipeline *pipeline,
                 sizeof (CoglPipelineFogState));
         break;
       }
-    case COGL_PIPELINE_STATE_LOGIC_OPS:
-      {
-        memcpy (&pipeline->big_state->logic_ops_state,
-                &authority->big_state->logic_ops_state,
-                sizeof (CoglPipelineLogicOpsState));
-        break;
-      }
     case COGL_PIPELINE_STATE_CULL_FACE:
       {
         memcpy (&pipeline->big_state->cull_face_state,
@@ -1921,7 +1904,6 @@ fallback_layer_cb (CoglPipelineLayer *layer, void *user_data)
 {
   CoglPipelineFallbackState *state = user_data;
   CoglPipeline *pipeline = state->pipeline;
-  CoglTextureType texture_type = _cogl_pipeline_layer_get_texture_type (layer);
   CoglTexture *texture = NULL;
   COGL_STATIC_COUNTER (layer_fallback_counter,
                        "layer fallback counter",
@@ -1936,20 +1918,7 @@ fallback_layer_cb (CoglPipelineLayer *layer, void *user_data)
 
   COGL_COUNTER_INC (_cogl_uprof_context, layer_fallback_counter);
 
-  switch (texture_type)
-    {
-    case COGL_TEXTURE_TYPE_2D:
-      texture = COGL_TEXTURE (ctx->default_gl_texture_2d_tex);
-      break;
-
-    case COGL_TEXTURE_TYPE_3D:
-      texture = COGL_TEXTURE (ctx->default_gl_texture_3d_tex);
-      break;
-
-    case COGL_TEXTURE_TYPE_RECTANGLE:
-      texture = COGL_TEXTURE (ctx->default_gl_texture_rect_tex);
-      break;
-    }
+  texture = COGL_TEXTURE (ctx->default_gl_texture_2d_tex);
 
   if (texture == NULL)
     {
@@ -2323,11 +2292,6 @@ _cogl_pipeline_equal (CoglPipeline *pipeline0,
                                                            authorities1[bit]))
             goto done;
           break;
-        case COGL_PIPELINE_STATE_LOGIC_OPS_INDEX:
-          if (!_cogl_pipeline_logic_ops_state_equal (authorities0[bit],
-                                                     authorities1[bit]))
-            goto done;
-          break;
         case COGL_PIPELINE_STATE_USER_SHADER_INDEX:
           if (!_cogl_pipeline_user_shader_equal (authorities0[bit],
                                                  authorities1[bit]))
@@ -2647,8 +2611,6 @@ _cogl_pipeline_init_layer_state_hash_functions (void)
   CoglPipelineLayerStateIndex _index;
   layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_UNIT_INDEX] =
     _cogl_pipeline_layer_hash_unit_state;
-  layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE_INDEX] =
-    _cogl_pipeline_layer_hash_texture_type_state;
   layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_TEXTURE_DATA_INDEX] =
     _cogl_pipeline_layer_hash_texture_data_state;
   layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_SAMPLER_INDEX] =
@@ -2671,7 +2633,7 @@ _cogl_pipeline_init_layer_state_hash_functions (void)
 
   {
   /* So we get a big error if we forget to update this code! */
-  _COGL_STATIC_ASSERT (COGL_PIPELINE_LAYER_STATE_SPARSE_COUNT == 10,
+  _COGL_STATIC_ASSERT (COGL_PIPELINE_LAYER_STATE_SPARSE_COUNT == 9,
                        "Don't forget to install a hash function for new "
                        "pipeline state and update assert at end of "
                        "_cogl_pipeline_init_state_hash_functions");
@@ -2776,8 +2738,6 @@ _cogl_pipeline_init_state_hash_functions (void)
     _cogl_pipeline_hash_point_size_state;
   state_hash_functions[COGL_PIPELINE_STATE_PER_VERTEX_POINT_SIZE_INDEX] =
     _cogl_pipeline_hash_per_vertex_point_size_state;
-  state_hash_functions[COGL_PIPELINE_STATE_LOGIC_OPS_INDEX] =
-    _cogl_pipeline_hash_logic_ops_state;
   state_hash_functions[COGL_PIPELINE_STATE_UNIFORMS_INDEX] =
     _cogl_pipeline_hash_uniforms_state;
   state_hash_functions[COGL_PIPELINE_STATE_VERTEX_SNIPPETS_INDEX] =
@@ -2787,7 +2747,7 @@ _cogl_pipeline_init_state_hash_functions (void)
 
   {
   /* So we get a big error if we forget to update this code! */
-  _COGL_STATIC_ASSERT (COGL_PIPELINE_STATE_SPARSE_COUNT == 18,
+  _COGL_STATIC_ASSERT (COGL_PIPELINE_STATE_SPARSE_COUNT == 17,
                        "Make sure to install a hash function for "
                        "newly added pipeline state and update assert "
                        "in _cogl_pipeline_init_state_hash_functions");
@@ -3078,15 +3038,13 @@ _cogl_pipeline_get_layer_state_for_fragment_codegen (CoglContext *context)
 {
   CoglPipelineLayerState state =
     (COGL_PIPELINE_LAYER_STATE_COMBINE |
-     COGL_PIPELINE_LAYER_STATE_TEXTURE_TYPE |
      COGL_PIPELINE_LAYER_STATE_UNIT |
      COGL_PIPELINE_LAYER_STATE_FRAGMENT_SNIPPETS);
 
-  /* If the driver supports GLSL then we might be using gl_PointCoord
+  /* Since the driver supports GLSL then we might be using gl_PointCoord
    * to implement the sprite coords. In that case the generated code
    * depends on the point sprite state */
-  if (cogl_has_feature (context, COGL_FEATURE_ID_GLSL))
-    state |= COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS;
+  state |= COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS;
 
   return state;
 }

cogl/cogl/cogl-primitive-texture.h

@@ -42,14 +42,13 @@ G_BEGIN_DECLS
 /**
  * SECTION:cogl-primitive-texture
  * @short_description: Interface for low-level textures like
- *                     #CoglTexture2D and #CoglTexture3D.
+ *                     #CoglTexture2D.
  *
  * A #CoglPrimitiveTexture is a texture that is directly represented
- * by a single texture on the GPU. For example these could be a
- * #CoglTexture2D, #CoglTexture3D or #CoglTextureRectangle. This is
- * opposed to high level meta textures which may be composed of
- * multiple primitive textures or a sub-region of another texture such
- * as #CoglAtlasTexture and #CoglTexture2DSliced.
+ * by a single texture on the GPU. For example this could be a
+ * #CoglTexture2D. This is opposed to high level meta textures which
+ * may be composed of multiple primitive textures or a sub-region of
+ * another texture such as #CoglAtlasTexture and #CoglTexture2DSliced.
  *
  * A texture that implements this interface can be directly used with
  * the low level cogl_primitive_draw() API. Other types of textures

cogl/cogl/cogl-primitive.h

@@ -926,8 +926,8 @@ cogl_primitive_foreach_attribute (CoglPrimitive *primitive,
  * This drawing api doesn't support high-level meta texture types such
  * as #CoglTexture2DSliced so it is the user's responsibility to
  * ensure that only low-level textures that can be directly sampled by
- * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
- * are associated with layers of the given @pipeline.
+ * a GPU such as #CoglTexture2D are associated with layers of the given
+ * @pipeline.
  *
  * Stability: unstable
  * Since: 1.16

cogl/cogl/cogl-primitives.c

@@ -187,8 +187,6 @@ validate_first_layer_cb (CoglPipeline *pipeline,
  *   texture coordinates require repeating,
  * - CoglTexture2DAtlas: if the users given texture coordinates require
  *   repeating,
- * - CoglTextureRectangle: if the users given texture coordinates require
- *   repeating,
  * - CoglTexturePixmap: if the users given texture coordinates require
  *   repeating
  */
@@ -427,11 +425,9 @@ validate_tex_coords_cb (CoglPipeline *pipeline,
  * - CoglTexture2DSliced: if only comprised of a single slice with optional
  *   waste, assuming the users given texture coordinates don't require
  *   repeating.
- * - CoglTexture{1D,2D,3D}: always.
+ * - CoglTexture{1D,2D}: always.
  * - CoglTexture2DAtlas: assuming the users given texture coordinates don't
  *   require repeating.
- * - CoglTextureRectangle: assuming the users given texture coordinates don't
- *   require repeating.
  * - CoglTexturePixmap: assuming the users given texture coordinates don't
  *   require repeating.
  */

cogl/cogl/cogl-renderer.c

@@ -784,8 +784,7 @@ cogl_renderer_get_n_fragment_texture_units (CoglRenderer *renderer)
   _COGL_GET_CONTEXT (ctx, 0);
 
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES2)
-  if (cogl_has_feature (ctx, COGL_FEATURE_ID_GLSL))
-    GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_IMAGE_UNITS, &n));
+  GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_IMAGE_UNITS, &n));
 #endif
 
   return n;

cogl/cogl/cogl-sub-texture.c

@@ -40,7 +40,6 @@
 #include "cogl-context-private.h"
 #include "cogl-object.h"
 #include "cogl-texture-driver.h"
-#include "cogl-texture-rectangle-private.h"
 #include "cogl-texture-2d.h"
 #include "cogl-gtype-private.h"
 #include "driver/gl/cogl-texture-gl-private.h"
@@ -60,30 +59,13 @@ _cogl_sub_texture_unmap_quad (CoglSubTexture *sub_tex,
                               float *coords)
 {
   CoglTexture *tex = COGL_TEXTURE (sub_tex);
+  float width = cogl_texture_get_width (sub_tex->full_texture);
+  float height = cogl_texture_get_height (sub_tex->full_texture);
 
-  /* 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.
-   *
-   * NB: sub_tex->sub_x/y/width/height are in non-normalized
-   * coordinates.
-   */
-  if (cogl_is_texture_rectangle (sub_tex->full_texture))
-    {
-      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) / 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;
-    }
+  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;
 }
 
 static void
@@ -91,31 +73,13 @@ _cogl_sub_texture_map_quad (CoglSubTexture *sub_tex,
                             float *coords)
 {
   CoglTexture *tex = COGL_TEXTURE (sub_tex);
+  float width = cogl_texture_get_width (sub_tex->full_texture);
+  float height = cogl_texture_get_height (sub_tex->full_texture);
 
-  /* NB: coords[] always come in as normalized coordinates but may go
-   * out as non-normalized if sub_tex->full_texture is a
-   * CoglTextureRectangle.
-   *
-   * NB: sub_tex->sub_x/y/width/height are in non-normalized
-   * coordinates.
-   */
-
-  if (cogl_is_texture_rectangle (sub_tex->full_texture))
-    {
-      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] * 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;
-    }
+  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;
 }
 
 typedef struct _CoglSubTextureForeachData
@@ -165,8 +129,7 @@ _cogl_sub_texture_foreach_sub_texture_in_region (
   _cogl_sub_texture_map_quad (sub_tex, mapped_coords);
 
   /* TODO: Add something like cogl_is_low_level_texture() */
-  if (cogl_is_texture_2d (full_texture) ||
-      cogl_is_texture_rectangle (full_texture))
+  if (cogl_is_texture_2d (full_texture))
     {
       callback (sub_tex->full_texture,
                 mapped_coords,
@@ -452,14 +415,6 @@ _cogl_sub_texture_get_gl_format (CoglTexture *tex)
   return _cogl_texture_gl_get_format (sub_tex->full_texture);
 }
 
-static CoglTextureType
-_cogl_sub_texture_get_type (CoglTexture *tex)
-{
-  CoglSubTexture *sub_tex = COGL_SUB_TEXTURE (tex);
-
-  return _cogl_texture_get_type (sub_tex->full_texture);
-}
-
 static const CoglTextureVtable
 cogl_sub_texture_vtable =
   {
@@ -481,7 +436,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_type,
     NULL, /* is_foreign */
     NULL /* set_auto_mipmap */
   };

cogl/cogl/cogl-texture-2d-sliced.c

@@ -585,65 +585,6 @@ _cogl_rect_slices_for_size (int     size_to_fill,
   return n_spans;
 }
 
-static int
-_cogl_pot_slices_for_size (int    size_to_fill,
-                           int    max_span_size,
-                           int    max_waste,
-                           GArray *out_spans)
-{
-  int      n_spans = 0;
-  CoglSpan span;
-
-  /* Init first slice span */
-  span.start = 0;
-  span.size = max_span_size;
-  span.waste = 0;
-
-  /* Fix invalid max_waste */
-  if (max_waste < 0)
-    max_waste = 0;
-
-  while (TRUE)
-    {
-      /* Is the whole area covered? */
-      if (size_to_fill > span.size)
-        {
-          /* Not yet - add a span of this size */
-          if (out_spans)
-            g_array_append_val (out_spans, span);
-
-          span.start   += span.size;
-          size_to_fill -= span.size;
-          n_spans++;
-        }
-      else if (span.size - size_to_fill <= max_waste)
-        {
-          /* Yes and waste is small enough */
-          /* Pick the next power of two up from size_to_fill. This can
-             sometimes be less than the span.size that would be chosen
-             otherwise */
-          span.size = _cogl_util_next_p2 (size_to_fill);
-          span.waste = span.size - size_to_fill;
-          if (out_spans)
-            g_array_append_val (out_spans, span);
-
-          return ++n_spans;
-        }
-      else
-        {
-          /* Yes but waste is too large */
-          while (span.size - size_to_fill > max_waste)
-            {
-              span.size /= 2;
-              g_assert (span.size > 0);
-            }
-        }
-    }
-
-  /* Can't get here */
-  return 0;
-}
-
 static void
 _cogl_texture_2d_sliced_gl_flush_legacy_texobj_wrap_modes (CoglTexture *tex,
                                                            GLenum wrap_mode_s,
@@ -700,18 +641,9 @@ setup_spans (CoglContext *ctx,
   int   (*slices_for_size) (int, int, int, GArray*);
 
   /* Initialize size of largest slice according to supported features */
-  if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT))
-    {
-      max_width = width;
-      max_height = height;
-      slices_for_size = _cogl_rect_slices_for_size;
-    }
-  else
-    {
-      max_width = _cogl_util_next_p2 (width);
-      max_height = _cogl_util_next_p2 (height);
-      slices_for_size = _cogl_pot_slices_for_size;
-    }
+  max_width = width;
+  max_height = height;
+  slices_for_size = _cogl_rect_slices_for_size;
 
   /* Negative number means no slicing forced by the user */
   if (max_waste <= -1)
@@ -999,9 +931,7 @@ _cogl_texture_2d_sliced_new_from_foreign (CoglContext *ctx,
    * in GLES, hence such a function prototype.
    */
 
-  /* This should only be called when the texture target is 2D. If a
-     rectangle texture is used then _cogl_texture_new_from_foreign
-     will create a cogl_texture_rectangle instead */
+  /* This should only be called when the texture target is 2D. */
   _COGL_RETURN_VAL_IF_FAIL (gl_target == GL_TEXTURE_2D, NULL);
 
   /* Assert it is a valid GL texture object */
@@ -1512,12 +1442,6 @@ _cogl_texture_2d_sliced_get_gl_format (CoglTexture *tex)
   return _cogl_texture_gl_get_format (COGL_TEXTURE (slice_tex));
 }
 
-static CoglTextureType
-_cogl_texture_2d_sliced_get_type (CoglTexture *tex)
-{
-  return COGL_TEXTURE_TYPE_2D;
-}
-
 static const CoglTextureVtable
 cogl_texture_2d_sliced_vtable =
   {
@@ -1539,7 +1463,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_type,
     _cogl_texture_2d_sliced_is_foreign,
     NULL /* set_auto_mipmap */
   };

cogl/cogl/cogl-texture-2d.c

@@ -505,14 +505,7 @@ _cogl_texture_2d_is_sliced (CoglTexture *tex)
 static gboolean
 _cogl_texture_2d_can_hardware_repeat (CoglTexture *tex)
 {
-  CoglContext *ctx = tex->context;
-
-  if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT) ||
-      (_cogl_util_is_pot (tex->width) &&
-       _cogl_util_is_pot (tex->height)))
-    return TRUE;
-  else
-    return FALSE;
+  return TRUE;
 }
 
 static void
@@ -674,12 +667,6 @@ _cogl_texture_2d_is_foreign (CoglTexture *tex)
   return COGL_TEXTURE_2D (tex)->is_foreign;
 }
 
-static CoglTextureType
-_cogl_texture_2d_get_type (CoglTexture *tex)
-{
-  return COGL_TEXTURE_TYPE_2D;
-}
-
 static const CoglTextureVtable
 cogl_texture_2d_vtable =
   {
@@ -701,7 +688,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_type,
     _cogl_texture_2d_is_foreign,
     _cogl_texture_2d_set_auto_mipmap
   };

cogl/cogl/cogl-texture-2d.h

@@ -55,11 +55,6 @@ G_BEGIN_DECLS
  * made up of multiple 2D textures, or atlas textures where Cogl must
  * internally modify user texture coordinates before they can be used
  * by the GPU.
- *
- * You should be aware that many GPUs only support power of two sizes
- * for #CoglTexture2D textures. You can check support for non power of
- * two textures by checking for the %COGL_FEATURE_ID_TEXTURE_NPOT feature
- * via cogl_has_feature().
  */
 
 typedef struct _CoglTexture2D CoglTexture2D;
@@ -105,11 +100,6 @@ cogl_is_texture_2d (void *object);
  * using cogl_texture_set_components() and
  * cogl_texture_set_premultiplied().
  *
- * <note>Many GPUs only support power of two sizes for #CoglTexture2D
- * textures. You can check support for non power of two textures by
- * checking for the %COGL_FEATURE_ID_TEXTURE_NPOT feature via
- * cogl_has_feature().</note>
- *
  * Returns: (transfer full): A new #CoglTexture2D object with no storage yet allocated.
  *
  * Since: 2.0
@@ -138,11 +128,6 @@ cogl_texture_2d_new_with_size (CoglContext *ctx,
  * using cogl_texture_set_components() and
  * cogl_texture_set_premultiplied().
  *
- * <note>Many GPUs only support power of two sizes for #CoglTexture2D
- * textures. You can check support for non power of two textures by
- * checking for the %COGL_FEATURE_ID_TEXTURE_NPOT feature via
- * cogl_has_feature().</note>
- *
  * Return value: (transfer full): A newly created #CoglTexture2D or %NULL on failure
  *               and @error will be updated.
  *
@@ -179,11 +164,6 @@ cogl_texture_2d_new_from_file (CoglContext *ctx,
  * cogl_texture_2d_new_with_size() and then upload data using
  * cogl_texture_set_data()</note>
  *
- * <note>Many GPUs only support power of two sizes for #CoglTexture2D
- * textures. You can check support for non power of two textures by
- * checking for the %COGL_FEATURE_ID_TEXTURE_NPOT feature via
- * cogl_has_feature().</note>
- *
  * Returns: (transfer full): A newly allocated #CoglTexture2D, or if
  *          the size is not supported (because it is too large or a
  *          non-power-of-two size that the hardware doesn't support)
@@ -218,11 +198,6 @@ cogl_texture_2d_new_from_data (CoglContext *ctx,
  * using cogl_texture_set_components() and
  * cogl_texture_set_premultiplied().
  *
- * <note>Many GPUs only support power of two sizes for #CoglTexture2D
- * textures. You can check support for non power of two textures by
- * checking for the %COGL_FEATURE_ID_TEXTURE_NPOT feature via
- * cogl_has_feature().</note>
- *
  * Returns: (transfer full): A newly allocated #CoglTexture2D
  *
  * Since: 2.0

cogl/cogl/cogl-texture-3d-private.h

@@ -1,66 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * 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:
- *   Neil Roberts <neil@linux.intel.com>
- */
-
-#ifndef __COGL_TEXTURE_3D_PRIVATE_H
-#define __COGL_TEXTURE_3D_PRIVATE_H
-
-#include "cogl-object-private.h"
-#include "cogl-pipeline-private.h"
-#include "cogl-texture-private.h"
-#include "cogl-texture-3d.h"
-
-struct _CoglTexture3D
-{
-  CoglTexture _parent;
-
-  /* The internal format of the texture represented as a
-     CoglPixelFormat */
-  CoglPixelFormat internal_format;
-  int depth;
-  gboolean auto_mipmap;
-  gboolean mipmaps_dirty;
-
-  /* TODO: factor out these OpenGL specific members into some form
-   * of driver private state. */
-
-  /* The internal format of the GL texture represented as a GL enum */
-  GLenum gl_format;
-  /* The texture object number */
-  GLuint gl_texture;
-  GLenum gl_legacy_texobj_min_filter;
-  GLenum gl_legacy_texobj_mag_filter;
-  GLint gl_legacy_texobj_wrap_mode_s;
-  GLint gl_legacy_texobj_wrap_mode_t;
-  GLint gl_legacy_texobj_wrap_mode_p;
-  CoglTexturePixel first_pixel;
-};
-
-#endif /* __COGL_TEXTURE_3D_PRIVATE_H */

cogl/cogl/cogl-texture-3d.c

@@ -1,758 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * 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:
- *  Neil Roberts   <neil@linux.intel.com>
- */
-
-#include "cogl-config.h"
-
-#include "cogl-private.h"
-#include "cogl-util.h"
-#include "cogl-texture-private.h"
-#include "cogl-texture-3d-private.h"
-#include "cogl-texture-3d.h"
-#include "cogl-texture-driver.h"
-#include "cogl-context-private.h"
-#include "cogl-object-private.h"
-#include "cogl-journal-private.h"
-#include "cogl-pipeline-private.h"
-#include "cogl-error-private.h"
-#include "cogl-gtype-private.h"
-#include "driver/gl/cogl-texture-gl-private.h"
-#include "driver/gl/cogl-pipeline-opengl-private.h"
-#include "driver/gl/cogl-util-gl-private.h"
-
-#include <string.h>
-#include <math.h>
-
-/* These might not be defined on GLES */
-#ifndef GL_TEXTURE_3D
-#define GL_TEXTURE_3D                           0x806F
-#endif
-#ifndef GL_TEXTURE_WRAP_R
-#define GL_TEXTURE_WRAP_R                       0x8072
-#endif
-
-static void _cogl_texture_3d_free (CoglTexture3D *tex_3d);
-
-COGL_TEXTURE_DEFINE (Texture3D, texture_3d);
-COGL_GTYPE_DEFINE_CLASS (Texture3D, texture_3d,
-                         COGL_GTYPE_IMPLEMENT_INTERFACE (texture));
-
-static const CoglTextureVtable cogl_texture_3d_vtable;
-
-static void
-_cogl_texture_3d_gl_flush_legacy_texobj_wrap_modes (CoglTexture *tex,
-                                                    GLenum wrap_mode_s,
-                                                    GLenum wrap_mode_t,
-                                                    GLenum wrap_mode_p)
-{
-  CoglTexture3D *tex_3d = COGL_TEXTURE_3D (tex);
-  CoglContext *ctx = tex->context;
-
-  /* Only set the wrap mode if it's different from the current value
-     to avoid too many GL calls. */
-  if (tex_3d->gl_legacy_texobj_wrap_mode_s != wrap_mode_s ||
-      tex_3d->gl_legacy_texobj_wrap_mode_t != wrap_mode_t ||
-      tex_3d->gl_legacy_texobj_wrap_mode_p != wrap_mode_p)
-    {
-      _cogl_bind_gl_texture_transient (GL_TEXTURE_3D,
-                                       tex_3d->gl_texture,
-                                       FALSE);
-      GE( ctx, glTexParameteri (GL_TEXTURE_3D,
-                                GL_TEXTURE_WRAP_S,
-                                wrap_mode_s) );
-      GE( ctx, glTexParameteri (GL_TEXTURE_3D,
-                                GL_TEXTURE_WRAP_T,
-                                wrap_mode_t) );
-      GE( ctx, glTexParameteri (GL_TEXTURE_3D,
-                                GL_TEXTURE_WRAP_R,
-                                wrap_mode_p) );
-
-      tex_3d->gl_legacy_texobj_wrap_mode_s = wrap_mode_s;
-      tex_3d->gl_legacy_texobj_wrap_mode_t = wrap_mode_t;
-      tex_3d->gl_legacy_texobj_wrap_mode_p = wrap_mode_p;
-    }
-}
-
-static void
-_cogl_texture_3d_free (CoglTexture3D *tex_3d)
-{
-  if (tex_3d->gl_texture)
-    _cogl_delete_gl_texture (tex_3d->gl_texture);
-
-  /* Chain up */
-  _cogl_texture_free (COGL_TEXTURE (tex_3d));
-}
-
-static void
-_cogl_texture_3d_set_auto_mipmap (CoglTexture *tex,
-                                  gboolean value)
-{
-  CoglTexture3D *tex_3d = COGL_TEXTURE_3D (tex);
-
-  tex_3d->auto_mipmap = value;
-}
-
-static CoglTexture3D *
-_cogl_texture_3d_create_base (CoglContext *ctx,
-                              int width,
-                              int height,
-                              int depth,
-                              CoglPixelFormat internal_format,
-                              CoglTextureLoader *loader)
-{
-  CoglTexture3D *tex_3d = g_new (CoglTexture3D, 1);
-  CoglTexture *tex = COGL_TEXTURE (tex_3d);
-
-  _cogl_texture_init (tex, ctx, width, height,
-                      internal_format, loader, &cogl_texture_3d_vtable);
-
-  tex_3d->gl_texture = 0;
-
-  tex_3d->depth = depth;
-  tex_3d->mipmaps_dirty = TRUE;
-  tex_3d->auto_mipmap = TRUE;
-
-  /* We default to GL_LINEAR for both filters */
-  tex_3d->gl_legacy_texobj_min_filter = GL_LINEAR;
-  tex_3d->gl_legacy_texobj_mag_filter = GL_LINEAR;
-
-  /* Wrap mode not yet set */
-  tex_3d->gl_legacy_texobj_wrap_mode_s = GL_FALSE;
-  tex_3d->gl_legacy_texobj_wrap_mode_t = GL_FALSE;
-  tex_3d->gl_legacy_texobj_wrap_mode_p = GL_FALSE;
-
-  return _cogl_texture_3d_object_new (tex_3d);
-}
-
-CoglTexture3D *
-cogl_texture_3d_new_with_size (CoglContext *ctx,
-                               int width,
-                               int height,
-                               int depth)
-{
-  CoglTextureLoader *loader = _cogl_texture_create_loader ();
-  loader->src_type = COGL_TEXTURE_SOURCE_TYPE_SIZED;
-  loader->src.sized.width = width;
-  loader->src.sized.height = height;
-  loader->src.sized.depth = depth;
-
-  return _cogl_texture_3d_create_base (ctx, width, height, depth,
-                                       COGL_PIXEL_FORMAT_RGBA_8888_PRE,
-                                       loader);
-}
-
-CoglTexture3D *
-cogl_texture_3d_new_from_bitmap (CoglBitmap *bmp,
-                                 int height,
-                                 int depth)
-{
-  CoglTextureLoader *loader;
-
-  _COGL_RETURN_VAL_IF_FAIL (bmp, NULL);
-
-  loader = _cogl_texture_create_loader ();
-  loader->src_type = COGL_TEXTURE_SOURCE_TYPE_BITMAP;
-  loader->src.bitmap.bitmap = cogl_object_ref (bmp);
-  loader->src.bitmap.height = height;
-  loader->src.bitmap.depth = depth;
-  loader->src.bitmap.can_convert_in_place = FALSE; /* TODO add api for this */
-
-  return _cogl_texture_3d_create_base (_cogl_bitmap_get_context (bmp),
-                                       cogl_bitmap_get_width (bmp),
-                                       height,
-                                       depth,
-                                       cogl_bitmap_get_format (bmp),
-                                       loader);
-}
-
-CoglTexture3D *
-cogl_texture_3d_new_from_data (CoglContext *context,
-                               int width,
-                               int height,
-                               int depth,
-                               CoglPixelFormat format,
-                               int rowstride,
-                               int image_stride,
-                               const uint8_t *data,
-                               CoglError **error)
-{
-  CoglBitmap *bitmap;
-  CoglTexture3D *ret;
-
-  _COGL_RETURN_VAL_IF_FAIL (data, NULL);
-  _COGL_RETURN_VAL_IF_FAIL (format != COGL_PIXEL_FORMAT_ANY, NULL);
-
-  /* Rowstride from width if not given */
-  if (rowstride == 0)
-    rowstride = width * _cogl_pixel_format_get_bytes_per_pixel (format);
-  /* Image stride from height and rowstride if not given */
-  if (image_stride == 0)
-    image_stride = height * rowstride;
-
-  if (image_stride < rowstride * height)
-    return NULL;
-
-  /* GL doesn't support uploading when the image_stride isn't a
-     multiple of the rowstride. If this happens we'll just pack the
-     image into a new bitmap. The documentation for this function
-     recommends avoiding this situation. */
-  if (image_stride % rowstride != 0)
-    {
-      uint8_t *bmp_data;
-      int bmp_rowstride;
-      int z, y;
-
-      bitmap = _cogl_bitmap_new_with_malloc_buffer (context,
-                                                    width,
-                                                    depth * height,
-                                                    format,
-                                                    error);
-      if (!bitmap)
-        return NULL;
-
-      bmp_data = _cogl_bitmap_map (bitmap,
-                                   COGL_BUFFER_ACCESS_WRITE,
-                                   COGL_BUFFER_MAP_HINT_DISCARD,
-                                   error);
-
-      if (bmp_data == NULL)
-        {
-          cogl_object_unref (bitmap);
-          return NULL;
-        }
-
-      bmp_rowstride = cogl_bitmap_get_rowstride (bitmap);
-
-      /* Copy all of the images in */
-      for (z = 0; z < depth; z++)
-        for (y = 0; y < height; y++)
-          memcpy (bmp_data + (z * bmp_rowstride * height +
-                              bmp_rowstride * y),
-                  data + z * image_stride + rowstride * y,
-                  bmp_rowstride);
-
-      _cogl_bitmap_unmap (bitmap);
-    }
-  else
-    bitmap = cogl_bitmap_new_for_data (context,
-                                       width,
-                                       image_stride / rowstride * depth,
-                                       format,
-                                       rowstride,
-                                       (uint8_t *) data);
-
-  ret = cogl_texture_3d_new_from_bitmap (bitmap,
-                                         height,
-                                         depth);
-
-  cogl_object_unref (bitmap);
-
-  if (ret &&
-      !cogl_texture_allocate (COGL_TEXTURE (ret), error))
-    {
-      cogl_object_unref (ret);
-      return NULL;
-    }
-
-  return ret;
-}
-
-static gboolean
-_cogl_texture_3d_can_create (CoglContext *ctx,
-                             int width,
-                             int height,
-                             int depth,
-                             CoglPixelFormat internal_format,
-                             CoglError **error)
-{
-  GLenum gl_intformat;
-  GLenum gl_type;
-
-  /* This should only happen on GLES */
-  if (!cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_3D))
-    {
-      _cogl_set_error (error,
-                       COGL_SYSTEM_ERROR,
-                       COGL_SYSTEM_ERROR_UNSUPPORTED,
-                       "3D textures are not supported by the GPU");
-      return FALSE;
-    }
-
-  /* If NPOT textures aren't supported then the size must be a power
-     of two */
-  if (!cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT) &&
-      (!_cogl_util_is_pot (width) ||
-       !_cogl_util_is_pot (height) ||
-       !_cogl_util_is_pot (depth)))
-    {
-      _cogl_set_error (error,
-                       COGL_SYSTEM_ERROR,
-                       COGL_SYSTEM_ERROR_UNSUPPORTED,
-                       "A non-power-of-two size was requested but this is not "
-                       "supported by the GPU");
-      return FALSE;
-    }
-
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          internal_format,
-                                          &gl_intformat,
-                                          NULL,
-                                          &gl_type);
-
-  /* Check that the driver can create a texture with that size */
-  if (!ctx->texture_driver->size_supported_3d (ctx,
-                                               GL_TEXTURE_3D,
-                                               gl_intformat,
-                                               gl_type,
-                                               width,
-                                               height,
-                                               depth))
-    {
-      _cogl_set_error (error,
-                       COGL_SYSTEM_ERROR,
-                       COGL_SYSTEM_ERROR_UNSUPPORTED,
-                       "The requested dimensions are not supported by the GPU");
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-static gboolean
-allocate_with_size (CoglTexture3D *tex_3d,
-                    CoglTextureLoader *loader,
-                    CoglError **error)
-{
-  CoglTexture *tex = COGL_TEXTURE (tex_3d);
-  CoglContext *ctx = tex->context;
-  CoglPixelFormat internal_format;
-  int width = loader->src.sized.width;
-  int height = loader->src.sized.height;
-  int depth = loader->src.sized.depth;
-  GLenum gl_intformat;
-  GLenum gl_format;
-  GLenum gl_type;
-  GLenum gl_texture;
-
-  internal_format =
-    _cogl_texture_determine_internal_format (tex, COGL_PIXEL_FORMAT_ANY);
-
-  if (!_cogl_texture_3d_can_create (ctx,
-                                    width,
-                                    height,
-                                    depth,
-                                    internal_format,
-                                    error))
-    return FALSE;
-
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          internal_format,
-                                          &gl_intformat,
-                                          &gl_format,
-                                          &gl_type);
-
-  gl_texture =
-    ctx->texture_driver->gen (ctx, GL_TEXTURE_3D, internal_format);
-  _cogl_bind_gl_texture_transient (GL_TEXTURE_3D,
-                                   gl_texture,
-                                   FALSE);
-  /* Clear any GL errors */
-  _cogl_gl_util_clear_gl_errors (ctx);
-
-  ctx->glTexImage3D (GL_TEXTURE_3D, 0, gl_intformat,
-                     width, height, depth,
-                     0, gl_format, gl_type, NULL);
-
-  if (_cogl_gl_util_catch_out_of_memory (ctx, error))
-    {
-      GE( ctx, glDeleteTextures (1, &gl_texture) );
-      return FALSE;
-    }
-
-  tex_3d->gl_texture = gl_texture;
-  tex_3d->gl_format = gl_intformat;
-
-  tex_3d->depth = depth;
-
-  tex_3d->internal_format = internal_format;
-
-  _cogl_texture_set_allocated (tex, internal_format, width, height);
-
-  return TRUE;
-}
-
-static gboolean
-allocate_from_bitmap (CoglTexture3D *tex_3d,
-                      CoglTextureLoader *loader,
-                      CoglError **error)
-{
-  CoglTexture *tex = COGL_TEXTURE (tex_3d);
-  CoglContext *ctx = tex->context;
-  CoglPixelFormat internal_format;
-  CoglBitmap *bmp = loader->src.bitmap.bitmap;
-  int bmp_width = cogl_bitmap_get_width (bmp);
-  int height = loader->src.bitmap.height;
-  int depth = loader->src.bitmap.depth;
-  CoglPixelFormat bmp_format = cogl_bitmap_get_format (bmp);
-  gboolean can_convert_in_place = loader->src.bitmap.can_convert_in_place;
-  CoglBitmap *upload_bmp;
-  CoglPixelFormat upload_format;
-  GLenum gl_intformat;
-  GLenum gl_format;
-  GLenum gl_type;
-
-  internal_format = _cogl_texture_determine_internal_format (tex, bmp_format);
-
-  if (!_cogl_texture_3d_can_create (ctx,
-                                    bmp_width, height, depth,
-                                    internal_format,
-                                    error))
-    return FALSE;
-
-  upload_bmp = _cogl_bitmap_convert_for_upload (bmp,
-                                                internal_format,
-                                                can_convert_in_place,
-                                                error);
-  if (upload_bmp == NULL)
-    return FALSE;
-
-  upload_format = cogl_bitmap_get_format (upload_bmp);
-
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          upload_format,
-                                          NULL, /* internal format */
-                                          &gl_format,
-                                          &gl_type);
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          internal_format,
-                                          &gl_intformat,
-                                          NULL,
-                                          NULL);
-
-  /* Keep a copy of the first pixel so that if glGenerateMipmap isn't
-     supported we can fallback to using GL_GENERATE_MIPMAP */
-  if (!cogl_has_feature (ctx, COGL_FEATURE_ID_OFFSCREEN))
-    {
-      CoglError *ignore = NULL;
-      uint8_t *data = _cogl_bitmap_map (upload_bmp,
-                                        COGL_BUFFER_ACCESS_READ, 0,
-                                        &ignore);
-
-      tex_3d->first_pixel.gl_format = gl_format;
-      tex_3d->first_pixel.gl_type = gl_type;
-
-      if (data)
-        {
-          memcpy (tex_3d->first_pixel.data, data,
-                  _cogl_pixel_format_get_bytes_per_pixel (upload_format));
-          _cogl_bitmap_unmap (upload_bmp);
-        }
-      else
-        {
-          g_warning ("Failed to read first pixel of bitmap for "
-                     "glGenerateMipmap fallback");
-          cogl_error_free (ignore);
-          memset (tex_3d->first_pixel.data, 0,
-                  _cogl_pixel_format_get_bytes_per_pixel (upload_format));
-        }
-    }
-
-  tex_3d->gl_texture =
-    ctx->texture_driver->gen (ctx, GL_TEXTURE_3D, internal_format);
-
-  if (!ctx->texture_driver->upload_to_gl_3d (ctx,
-                                             GL_TEXTURE_3D,
-                                             tex_3d->gl_texture,
-                                             FALSE, /* is_foreign */
-                                             height,
-                                             depth,
-                                             upload_bmp,
-                                             gl_intformat,
-                                             gl_format,
-                                             gl_type,
-                                             error))
-    {
-      cogl_object_unref (upload_bmp);
-      return FALSE;
-    }
-
-  tex_3d->gl_format = gl_intformat;
-
-  cogl_object_unref (upload_bmp);
-
-  tex_3d->depth = loader->src.bitmap.depth;
-
-  tex_3d->internal_format = internal_format;
-
-  _cogl_texture_set_allocated (tex, internal_format,
-                               bmp_width, loader->src.bitmap.height);
-
-  return TRUE;
-}
-
-static gboolean
-_cogl_texture_3d_allocate (CoglTexture *tex,
-                           CoglError **error)
-{
-  CoglTexture3D *tex_3d = COGL_TEXTURE_3D (tex);
-  CoglTextureLoader *loader = tex->loader;
-
-  _COGL_RETURN_VAL_IF_FAIL (loader, FALSE);
-
-  switch (loader->src_type)
-    {
-    case COGL_TEXTURE_SOURCE_TYPE_SIZED:
-      return allocate_with_size (tex_3d, loader, error);
-    case COGL_TEXTURE_SOURCE_TYPE_BITMAP:
-      return allocate_from_bitmap (tex_3d, loader, error);
-    default:
-      break;
-    }
-
-  g_return_val_if_reached (FALSE);
-}
-
-static int
-_cogl_texture_3d_get_max_waste (CoglTexture *tex)
-{
-  return -1;
-}
-
-static gboolean
-_cogl_texture_3d_is_sliced (CoglTexture *tex)
-{
-  return FALSE;
-}
-
-static gboolean
-_cogl_texture_3d_can_hardware_repeat (CoglTexture *tex)
-{
-  return TRUE;
-}
-
-static void
-_cogl_texture_3d_transform_coords_to_gl (CoglTexture *tex,
-                                         float *s,
-                                         float *t)
-{
-  /* The texture coordinates map directly so we don't need to do
-     anything */
-}
-
-static CoglTransformResult
-_cogl_texture_3d_transform_quad_coords_to_gl (CoglTexture *tex,
-                                              float *coords)
-{
-  /* The texture coordinates map directly so we don't need to do
-     anything other than check for repeats */
-
-  gboolean need_repeat = FALSE;
-  int i;
-
-  for (i = 0; i < 4; i++)
-    if (coords[i] < 0.0f || coords[i] > 1.0f)
-      need_repeat = TRUE;
-
-  return (need_repeat ? COGL_TRANSFORM_HARDWARE_REPEAT
-          : COGL_TRANSFORM_NO_REPEAT);
-}
-
-static gboolean
-_cogl_texture_3d_get_gl_texture (CoglTexture *tex,
-                                 GLuint *out_gl_handle,
-                                 GLenum *out_gl_target)
-{
-  CoglTexture3D *tex_3d = COGL_TEXTURE_3D (tex);
-
-  if (out_gl_handle)
-    *out_gl_handle = tex_3d->gl_texture;
-
-  if (out_gl_target)
-    *out_gl_target = GL_TEXTURE_3D;
-
-  return TRUE;
-}
-
-static void
-_cogl_texture_3d_gl_flush_legacy_texobj_filters (CoglTexture *tex,
-                                                 GLenum min_filter,
-                                                 GLenum mag_filter)
-{
-  CoglTexture3D *tex_3d = COGL_TEXTURE_3D (tex);
-  CoglContext *ctx = tex->context;
-
-  if (min_filter == tex_3d->gl_legacy_texobj_min_filter
-      && mag_filter == tex_3d->gl_legacy_texobj_mag_filter)
-    return;
-
-  /* Store new values */
-  tex_3d->gl_legacy_texobj_min_filter = min_filter;
-  tex_3d->gl_legacy_texobj_mag_filter = mag_filter;
-
-  /* Apply new filters to the texture */
-  _cogl_bind_gl_texture_transient (GL_TEXTURE_3D,
-                                   tex_3d->gl_texture,
-                                   FALSE);
-  GE( ctx, glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, mag_filter) );
-  GE( ctx, glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, min_filter) );
-}
-
-static void
-_cogl_texture_3d_pre_paint (CoglTexture *tex, CoglTexturePrePaintFlags flags)
-{
-  CoglTexture3D *tex_3d = COGL_TEXTURE_3D (tex);
-  CoglContext *ctx = tex->context;
-
-  /* Only update if the mipmaps are dirty */
-  if ((flags & COGL_TEXTURE_NEEDS_MIPMAP) &&
-      tex_3d->auto_mipmap && tex_3d->mipmaps_dirty)
-    {
-      /* glGenerateMipmap is defined in the FBO extension. If it's not
-         available we'll fallback to temporarily enabling
-         GL_GENERATE_MIPMAP and reuploading the first pixel */
-      if (cogl_has_feature (ctx, COGL_FEATURE_ID_OFFSCREEN))
-        _cogl_texture_gl_generate_mipmaps (tex);
-#ifdef HAVE_COGL_GL
-      else if (_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_FIXED))
-        {
-          _cogl_bind_gl_texture_transient (GL_TEXTURE_3D,
-                                           tex_3d->gl_texture,
-                                           FALSE);
-
-          GE( ctx, glTexParameteri (GL_TEXTURE_3D,
-                                    GL_GENERATE_MIPMAP,
-                                    GL_TRUE) );
-          GE( ctx, glTexSubImage3D (GL_TEXTURE_3D,
-                                    0, /* level */
-                                    0, /* xoffset */
-                                    0, /* yoffset */
-                                    0, /* zoffset */
-                                    1, /* width */
-                                    1, /* height */
-                                    1, /* depth */
-                                    tex_3d->first_pixel.gl_format,
-                                    tex_3d->first_pixel.gl_type,
-                                    tex_3d->first_pixel.data) );
-          GE( ctx, glTexParameteri (GL_TEXTURE_3D,
-                                    GL_GENERATE_MIPMAP,
-                                    GL_FALSE) );
-        }
-#endif
-
-      tex_3d->mipmaps_dirty = FALSE;
-    }
-}
-
-static void
-_cogl_texture_3d_ensure_non_quad_rendering (CoglTexture *tex)
-{
-  /* Nothing needs to be done */
-}
-
-static gboolean
-_cogl_texture_3d_set_region (CoglTexture *tex,
-                             int src_x,
-                             int src_y,
-                             int dst_x,
-                             int dst_y,
-                             int dst_width,
-                             int dst_height,
-                             int level,
-                             CoglBitmap *bmp,
-                             CoglError **error)
-{
-  /* This function doesn't really make sense for 3D textures because
-     it can't specify which image to upload to */
-  _cogl_set_error (error,
-                   COGL_SYSTEM_ERROR,
-                   COGL_SYSTEM_ERROR_UNSUPPORTED,
-                   "Setting a 2D region on a 3D texture isn't "
-                   "currently supported");
-
-  return FALSE;
-}
-
-static int
-_cogl_texture_3d_get_data (CoglTexture *tex,
-                           CoglPixelFormat format,
-                           int rowstride,
-                           uint8_t *data)
-{
-  /* FIXME: we could probably implement this by assuming the data is
-     big enough to hold all of the images and that there is no stride
-     between the images. However it would be better to have an API
-     that can provide an image stride and this function probably isn't
-     particularly useful anyway so for now it just reports failure */
-  return 0;
-}
-
-static CoglPixelFormat
-_cogl_texture_3d_get_format (CoglTexture *tex)
-{
-  return COGL_TEXTURE_3D (tex)->internal_format;
-}
-
-static GLenum
-_cogl_texture_3d_get_gl_format (CoglTexture *tex)
-{
-  return COGL_TEXTURE_3D (tex)->gl_format;
-}
-
-static CoglTextureType
-_cogl_texture_3d_get_type (CoglTexture *tex)
-{
-  return COGL_TEXTURE_TYPE_3D;
-}
-
-static const CoglTextureVtable
-cogl_texture_3d_vtable =
-  {
-    TRUE, /* primitive */
-    _cogl_texture_3d_allocate,
-    _cogl_texture_3d_set_region,
-    NULL, /* is_get_data_supported */
-    _cogl_texture_3d_get_data,
-    NULL, /* foreach_sub_texture_in_region */
-    _cogl_texture_3d_get_max_waste,
-    _cogl_texture_3d_is_sliced,
-    _cogl_texture_3d_can_hardware_repeat,
-    _cogl_texture_3d_transform_coords_to_gl,
-    _cogl_texture_3d_transform_quad_coords_to_gl,
-    _cogl_texture_3d_get_gl_texture,
-    _cogl_texture_3d_gl_flush_legacy_texobj_filters,
-    _cogl_texture_3d_pre_paint,
-    _cogl_texture_3d_ensure_non_quad_rendering,
-    _cogl_texture_3d_gl_flush_legacy_texobj_wrap_modes,
-    _cogl_texture_3d_get_format,
-    _cogl_texture_3d_get_gl_format,
-    _cogl_texture_3d_get_type,
-    NULL, /* is_foreign */
-    _cogl_texture_3d_set_auto_mipmap
-  };

cogl/cogl/cogl-texture-3d.h

@@ -1,202 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * 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:
- *   Neil Roberts <neil@linux.intel.com>
- */
-
-#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
-#error "Only <cogl/cogl.h> can be included directly."
-#endif
-
-#ifndef __COGL_TEXTURE_3D_H
-#define __COGL_TEXTURE_3D_H
-
-G_BEGIN_DECLS
-
-/**
- * SECTION:cogl-texture-3d
- * @short_description: Functions for creating and manipulating 3D textures
- *
- * These functions allow 3D textures to be used. 3D textures can be
- * thought of as layers of 2D images arranged into a cuboid
- * shape. When choosing a texel from the texture, Cogl will take into
- * account the 'r' texture coordinate to select one of the images.
- */
-
-typedef struct _CoglTexture3D CoglTexture3D;
-
-#define COGL_TEXTURE_3D(X) ((CoglTexture3D *)X)
-
-/**
- * cogl_texture_3d_get_gtype:
- *
- * Returns: a #GType that can be used with the GLib type system.
- */
-GType cogl_texture_3d_get_gtype (void);
-
-/**
- * cogl_texture_3d_new_with_size:
- * @context: a #CoglContext
- * @width: width of the texture in pixels.
- * @height: height of the texture in pixels.
- * @depth: depth of the texture in pixels.
- *
- * Creates a low-level #CoglTexture3D texture with the specified
- * dimensions and pixel format.
- *
- * The storage for the texture is not allocated before this function
- * returns. You can call cogl_texture_allocate() to explicitly
- * allocate the underlying storage or preferably let Cogl
- * automatically allocate storage lazily when it may know more about
- * how the texture is going to be used and can optimize how it is
- * allocated.
- *
- * The texture is still configurable until it has been allocated so
- * for example you can influence the internal format of the texture
- * using cogl_texture_set_components() and
- * cogl_texture_set_premultiplied().
- *
- * <note>This texture will fail to allocate later if
- * %COGL_FEATURE_ID_TEXTURE_3D is not advertised. Allocation can also
- * fail if the requested dimensions are not supported by the
- * GPU.</note>
- *
- * Returns: (transfer full): A new #CoglTexture3D object with no storage yet allocated.
- * Since: 1.10
- * Stability: Unstable
- */
-CoglTexture3D *
-cogl_texture_3d_new_with_size (CoglContext *context,
-                               int width,
-                               int height,
-                               int depth);
-
-/**
- * cogl_texture_3d_new_from_data:
- * @context: a #CoglContext
- * @width: width of the texture in pixels.
- * @height: height of the texture in pixels.
- * @depth: depth of the texture in pixels.
- * @format: the #CoglPixelFormat the buffer is stored in in RAM
- * @rowstride: the memory offset in bytes between the starts of
- *    scanlines in @data or 0 to infer it from the width and format
- * @image_stride: the number of bytes from one image to the next. This
- *    can be used to add padding between the images in a similar way
- *    that the rowstride can be used to add padding between
- *    rows. Alternatively 0 can be passed to infer the @image_stride
- *    from the @height.
- * @data: pointer the memory region where the source buffer resides
- * @error: A CoglError return location.
- *
- * Creates a low-level 3D texture and initializes it with @data. The
- * data is assumed to be packed array of @depth images. There can be
- * padding between the images using @image_stride.
- *
- * <note>This api will always immediately allocate GPU memory for the
- * texture and upload the given data so that the @data pointer does
- * not need to remain valid once this function returns. This means it
- * is not possible to configure the texture before it is allocated. If
- * you do need to configure the texture before allocation (to specify
- * constraints on the internal format for example) then you can
- * instead create a #CoglBitmap for your data and use
- * cogl_texture_3d_new_from_bitmap().</note>
- *
- * Return value: (transfer full): the newly created #CoglTexture3D or
- *               %NULL if there was an error and an exception will be
- *               returned through @error.
- * Since: 1.10
- * Stability: Unstable
- */
-CoglTexture3D *
-cogl_texture_3d_new_from_data (CoglContext *context,
-                               int width,
-                               int height,
-                               int depth,
-                               CoglPixelFormat format,
-                               int rowstride,
-                               int image_stride,
-                               const uint8_t *data,
-                               CoglError **error);
-
-/**
- * cogl_texture_3d_new_from_bitmap:
- * @bitmap: A #CoglBitmap object.
- * @height: height of the texture in pixels.
- * @depth: depth of the texture in pixels.
- *
- * Creates a low-level 3D texture and initializes it with the images
- * in @bitmap. The images are assumed to be packed together after one
- * another in the increasing y axis. The height of individual image is
- * given as @height and the number of images is given in @depth. The
- * actual height of the bitmap can be larger than @height × @depth. In
- * this case it assumes there is padding between the images.
- *
- * The storage for the texture is not allocated before this function
- * returns. You can call cogl_texture_allocate() to explicitly
- * allocate the underlying storage or preferably let Cogl
- * automatically allocate storage lazily when it may know more about
- * how the texture is going to be used and can optimize how it is
- * allocated.
- *
- * The texture is still configurable until it has been allocated so
- * for example you can influence the internal format of the texture
- * using cogl_texture_set_components() and
- * cogl_texture_set_premultiplied().
- *
- * <note>This texture will fail to allocate later if
- * %COGL_FEATURE_ID_TEXTURE_3D is not advertised. Allocation can also
- * fail if the requested dimensions are not supported by the
- * GPU.</note>
- *
- * Return value: (transfer full): a newly created #CoglTexture3D
- * Since: 2.0
- * Stability: unstable
- */
-CoglTexture3D *
-cogl_texture_3d_new_from_bitmap (CoglBitmap *bitmap,
-                                 int height,
-                                 int depth);
-
-/**
- * cogl_is_texture_3d:
- * @object: a #CoglObject
- *
- * Checks whether the given object references a #CoglTexture3D
- *
- * Return value: %TRUE if the passed object represents a 3D texture
- *   and %FALSE otherwise
- *
- * Since: 1.4
- * Stability: Unstable
- */
-gboolean
-cogl_is_texture_3d (void *object);
-
-G_END_DECLS
-
-#endif /* __COGL_TEXTURE_3D_H */

cogl/cogl/cogl-texture-driver.h

@@ -103,26 +103,6 @@ struct _CoglTextureDriver
                     GLuint source_gl_type,
                     CoglError **error);
 
-  /*
-   * Replaces the contents of the GL texture with the entire bitmap. The
-   * width of the texture is inferred from the bitmap. The height and
-   * depth of the texture is given directly. The 'image_height' (which
-   * is the number of rows between images) is inferred by dividing the
-   * height of the bitmap by the depth.
-   */
-  gboolean
-  (* upload_to_gl_3d) (CoglContext *ctx,
-                       GLenum gl_target,
-                       GLuint gl_handle,
-                       gboolean is_foreign,
-                       GLint height,
-                       GLint depth,
-                       CoglBitmap *source_bmp,
-                       GLint internal_gl_format,
-                       GLuint source_gl_format,
-                       GLuint source_gl_type,
-                       CoglError **error);
-
   /*
    * This sets up the glPixelStore state for an download to a destination with
    * the same size, and with no offset.
@@ -162,15 +142,6 @@ struct _CoglTextureDriver
                       int width,
                       int height);
 
-  gboolean
-  (* size_supported_3d) (CoglContext *ctx,
-                         GLenum gl_target,
-                         GLenum gl_format,
-                         GLenum gl_type,
-                         int width,
-                         int height,
-                         int depth);
-
   /*
    * It may depend on the driver as to what texture targets may be used when
    * creating a foreign texture. E.g. OpenGL supports ARB_texture_rectangle

cogl/cogl/cogl-texture-private.h

@@ -146,8 +146,6 @@ struct _CoglTextureVtable
   CoglPixelFormat (* get_format) (CoglTexture *tex);
   GLenum (* get_gl_format) (CoglTexture *tex);
 
-  CoglTextureType (* get_type) (CoglTexture *tex);
-
   gboolean (* is_foreign) (CoglTexture *tex);
 
   /* Only needs to be implemented if is_primitive == TRUE */
@@ -354,18 +352,6 @@ _cogl_texture_spans_foreach_in_region (CoglSpan *x_spans,
                                        CoglMetaTextureCallback callback,
                                        void *user_data);
 
-/*
- * _cogl_texture_get_type:
- * @texture: a #CoglTexture pointer
- *
- * Retrieves the texture type of the underlying hardware texture that
- * this #CoglTexture will use.
- *
- * Return value: The type of the hardware texture.
- */
-CoglTextureType
-_cogl_texture_get_type (CoglTexture *texture);
-
 gboolean
 _cogl_texture_set_region (CoglTexture *texture,
                           int width,

cogl/cogl/cogl-texture-rectangle-private.h

@@ -1,66 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2009 Intel Corporation.
- *
- * 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 __COGL_TEXTURE_RECTANGLE_H
-#define __COGL_TEXTURE_RECTANGLE_H
-
-#include "cogl-pipeline-private.h"
-#include "cogl-texture-private.h"
-#include "cogl-texture-rectangle.h"
-
-struct _CoglTextureRectangle
-{
-  CoglTexture _parent;
-
-  /* The internal format of the texture represented as a
-     CoglPixelFormat */
-  CoglPixelFormat internal_format;
-
-  /* TODO: factor out these OpenGL specific members into some form
-   * of driver private state. */
-
-  /* The internal format of the GL texture represented as a GL enum */
-  GLenum gl_format;
-  /* The texture object number */
-  GLuint gl_texture;
-  GLenum gl_legacy_texobj_min_filter;
-  GLenum gl_legacy_texobj_mag_filter;
-  GLint gl_legacy_texobj_wrap_mode_s;
-  GLint gl_legacy_texobj_wrap_mode_t;
-  gboolean is_foreign;
-};
-
-CoglTextureRectangle *
-_cogl_texture_rectangle_new_from_foreign (GLuint gl_handle,
-                                          GLuint width,
-                                          GLuint height,
-                                          CoglPixelFormat format);
-
-#endif /* __COGL_TEXTURE_RECTANGLE_H */

cogl/cogl/cogl-texture-rectangle.c

@@ -1,776 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * 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:
- *  Neil Roberts   <neil@linux.intel.com>
- */
-
-#include "cogl-config.h"
-
-#include "cogl-private.h"
-#include "cogl-util.h"
-#include "cogl-texture-private.h"
-#include "cogl-texture-rectangle-private.h"
-#include "cogl-texture-driver.h"
-#include "cogl-context-private.h"
-#include "cogl-object-private.h"
-#include "cogl-journal-private.h"
-#include "cogl-error-private.h"
-#include "cogl-gtype-private.h"
-#include "driver/gl/cogl-pipeline-opengl-private.h"
-#include "driver/gl/cogl-util-gl-private.h"
-
-#include <string.h>
-#include <math.h>
-
-/* These aren't defined under GLES */
-#ifndef GL_TEXTURE_RECTANGLE_ARB
-#define GL_TEXTURE_RECTANGLE_ARB 0x84F5
-#endif
-#ifndef GL_CLAMP
-#define GL_CLAMP                 0x2900
-#endif
-#ifndef GL_CLAMP_TO_BORDER
-#define GL_CLAMP_TO_BORDER       0x812D
-#endif
-
-static void _cogl_texture_rectangle_free (CoglTextureRectangle *tex_rect);
-
-COGL_TEXTURE_DEFINE (TextureRectangle, texture_rectangle);
-COGL_GTYPE_DEFINE_CLASS (TextureRectangle, texture_rectangle,
-                         COGL_GTYPE_IMPLEMENT_INTERFACE (texture));
-
-static const CoglTextureVtable cogl_texture_rectangle_vtable;
-
-static gboolean
-can_use_wrap_mode (GLenum wrap_mode)
-{
-  return (wrap_mode == GL_CLAMP ||
-          wrap_mode == GL_CLAMP_TO_EDGE ||
-          wrap_mode == GL_CLAMP_TO_BORDER);
-}
-
-static void
-_cogl_texture_rectangle_gl_flush_legacy_texobj_wrap_modes (CoglTexture *tex,
-                                                           GLenum wrap_mode_s,
-                                                           GLenum wrap_mode_t,
-                                                           GLenum wrap_mode_p)
-{
-  CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
-  CoglContext *ctx = tex->context;
-
-  /* Only set the wrap mode if it's different from the current value
-     to avoid too many GL calls. Texture rectangle doesn't make use of
-     the r coordinate so we can ignore its wrap mode */
-  if (tex_rect->gl_legacy_texobj_wrap_mode_s != wrap_mode_s ||
-      tex_rect->gl_legacy_texobj_wrap_mode_t != wrap_mode_t)
-    {
-      g_assert (can_use_wrap_mode (wrap_mode_s));
-      g_assert (can_use_wrap_mode (wrap_mode_t));
-
-      _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
-                                       tex_rect->gl_texture,
-                                       tex_rect->is_foreign);
-      GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB,
-                                GL_TEXTURE_WRAP_S, wrap_mode_s) );
-      GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB,
-                                GL_TEXTURE_WRAP_T, wrap_mode_t) );
-
-      tex_rect->gl_legacy_texobj_wrap_mode_s = wrap_mode_s;
-      tex_rect->gl_legacy_texobj_wrap_mode_t = wrap_mode_t;
-    }
-}
-
-static void
-_cogl_texture_rectangle_free (CoglTextureRectangle *tex_rect)
-{
-  if (!tex_rect->is_foreign && tex_rect->gl_texture)
-    _cogl_delete_gl_texture (tex_rect->gl_texture);
-
-  /* Chain up */
-  _cogl_texture_free (COGL_TEXTURE (tex_rect));
-}
-
-static gboolean
-_cogl_texture_rectangle_can_create (CoglContext *ctx,
-                                    unsigned int width,
-                                    unsigned int height,
-                                    CoglPixelFormat internal_format,
-                                    CoglError **error)
-{
-  GLenum gl_intformat;
-  GLenum gl_format;
-  GLenum gl_type;
-
-  if (!cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_RECTANGLE))
-    {
-      _cogl_set_error (error,
-                       COGL_TEXTURE_ERROR,
-                       COGL_TEXTURE_ERROR_TYPE,
-                       "The CoglTextureRectangle feature isn't available");
-      return FALSE;
-    }
-
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          internal_format,
-                                          &gl_intformat,
-                                          &gl_format,
-                                          &gl_type);
-
-  /* Check that the driver can create a texture with that size */
-  if (!ctx->texture_driver->size_supported (ctx,
-                                            GL_TEXTURE_RECTANGLE_ARB,
-                                            gl_intformat,
-                                            gl_format,
-                                            gl_type,
-                                            width,
-                                            height))
-    {
-      _cogl_set_error (error,
-                       COGL_TEXTURE_ERROR,
-                       COGL_TEXTURE_ERROR_SIZE,
-                       "The requested texture size + format is unsupported");
-      return FALSE;
-    }
-
-  return TRUE;
-}
-
-static void
-_cogl_texture_rectangle_set_auto_mipmap (CoglTexture *tex,
-                                         gboolean value)
-{
-  /* Rectangle textures currently never support mipmapping so there's
-     no point in doing anything here */
-}
-
-static CoglTextureRectangle *
-_cogl_texture_rectangle_create_base (CoglContext *ctx,
-                                     int width,
-                                     int height,
-                                     CoglPixelFormat internal_format,
-                                     CoglTextureLoader *loader)
-{
-  CoglTextureRectangle *tex_rect = g_new (CoglTextureRectangle, 1);
-  CoglTexture *tex = COGL_TEXTURE (tex_rect);
-
-  _cogl_texture_init (tex, ctx, width, height,
-                      internal_format, loader,
-                      &cogl_texture_rectangle_vtable);
-
-  tex_rect->gl_texture = 0;
-  tex_rect->is_foreign = FALSE;
-
-  /* We default to GL_LINEAR for both filters */
-  tex_rect->gl_legacy_texobj_min_filter = GL_LINEAR;
-  tex_rect->gl_legacy_texobj_mag_filter = GL_LINEAR;
-
-  /* Wrap mode not yet set */
-  tex_rect->gl_legacy_texobj_wrap_mode_s = GL_FALSE;
-  tex_rect->gl_legacy_texobj_wrap_mode_t = GL_FALSE;
-
-  return _cogl_texture_rectangle_object_new (tex_rect);
-}
-
-CoglTextureRectangle *
-cogl_texture_rectangle_new_with_size (CoglContext *ctx,
-                                      int width,
-                                      int height)
-{
-  CoglTextureLoader *loader = _cogl_texture_create_loader ();
-  loader->src_type = COGL_TEXTURE_SOURCE_TYPE_SIZED;
-  loader->src.sized.width = width;
-  loader->src.sized.height = height;
-
-  return _cogl_texture_rectangle_create_base (ctx, width, height,
-                                              COGL_PIXEL_FORMAT_RGBA_8888_PRE,
-                                              loader);
-}
-
-static gboolean
-allocate_with_size (CoglTextureRectangle *tex_rect,
-                    CoglTextureLoader *loader,
-                    CoglError **error)
-{
-  CoglTexture *tex = COGL_TEXTURE (tex_rect);
-  CoglContext *ctx = tex->context;
-  CoglPixelFormat internal_format;
-  int width = loader->src.sized.width;
-  int height = loader->src.sized.height;
-  GLenum gl_intformat;
-  GLenum gl_format;
-  GLenum gl_type;
-  GLenum gl_texture;
-
-  internal_format =
-    _cogl_texture_determine_internal_format (tex, COGL_PIXEL_FORMAT_ANY);
-
-  if (!_cogl_texture_rectangle_can_create (ctx,
-                                           width,
-                                           height,
-                                           internal_format,
-                                           error))
-    return FALSE;
-
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          internal_format,
-                                          &gl_intformat,
-                                          &gl_format,
-                                          &gl_type);
-
-  gl_texture =
-    ctx->texture_driver->gen (ctx,
-                              GL_TEXTURE_RECTANGLE_ARB,
-                              internal_format);
-  _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
-                                   gl_texture,
-                                   tex_rect->is_foreign);
-
-  /* Clear any GL errors */
-  _cogl_gl_util_clear_gl_errors (ctx);
-
-  ctx->glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, gl_intformat,
-                     width, height, 0, gl_format, gl_type, NULL);
-
-  if (_cogl_gl_util_catch_out_of_memory (ctx, error))
-    {
-      GE( ctx, glDeleteTextures (1, &gl_texture) );
-      return FALSE;
-    }
-
-  tex_rect->internal_format = internal_format;
-
-  tex_rect->gl_texture = gl_texture;
-  tex_rect->gl_format = gl_intformat;
-
-  _cogl_texture_set_allocated (COGL_TEXTURE (tex_rect),
-                               internal_format, width, height);
-
-  return TRUE;
-}
-
-static gboolean
-allocate_from_bitmap (CoglTextureRectangle *tex_rect,
-                      CoglTextureLoader *loader,
-                      CoglError **error)
-{
-  CoglTexture *tex = COGL_TEXTURE (tex_rect);
-  CoglContext *ctx = tex->context;
-  CoglPixelFormat internal_format;
-  CoglBitmap *bmp = loader->src.bitmap.bitmap;
-  int width = cogl_bitmap_get_width (bmp);
-  int height = cogl_bitmap_get_height (bmp);
-  gboolean can_convert_in_place = loader->src.bitmap.can_convert_in_place;
-  CoglBitmap *upload_bmp;
-  GLenum gl_intformat;
-  GLenum gl_format;
-  GLenum gl_type;
-
-  internal_format =
-    _cogl_texture_determine_internal_format (tex, cogl_bitmap_get_format (bmp));
-
-  if (!_cogl_texture_rectangle_can_create (ctx,
-                                           width,
-                                           height,
-                                           internal_format,
-                                           error))
-    return FALSE;
-
-  upload_bmp = _cogl_bitmap_convert_for_upload (bmp,
-                                                internal_format,
-                                                can_convert_in_place,
-                                                error);
-  if (upload_bmp == NULL)
-    return FALSE;
-
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          cogl_bitmap_get_format (upload_bmp),
-                                          NULL, /* internal format */
-                                          &gl_format,
-                                          &gl_type);
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          internal_format,
-                                          &gl_intformat,
-                                          NULL,
-                                          NULL);
-
-  tex_rect->gl_texture =
-    ctx->texture_driver->gen (ctx,
-                              GL_TEXTURE_RECTANGLE_ARB,
-                              internal_format);
-  if (!ctx->texture_driver->upload_to_gl (ctx,
-                                          GL_TEXTURE_RECTANGLE_ARB,
-                                          tex_rect->gl_texture,
-                                          FALSE,
-                                          upload_bmp,
-                                          gl_intformat,
-                                          gl_format,
-                                          gl_type,
-                                          error))
-    {
-      cogl_object_unref (upload_bmp);
-      return FALSE;
-    }
-
-  tex_rect->gl_format = gl_intformat;
-  tex_rect->internal_format = internal_format;
-
-  cogl_object_unref (upload_bmp);
-
-  _cogl_texture_set_allocated (COGL_TEXTURE (tex_rect),
-                               internal_format, width, height);
-
-  return TRUE;
-}
-
-static gboolean
-allocate_from_gl_foreign (CoglTextureRectangle *tex_rect,
-                          CoglTextureLoader *loader,
-                          CoglError **error)
-{
-  CoglTexture *tex = COGL_TEXTURE (tex_rect);
-  CoglContext *ctx = tex->context;
-  CoglPixelFormat format = loader->src.gl_foreign.format;
-  GLint gl_compressed = GL_FALSE;
-  GLenum gl_int_format = 0;
-
-  if (!ctx->texture_driver->allows_foreign_gl_target (ctx,
-                                                      GL_TEXTURE_RECTANGLE_ARB))
-    {
-      _cogl_set_error (error,
-                       COGL_SYSTEM_ERROR,
-                       COGL_SYSTEM_ERROR_UNSUPPORTED,
-                       "Foreign GL_TEXTURE_RECTANGLE textures are not "
-                       "supported by your system");
-      return FALSE;
-    }
-
-  /* Make sure binding succeeds */
-  _cogl_gl_util_clear_gl_errors (ctx);
-
-  _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
-                                   loader->src.gl_foreign.gl_handle, TRUE);
-  if (_cogl_gl_util_get_error (ctx) != GL_NO_ERROR)
-    {
-      _cogl_set_error (error,
-                       COGL_SYSTEM_ERROR,
-                       COGL_SYSTEM_ERROR_UNSUPPORTED,
-                       "Failed to bind foreign GL_TEXTURE_RECTANGLE texture");
-      return FALSE;
-    }
-
-  /* Obtain texture parameters */
-
-#ifdef HAVE_COGL_GL
-  if (_cogl_has_private_feature
-      (ctx, COGL_PRIVATE_FEATURE_QUERY_TEXTURE_PARAMETERS))
-    {
-      GLint val;
-
-      GE( ctx, glGetTexLevelParameteriv (GL_TEXTURE_RECTANGLE_ARB, 0,
-                                         GL_TEXTURE_COMPRESSED,
-                                         &gl_compressed) );
-
-      GE( ctx, glGetTexLevelParameteriv (GL_TEXTURE_RECTANGLE_ARB, 0,
-                                         GL_TEXTURE_INTERNAL_FORMAT,
-                                         &val) );
-
-      gl_int_format = val;
-
-      /* If we can query GL for the actual pixel format then we'll ignore
-         the passed in format and use that. */
-      if (!ctx->driver_vtable->pixel_format_from_gl_internal (ctx,
-                                                              gl_int_format,
-                                                              &format))
-        {
-          _cogl_set_error (error,
-                           COGL_SYSTEM_ERROR,
-                           COGL_SYSTEM_ERROR_UNSUPPORTED,
-                           "Unsupported internal format for foreign texture");
-          return FALSE;
-        }
-    }
-  else
-#endif
-    {
-      /* Otherwise we'll assume we can derive the GL format from the
-         passed in format */
-      ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                              format,
-                                              &gl_int_format,
-                                              NULL,
-                                              NULL);
-    }
-
-  /* Compressed texture images not supported */
-  if (gl_compressed == GL_TRUE)
-    {
-      _cogl_set_error (error,
-                       COGL_SYSTEM_ERROR,
-                       COGL_SYSTEM_ERROR_UNSUPPORTED,
-                       "Compressed foreign textures aren't currently supported");
-      return FALSE;
-    }
-
-  /* Setup bitmap info */
-  tex_rect->is_foreign = TRUE;
-
-  tex_rect->gl_texture = loader->src.gl_foreign.gl_handle;
-  tex_rect->gl_format = gl_int_format;
-
-  /* Unknown filter */
-  tex_rect->gl_legacy_texobj_min_filter = GL_FALSE;
-  tex_rect->gl_legacy_texobj_mag_filter = GL_FALSE;
-
-  tex_rect->internal_format = format;
-
-  _cogl_texture_set_allocated (COGL_TEXTURE (tex_rect),
-                               format,
-                               loader->src.gl_foreign.width,
-                               loader->src.gl_foreign.height);
-
-  return TRUE;
-}
-
-static gboolean
-_cogl_texture_rectangle_allocate (CoglTexture *tex,
-                                  CoglError **error)
-{
-  CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
-  CoglTextureLoader *loader = tex->loader;
-
-  _COGL_RETURN_VAL_IF_FAIL (loader, FALSE);
-
-  switch (loader->src_type)
-    {
-    case COGL_TEXTURE_SOURCE_TYPE_SIZED:
-      return allocate_with_size (tex_rect, loader, error);
-    case COGL_TEXTURE_SOURCE_TYPE_BITMAP:
-      return allocate_from_bitmap (tex_rect, loader, error);
-    case COGL_TEXTURE_SOURCE_TYPE_GL_FOREIGN:
-      return allocate_from_gl_foreign (tex_rect, loader, error);
-    default:
-      break;
-    }
-
-  g_return_val_if_reached (FALSE);
-}
-
-CoglTextureRectangle *
-cogl_texture_rectangle_new_from_bitmap (CoglBitmap *bmp)
-{
-  CoglTextureLoader *loader;
-
-  _COGL_RETURN_VAL_IF_FAIL (cogl_is_bitmap (bmp), NULL);
-
-  loader = _cogl_texture_create_loader ();
-  loader->src_type = COGL_TEXTURE_SOURCE_TYPE_BITMAP;
-  loader->src.bitmap.bitmap = cogl_object_ref (bmp);
-  loader->src.bitmap.can_convert_in_place = FALSE; /* TODO add api for this */
-
-  return _cogl_texture_rectangle_create_base (_cogl_bitmap_get_context (bmp),
-                                              cogl_bitmap_get_width (bmp),
-                                              cogl_bitmap_get_height (bmp),
-                                              cogl_bitmap_get_format (bmp),
-                                              loader);
-}
-
-CoglTextureRectangle *
-cogl_texture_rectangle_new_from_foreign (CoglContext *ctx,
-                                         unsigned int gl_handle,
-                                         int width,
-                                         int height,
-                                         CoglPixelFormat format)
-{
-  CoglTextureLoader *loader;
-
-  /* NOTE: width, height and internal format are not queriable in
-   * GLES, hence such a function prototype. Also in the case of full
-   * opengl the user may be creating a Cogl texture for a
-   * texture_from_pixmap object where glTexImage2D may not have been
-   * called and the texture_from_pixmap spec doesn't clarify that it
-   * is reliable to query back the size from OpenGL.
-   */
-
-  /* Assert that it is a valid GL texture object */
-  _COGL_RETURN_VAL_IF_FAIL (ctx->glIsTexture (gl_handle), NULL);
-
-  /* Validate width and height */
-  _COGL_RETURN_VAL_IF_FAIL (width > 0 && height > 0, NULL);
-
-  loader = _cogl_texture_create_loader ();
-  loader->src_type = COGL_TEXTURE_SOURCE_TYPE_GL_FOREIGN;
-  loader->src.gl_foreign.gl_handle = gl_handle;
-  loader->src.gl_foreign.width = width;
-  loader->src.gl_foreign.height = height;
-  loader->src.gl_foreign.format = format;
-
-  return _cogl_texture_rectangle_create_base (ctx, width, height,
-                                              format, loader);
-}
-
-static int
-_cogl_texture_rectangle_get_max_waste (CoglTexture *tex)
-{
-  return -1;
-}
-
-static gboolean
-_cogl_texture_rectangle_is_sliced (CoglTexture *tex)
-{
-  return FALSE;
-}
-
-static gboolean
-_cogl_texture_rectangle_can_hardware_repeat (CoglTexture *tex)
-{
-  return FALSE;
-}
-
-static void
-_cogl_texture_rectangle_transform_coords_to_gl (CoglTexture *tex,
-                                                float *s,
-                                                float *t)
-{
-  *s *= tex->width;
-  *t *= tex->height;
-}
-
-static CoglTransformResult
-_cogl_texture_rectangle_transform_quad_coords_to_gl (CoglTexture *tex,
-                                                     float *coords)
-{
-  gboolean need_repeat = FALSE;
-  int i;
-
-  for (i = 0; i < 4; i++)
-    {
-      if (coords[i] < 0.0f || coords[i] > 1.0f)
-        need_repeat = TRUE;
-      coords[i] *= (i & 1) ? tex->height : tex->width;
-    }
-
-  return (need_repeat ? COGL_TRANSFORM_SOFTWARE_REPEAT
-          : COGL_TRANSFORM_NO_REPEAT);
-}
-
-static gboolean
-_cogl_texture_rectangle_get_gl_texture (CoglTexture *tex,
-                                        GLuint *out_gl_handle,
-                                        GLenum *out_gl_target)
-{
-  CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
-
-  if (out_gl_handle)
-    *out_gl_handle = tex_rect->gl_texture;
-
-  if (out_gl_target)
-    *out_gl_target = GL_TEXTURE_RECTANGLE_ARB;
-
-  return TRUE;
-}
-
-static void
-_cogl_texture_rectangle_gl_flush_legacy_texobj_filters (CoglTexture *tex,
-                                                        GLenum min_filter,
-                                                        GLenum mag_filter)
-{
-  CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
-  CoglContext *ctx = tex->context;
-
-  if (min_filter == tex_rect->gl_legacy_texobj_min_filter
-      && mag_filter == tex_rect->gl_legacy_texobj_mag_filter)
-    return;
-
-  /* Rectangle textures don't support mipmapping */
-  g_assert (min_filter == GL_LINEAR || min_filter == GL_NEAREST);
-
-  /* Store new values */
-  tex_rect->gl_legacy_texobj_min_filter = min_filter;
-  tex_rect->gl_legacy_texobj_mag_filter = mag_filter;
-
-  /* Apply new filters to the texture */
-  _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
-                                   tex_rect->gl_texture,
-                                   tex_rect->is_foreign);
-  GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER,
-                            mag_filter) );
-  GE( ctx, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER,
-                            min_filter) );
-}
-
-static void
-_cogl_texture_rectangle_pre_paint (CoglTexture *tex,
-                                   CoglTexturePrePaintFlags flags)
-{
-  /* Rectangle textures don't support mipmaps */
-  g_assert ((flags & COGL_TEXTURE_NEEDS_MIPMAP) == 0);
-}
-
-static void
-_cogl_texture_rectangle_ensure_non_quad_rendering (CoglTexture *tex)
-{
-  /* Nothing needs to be done */
-}
-
-static gboolean
-_cogl_texture_rectangle_set_region (CoglTexture *tex,
-                                    int src_x,
-                                    int src_y,
-                                    int dst_x,
-                                    int dst_y,
-                                    int dst_width,
-                                    int dst_height,
-                                    int level,
-                                    CoglBitmap *bmp,
-                                    CoglError **error)
-{
-  CoglBitmap *upload_bmp;
-  GLenum gl_format;
-  GLenum gl_type;
-  CoglContext *ctx = tex->context;
-  gboolean status;
-
-  upload_bmp =
-    _cogl_bitmap_convert_for_upload (bmp,
-                                     _cogl_texture_get_format (tex),
-                                     FALSE, /* can't convert in place */
-                                     error);
-  if (upload_bmp == NULL)
-    return FALSE;
-
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          cogl_bitmap_get_format (upload_bmp),
-                                          NULL, /* internal format */
-                                          &gl_format,
-                                          &gl_type);
-
-  /* Send data to GL */
-  status =
-    ctx->texture_driver->upload_subregion_to_gl (ctx,
-                                                 tex,
-                                                 FALSE,
-                                                 src_x, src_y,
-                                                 dst_x, dst_y,
-                                                 dst_width, dst_height,
-                                                 level,
-                                                 upload_bmp,
-                                                 gl_format,
-                                                 gl_type,
-                                                 error);
-
-  cogl_object_unref (upload_bmp);
-
-  return status;
-}
-
-static gboolean
-_cogl_texture_rectangle_get_data (CoglTexture *tex,
-                                  CoglPixelFormat format,
-                                  int rowstride,
-                                  uint8_t *data)
-{
-  CoglTextureRectangle *tex_rect = COGL_TEXTURE_RECTANGLE (tex);
-  CoglContext *ctx = tex->context;
-  int bpp;
-  GLenum gl_format;
-  GLenum gl_type;
-
-  bpp = _cogl_pixel_format_get_bytes_per_pixel (format);
-
-  ctx->driver_vtable->pixel_format_to_gl (ctx,
-                                          format,
-                                          NULL, /* internal format */
-                                          &gl_format,
-                                          &gl_type);
-
-  ctx->texture_driver->prep_gl_for_pixels_download (ctx,
-                                                    rowstride,
-                                                    tex->width,
-                                                    bpp);
-
-  _cogl_bind_gl_texture_transient (GL_TEXTURE_RECTANGLE_ARB,
-                                   tex_rect->gl_texture,
-                                   tex_rect->is_foreign);
-  return ctx->texture_driver->gl_get_tex_image (ctx,
-                                                GL_TEXTURE_RECTANGLE_ARB,
-                                                gl_format,
-                                                gl_type,
-                                                data);
-}
-
-static CoglPixelFormat
-_cogl_texture_rectangle_get_format (CoglTexture *tex)
-{
-  return COGL_TEXTURE_RECTANGLE (tex)->internal_format;
-}
-
-static GLenum
-_cogl_texture_rectangle_get_gl_format (CoglTexture *tex)
-{
-  return COGL_TEXTURE_RECTANGLE (tex)->gl_format;
-}
-
-static gboolean
-_cogl_texture_rectangle_is_foreign (CoglTexture *tex)
-{
-  return COGL_TEXTURE_RECTANGLE (tex)->is_foreign;
-}
-
-static CoglTextureType
-_cogl_texture_rectangle_get_type (CoglTexture *tex)
-{
-  return COGL_TEXTURE_TYPE_RECTANGLE;
-}
-
-static const CoglTextureVtable
-cogl_texture_rectangle_vtable =
-  {
-    TRUE, /* primitive */
-    _cogl_texture_rectangle_allocate,
-    _cogl_texture_rectangle_set_region,
-    NULL, /* is_get_data_supported */
-    _cogl_texture_rectangle_get_data,
-    NULL, /* foreach_sub_texture_in_region */
-    _cogl_texture_rectangle_get_max_waste,
-    _cogl_texture_rectangle_is_sliced,
-    _cogl_texture_rectangle_can_hardware_repeat,
-    _cogl_texture_rectangle_transform_coords_to_gl,
-    _cogl_texture_rectangle_transform_quad_coords_to_gl,
-    _cogl_texture_rectangle_get_gl_texture,
-    _cogl_texture_rectangle_gl_flush_legacy_texobj_filters,
-    _cogl_texture_rectangle_pre_paint,
-    _cogl_texture_rectangle_ensure_non_quad_rendering,
-    _cogl_texture_rectangle_gl_flush_legacy_texobj_wrap_modes,
-    _cogl_texture_rectangle_get_format,
-    _cogl_texture_rectangle_get_gl_format,
-    _cogl_texture_rectangle_get_type,
-    _cogl_texture_rectangle_is_foreign,
-    _cogl_texture_rectangle_set_auto_mipmap
-  };

cogl/cogl/cogl-texture-rectangle.h

@@ -1,216 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2011 Intel Corporation.
- *
- * 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:
- *   Robert Bragg <robert@linux.intel.com>
- */
-
-#ifndef __COGL_TEXURE_RECTANGLE_H
-#define __COGL_TEXURE_RECTANGLE_H
-
-#include "cogl-context.h"
-
-G_BEGIN_DECLS
-
-/**
- * SECTION:cogl-texture-rectangle
- * @short_description: Functions for creating and manipulating rectangle
- *                     textures for use with non-normalized coordinates.
- *
- * These functions allow low-level "rectangle" textures to be allocated.
- * These textures are never constrained to power-of-two sizes but they
- * also don't support having a mipmap and can only be wrapped with
- * %COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE.
- *
- * The most notable difference between rectangle textures and 2D
- * textures is that rectangle textures are sampled using un-normalized
- * texture coordinates, so instead of using coordinates (0,0) and
- * (1,1) to map to the top-left and bottom right corners of the
- * texture you would instead use (0,0) and (width,height).
- *
- * The use of non-normalized coordinates can be particularly
- * convenient when writing glsl shaders that use a texture as a lookup
- * table since you don't need to upload separate uniforms to map
- * normalized coordinates to texels.
- *
- * If you want to sample from a rectangle texture from GLSL you should
- * use the sampler2DRect sampler type.
- *
- * Applications wanting to use #CoglTextureRectangle should first check
- * for the %COGL_FEATURE_ID_TEXTURE_RECTANGLE feature using
- * cogl_has_feature().
- */
-
-typedef struct _CoglTextureRectangle CoglTextureRectangle;
-#define COGL_TEXTURE_RECTANGLE(X) ((CoglTextureRectangle *)X)
-
-/**
- * cogl_texture_rectangle_get_gtype:
- *
- * Returns: a #GType that can be used with the GLib type system.
- */
-GType cogl_texture_rectangle_get_gtype (void);
-
-/**
- * cogl_is_texture_rectangle:
- * @object: A #CoglObject
- *
- * Gets whether the given object references an existing
- * #CoglTextureRectangle object.
- *
- * Return value: %TRUE if the object references a
- *               #CoglTextureRectangle, %FALSE otherwise.
- */
-gboolean
-cogl_is_texture_rectangle (void *object);
-
-/**
- * cogl_texture_rectangle_new_with_size:
- * @ctx: A #CoglContext pointer
- * @width: The texture width to allocate
- * @height: The texture height to allocate
- *
- * Creates a new #CoglTextureRectangle texture with a given @width,
- * and @height. This texture is a low-level texture that the GPU can
- * sample from directly unlike high-level textures such as
- * #CoglTexture2DSliced and #CoglAtlasTexture.
- *
- * <note>Unlike for #CoglTexture2D textures, coordinates for
- * #CoglTextureRectangle textures should not be normalized. So instead
- * of using the coordinate (1, 1) to sample the bottom right corner of
- * a rectangle texture you would use (@width, @height) where @width
- * and @height are the width and height of the texture.</note>
- *
- * <note>If you want to sample from a rectangle texture from GLSL you
- * should use the sampler2DRect sampler type.</note>
- *
- * <note>Applications wanting to use #CoglTextureRectangle should
- * first check for the %COGL_FEATURE_ID_TEXTURE_RECTANGLE feature
- * using cogl_has_feature().</note>
- *
- * The storage for the texture is not allocated before this function
- * returns. You can call cogl_texture_allocate() to explicitly
- * allocate the underlying storage or preferably let Cogl
- * automatically allocate storage lazily when it may know more about
- * how the texture is going to be used and can optimize how it is
- * allocated.
- *
- * Returns value: (transfer full): A pointer to a new #CoglTextureRectangle
- *          object with no storage allocated yet.
- *
- * Since: 1.10
- * Stability: unstable
- */
-CoglTextureRectangle *
-cogl_texture_rectangle_new_with_size (CoglContext *ctx,
-                                      int width,
-                                      int height);
-
-/**
- * cogl_texture_rectangle_new_from_bitmap:
- * @bitmap: A #CoglBitmap
- *
- * Allocates a new #CoglTextureRectangle texture which will be
- * initialized with the pixel data from @bitmap. This texture is a
- * low-level texture that the GPU can sample from directly unlike
- * high-level textures such as #CoglTexture2DSliced and
- * #CoglAtlasTexture.
- *
- * <note>Unlike for #CoglTexture2D textures, coordinates for
- * #CoglTextureRectangle textures should not be normalized. So instead
- * of using the coordinate (1, 1) to sample the bottom right corner of
- * a rectangle texture you would use (@width, @height) where @width
- * and @height are the width and height of the texture.</note>
- *
- * <note>If you want to sample from a rectangle texture from GLSL you
- * should use the sampler2DRect sampler type.</note>
- *
- * <note>Applications wanting to use #CoglTextureRectangle should
- * first check for the %COGL_FEATURE_ID_TEXTURE_RECTANGLE feature
- * using cogl_has_feature().</note>
- *
- * The storage for the texture is not allocated before this function
- * returns. You can call cogl_texture_allocate() to explicitly
- * allocate the underlying storage or preferably let Cogl
- * automatically allocate storage lazily when it may know more about
- * how the texture is going to be used and can optimize how it is
- * allocated.
- *
- * Return value: (transfer full): A pointer to a new
- *               #CoglTextureRectangle texture.
- * Since: 2.0
- * Stability: unstable
- */
-CoglTextureRectangle *
-cogl_texture_rectangle_new_from_bitmap (CoglBitmap *bitmap);
-
-/**
- * cogl_texture_rectangle_new_from_foreign:
- * @ctx: A #CoglContext
- * @gl_handle: A GL handle for a GL_TEXTURE_RECTANGLE texture object
- * @width: Width of the foreign GL texture
- * @height: Height of the foreign GL texture
- * @format: The format of the texture
- *
- * Wraps an existing GL_TEXTURE_RECTANGLE texture object as a
- * #CoglTextureRectangle.  This can be used for integrating Cogl with
- * software using OpenGL directly.
- *
- * <note>Unlike for #CoglTexture2D textures, coordinates for
- * #CoglTextureRectangle textures should not be normalized. So instead
- * of using the coordinate (1, 1) to sample the bottom right corner of
- * a rectangle texture you would use (@width, @height) where @width
- * and @height are the width and height of the texture.</note>
- *
- * <note>The results are undefined for passing an invalid @gl_handle
- * or if @width or @height don't have the correct texture
- * geometry.</note>
- *
- * <note>If you want to sample from a rectangle texture from GLSL you
- * should use the sampler2DRect sampler type.</note>
- *
- * <note>Applications wanting to use #CoglTextureRectangle should
- * first check for the %COGL_FEATURE_ID_TEXTURE_RECTANGLE feature
- * using cogl_has_feature().</note>
- *
- * The texture is still configurable until it has been allocated so
- * for example you can declare whether the texture is premultiplied
- * with cogl_texture_set_premultiplied().
- *
- * Return value: (transfer full): A new #CoglTextureRectangle texture
- */
-CoglTextureRectangle *
-cogl_texture_rectangle_new_from_foreign (CoglContext *ctx,
-                                         unsigned int gl_handle,
-                                         int width,
-                                         int height,
-                                         CoglPixelFormat format);
-
-G_END_DECLS
-
-#endif /* __COGL_TEXURE_RECTANGLE_H */

cogl/cogl/cogl-texture.c

@@ -47,8 +47,6 @@
 #include "cogl-texture-2d-sliced-private.h"
 #include "cogl-texture-2d-private.h"
 #include "cogl-texture-2d-gl.h"
-#include "cogl-texture-3d-private.h"
-#include "cogl-texture-rectangle-private.h"
 #include "cogl-sub-texture-private.h"
 #include "cogl-atlas-texture-private.h"
 #include "cogl-pipeline.h"
@@ -245,12 +243,6 @@ _cogl_texture_get_n_levels (CoglTexture *texture)
   int height = cogl_texture_get_height (texture);
   int max_dimension = MAX (width, height);
 
-  if (cogl_is_texture_3d (texture))
-    {
-      CoglTexture3D *tex_3d = COGL_TEXTURE_3D (texture);
-      max_dimension = MAX (max_dimension, tex_3d->depth);
-    }
-
   return _cogl_util_fls (max_dimension);
 }
 
@@ -263,17 +255,9 @@ _cogl_texture_get_level_size (CoglTexture *texture,
 {
   int current_width = cogl_texture_get_width (texture);
   int current_height = cogl_texture_get_height (texture);
-  int current_depth;
+  int current_depth = 0;
   int i;
 
-  if (cogl_is_texture_3d (texture))
-    {
-      CoglTexture3D *tex_3d = COGL_TEXTURE_3D (texture);
-      current_depth = tex_3d->depth;
-    }
-  else
-    current_depth = 0;
-
   /* NB: The OpenGL spec (like D3D) uses a floor() convention to
    * round down the size of a mipmap level when dividing the size
    * of the previous level results in a fraction...
@@ -343,12 +327,6 @@ cogl_texture_get_gl_texture (CoglTexture *texture,
                                           out_gl_handle, out_gl_target);
 }
 
-CoglTextureType
-_cogl_texture_get_type (CoglTexture *texture)
-{
-  return texture->vtable->get_type (texture);
-}
-
 void
 _cogl_texture_pre_paint (CoglTexture *texture, CoglTexturePrePaintFlags flags)
 {

cogl/cogl/cogl-texture.h

@@ -107,25 +107,6 @@ typedef enum
   COGL_TEXTURE_ERROR_TYPE
 } CoglTextureError;
 
-/**
- * CoglTextureType:
- * @COGL_TEXTURE_TYPE_2D: A #CoglTexture2D
- * @COGL_TEXTURE_TYPE_3D: A #CoglTexture3D
- * @COGL_TEXTURE_TYPE_RECTANGLE: A #CoglTextureRectangle
- *
- * Constants representing the underlying hardware texture type of a
- * #CoglTexture.
- *
- * Stability: unstable
- * Since: 1.10
- */
-typedef enum
-{
-  COGL_TEXTURE_TYPE_2D,
-  COGL_TEXTURE_TYPE_3D,
-  COGL_TEXTURE_TYPE_RECTANGLE
-} CoglTextureType;
-
 uint32_t cogl_texture_error_quark (void);
 
 /**

cogl/cogl/cogl-types.h

@@ -315,14 +315,8 @@ typedef enum /*< prefix=COGL_PIXEL_FORMAT >*/
 
 /**
  * CoglFeatureFlags:
- * @COGL_FEATURE_TEXTURE_RECTANGLE: ARB_texture_rectangle support
- * @COGL_FEATURE_TEXTURE_NPOT: Non power of two textures are supported
- *    by the hardware. This is a equivalent to the
- *    %COGL_FEATURE_TEXTURE_NPOT_BASIC, %COGL_FEATURE_TEXTURE_NPOT_MIPMAP
- *    and %COGL_FEATURE_TEXTURE_NPOT_REPEAT features combined.
  * @COGL_FEATURE_TEXTURE_YUV: ycbcr conversion support
  * @COGL_FEATURE_TEXTURE_READ_PIXELS: glReadPixels() support
- * @COGL_FEATURE_SHADERS_GLSL: GLSL support
  * @COGL_FEATURE_OFFSCREEN: FBO support
  * @COGL_FEATURE_OFFSCREEN_MULTISAMPLE: Multisample support on FBOs
  * @COGL_FEATURE_OFFSCREEN_BLIT: Blit support on FBOs
@@ -334,20 +328,8 @@ typedef enum /*< prefix=COGL_PIXEL_FORMAT >*/
  *     %COGL_INDICES_TYPE_UNSIGNED_INT is supported in
  *     cogl_vertex_buffer_indices_new().
  * @COGL_FEATURE_DEPTH_RANGE: cogl_material_set_depth_range() support
- * @COGL_FEATURE_TEXTURE_NPOT_BASIC: The hardware supports non power
- *     of two textures, but you also need to check the
- *     %COGL_FEATURE_TEXTURE_NPOT_MIPMAP and %COGL_FEATURE_TEXTURE_NPOT_REPEAT
- *     features to know if the hardware supports npot texture mipmaps
- *     or repeat modes other than
- *     %COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE respectively.
- * @COGL_FEATURE_TEXTURE_NPOT_MIPMAP: Mipmapping is supported in
- *     conjuntion with non power of two textures.
- * @COGL_FEATURE_TEXTURE_NPOT_REPEAT: Repeat modes other than
- *     %COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE are supported by the
- *     hardware.
  * @COGL_FEATURE_POINT_SPRITE: Whether
  *     cogl_material_set_layer_point_sprite_coords_enabled() is supported.
- * @COGL_FEATURE_TEXTURE_3D: 3D texture support
  * @COGL_FEATURE_MAP_BUFFER_FOR_READ: Whether cogl_buffer_map() is
  *     supported with CoglBufferAccess including read support.
  * @COGL_FEATURE_MAP_BUFFER_FOR_WRITE: Whether cogl_buffer_map() is
@@ -361,11 +343,8 @@ typedef enum /*< prefix=COGL_PIXEL_FORMAT >*/
  */
 typedef enum
 {
-  COGL_FEATURE_TEXTURE_RECTANGLE      = (1 << 1),
-  COGL_FEATURE_TEXTURE_NPOT           = (1 << 2),
   COGL_FEATURE_TEXTURE_YUV            = (1 << 3),
   COGL_FEATURE_TEXTURE_READ_PIXELS    = (1 << 4),
-  COGL_FEATURE_SHADERS_GLSL           = (1 << 5),
   COGL_FEATURE_OFFSCREEN              = (1 << 6),
   COGL_FEATURE_OFFSCREEN_MULTISAMPLE  = (1 << 7),
   COGL_FEATURE_OFFSCREEN_BLIT         = (1 << 8),
@@ -375,11 +354,7 @@ typedef enum
   COGL_FEATURE_PBOS		      = (1 << 12),
   COGL_FEATURE_UNSIGNED_INT_INDICES   = (1 << 13),
   COGL_FEATURE_DEPTH_RANGE            = (1 << 14),
-  COGL_FEATURE_TEXTURE_NPOT_BASIC     = (1 << 15),
-  COGL_FEATURE_TEXTURE_NPOT_MIPMAP    = (1 << 16),
-  COGL_FEATURE_TEXTURE_NPOT_REPEAT    = (1 << 17),
   COGL_FEATURE_POINT_SPRITE           = (1 << 18),
-  COGL_FEATURE_TEXTURE_3D             = (1 << 19),
   COGL_FEATURE_MAP_BUFFER_FOR_READ    = (1 << 21),
   COGL_FEATURE_MAP_BUFFER_FOR_WRITE   = (1 << 22),
   COGL_FEATURE_ONSCREEN_MULTIPLE      = (1 << 23),
@@ -559,9 +534,7 @@ cogl_blend_string_error_quark (void);
  *
  * <itemizedlist>
  *  <listitem><para>You've tried to use a feature that is not
- *   advertised by cogl_has_feature(). This could happen if you create
- *   a 2d texture with a non-power-of-two size when
- *   %COGL_FEATURE_ID_TEXTURE_NPOT is not advertised.</para></listitem>
+ *   advertised by cogl_has_feature().</para></listitem>
  *  <listitem><para>The GPU can not handle the configuration you have
  *   requested. An example might be if you try to use too many texture
  *   layers in a single #CoglPipeline</para></listitem>
@@ -773,32 +746,6 @@ typedef enum _CoglWinsysFeature
   COGL_WINSYS_FEATURE_N_FEATURES
 } CoglWinsysFeature;
 
-/**
- * CoglColorMask:
- * @COGL_COLOR_MASK_NONE: None of the color channels are masked
- * @COGL_COLOR_MASK_RED: Masks the red color channel
- * @COGL_COLOR_MASK_GREEN: Masks the green color channel
- * @COGL_COLOR_MASK_BLUE: Masks the blue color channel
- * @COGL_COLOR_MASK_ALPHA: Masks the alpha color channel
- * @COGL_COLOR_MASK_ALL: All of the color channels are masked
- *
- * Defines a bit mask of color channels. This can be used with
- * cogl_pipeline_set_color_mask() for example to define which color
- * channels should be written to the current framebuffer when
- * drawing something.
- */
-typedef enum
-{
-  COGL_COLOR_MASK_NONE = 0,
-  COGL_COLOR_MASK_RED = 1L<<0,
-  COGL_COLOR_MASK_GREEN = 1L<<1,
-  COGL_COLOR_MASK_BLUE = 1L<<2,
-  COGL_COLOR_MASK_ALPHA = 1L<<3,
-  /* XXX: glib-mkenums is a perl script that can't cope if we split
-   * this onto multiple lines! *sigh* */
-  COGL_COLOR_MASK_ALL = (COGL_COLOR_MASK_RED | COGL_COLOR_MASK_GREEN | COGL_COLOR_MASK_BLUE | COGL_COLOR_MASK_ALPHA)
-} CoglColorMask;
-
 /**
  * CoglWinding:
  * @COGL_WINDING_CLOCKWISE: Vertices are in a clockwise order

cogl/cogl/cogl.h

@@ -105,8 +105,6 @@
 #include <cogl/cogl-quaternion.h>
 #include <cogl/cogl-texture-2d.h>
 #include <cogl/cogl-texture-2d-gl.h>
-#include <cogl/cogl-texture-rectangle.h>
-#include <cogl/cogl-texture-3d.h>
 #include <cogl/cogl-texture-2d-sliced.h>
 #include <cogl/cogl-sub-texture.h>
 #include <cogl/cogl-atlas-texture.h>

cogl/cogl/cogl.symbols

@@ -132,7 +132,6 @@ cogl_color_init_from_hsl
 cogl_color_init_from_4f
 cogl_color_init_from_4fv
 cogl_color_init_from_4ub
-cogl_color_mask_get_type
 cogl_color_new
 cogl_color_premultiply
 cogl_color_set_alpha
@@ -254,7 +253,6 @@ cogl_framebuffer_frustum
 cogl_framebuffer_get_alpha_bits
 cogl_framebuffer_get_blue_bits
 cogl_framebuffer_get_color_format
-cogl_framebuffer_get_color_mask
 cogl_framebuffer_get_context
 cogl_framebuffer_get_depth_bits
 cogl_framebuffer_get_depth_texture
@@ -297,7 +295,6 @@ cogl_framebuffer_rotate_quaternion
 #endif
 
 cogl_framebuffer_scale
-cogl_framebuffer_set_color_mask
 cogl_framebuffer_set_depth_texture_enabled
 cogl_framebuffer_set_depth_write_enabled
 cogl_framebuffer_set_dither_enabled
@@ -413,7 +410,6 @@ cogl_is_texture_pixmap_x11
 #endif
 cogl_is_texture_rectangle
 cogl_is_texture_2d
-cogl_is_texture_3d
 
 cogl_material_alpha_func_get_type
 cogl_material_copy
@@ -620,7 +616,6 @@ cogl_pipeline_get_alpha_test_function
 cogl_pipeline_get_alpha_test_reference
 cogl_pipeline_get_ambient
 cogl_pipeline_get_color
-cogl_pipeline_get_color_mask
 cogl_pipeline_get_cull_face_mode
 cogl_pipeline_get_depth_state
 cogl_pipeline_get_diffuse
@@ -650,7 +645,6 @@ cogl_pipeline_set_ambient_and_diffuse
 cogl_pipeline_set_blend
 cogl_pipeline_set_blend_constant
 cogl_pipeline_set_color
-cogl_pipeline_set_color_mask
 cogl_pipeline_set_color4f
 cogl_pipeline_set_color4ub
 cogl_pipeline_set_cull_face_mode
@@ -914,7 +908,6 @@ cogl_texture_is_sliced
 cogl_texture_new_from_bitmap
 cogl_texture_new_from_data
 cogl_texture_new_from_file
-cogl_texture_new_from_foreign
 cogl_texture_new_from_sub_texture
 cogl_texture_new_with_size
 #ifdef COGL_HAS_X11
@@ -959,12 +952,6 @@ cogl_texture_2d_sliced_new_from_bitmap
 cogl_texture_2d_sliced_new_from_data
 cogl_texture_2d_sliced_new_from_file
 cogl_texture_2d_sliced_new_with_size
-#ifdef COGL_HAS_GTYPE_SUPPORT
-cogl_texture_3d_get_gtype
-#endif
-cogl_texture_3d_new_from_bitmap
-cogl_texture_3d_new_from_data
-cogl_texture_3d_new_with_size
 
 cogl_transform
 cogl_translate

cogl/cogl/deprecated/cogl-auto-texture.c

@@ -48,7 +48,6 @@
 #include "cogl-bitmap-private.h"
 #include "cogl-atlas-texture-private.h"
 #include "cogl-error-private.h"
-#include "cogl-texture-rectangle.h"
 #include "cogl-sub-texture.h"
 #include "cogl-texture-2d-gl.h"
 
@@ -82,25 +81,18 @@ cogl_texture_new_with_size (unsigned int width,
 
   _COGL_GET_CONTEXT (ctx, NULL);
 
-  if ((_cogl_util_is_pot (width) && _cogl_util_is_pot (height)) ||
-      (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC) &&
-       cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP)))
+  /* First try creating a fast-path non-sliced texture */
+  tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, width, height));
+
+  _cogl_texture_set_internal_format (tex, internal_format);
+
+  if (!cogl_texture_allocate (tex, &skip_error))
     {
-      /* First try creating a fast-path non-sliced texture */
-      tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, width, height));
-
-      _cogl_texture_set_internal_format (tex, internal_format);
-
-      if (!cogl_texture_allocate (tex, &skip_error))
-        {
-          cogl_error_free (skip_error);
-          skip_error = NULL;
-          cogl_object_unref (tex);
-          tex = NULL;
-        }
+      cogl_error_free (skip_error);
+      skip_error = NULL;
+      cogl_object_unref (tex);
+      tex = NULL;
     }
-  else
-    tex = NULL;
 
   if (!tex)
     {
@@ -210,7 +202,6 @@ _cogl_texture_new_from_bitmap (CoglBitmap *bitmap,
                                gboolean can_convert_in_place,
                                CoglError **error)
 {
-  CoglContext *ctx = _cogl_bitmap_get_context (bitmap);
   CoglTexture *tex;
   CoglError *internal_error = NULL;
 
@@ -234,26 +225,18 @@ _cogl_texture_new_from_bitmap (CoglBitmap *bitmap,
     }
 
   /* If that doesn't work try a fast path 2D texture */
-  if ((_cogl_util_is_pot (bitmap->width) &&
-       _cogl_util_is_pot (bitmap->height)) ||
-      (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC) &&
-       cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP)))
+  tex = COGL_TEXTURE (_cogl_texture_2d_new_from_bitmap (bitmap,
+                                                        can_convert_in_place));
+
+  _cogl_texture_set_internal_format (tex, internal_format);
+
+  if (!cogl_texture_allocate (tex, &internal_error))
     {
-      tex = COGL_TEXTURE (_cogl_texture_2d_new_from_bitmap (bitmap,
-                                                            can_convert_in_place));
-
-      _cogl_texture_set_internal_format (tex, internal_format);
-
-      if (!cogl_texture_allocate (tex, &internal_error))
-        {
-          cogl_error_free (internal_error);
-          internal_error = NULL;
-          cogl_object_unref (tex);
-          tex = NULL;
-        }
+      cogl_error_free (internal_error);
+      internal_error = NULL;
+      cogl_object_unref (tex);
+      tex = NULL;
     }
-  else
-    tex = NULL;
 
   if (!tex)
     {
@@ -330,82 +313,6 @@ cogl_texture_new_from_file (const char        *filename,
   return texture;
 }
 
-CoglTexture *
-cogl_texture_new_from_foreign (GLuint           gl_handle,
-			       GLenum           gl_target,
-			       GLuint           width,
-			       GLuint           height,
-			       GLuint           x_pot_waste,
-			       GLuint           y_pot_waste,
-			       CoglPixelFormat  format)
-{
-  _COGL_GET_CONTEXT (ctx, NULL);
-
-#ifdef HAVE_COGL_GL
-  if (gl_target == GL_TEXTURE_RECTANGLE_ARB)
-    {
-      CoglTextureRectangle *texture_rectangle;
-      CoglSubTexture *sub_texture;
-
-      if (x_pot_waste != 0 || y_pot_waste != 0)
-        {
-          /* It shouldn't be necessary to have waste in this case since
-           * the texture isn't limited to power of two sizes. */
-          g_warning ("You can't create a foreign GL_TEXTURE_RECTANGLE cogl "
-                     "texture with waste\n");
-          return NULL;
-        }
-
-      texture_rectangle = cogl_texture_rectangle_new_from_foreign (ctx,
-                                                                   gl_handle,
-                                                                   width,
-                                                                   height,
-                                                                   format);
-      _cogl_texture_set_internal_format (COGL_TEXTURE (texture_rectangle),
-                                         format);
-
-      /* CoglTextureRectangle textures work with non-normalized
-       * coordinates, but the semantics for this function that people
-       * depend on are that all returned texture works with normalized
-       * coordinates so we wrap with a CoglSubTexture... */
-      sub_texture = cogl_sub_texture_new (ctx,
-                                          COGL_TEXTURE (texture_rectangle),
-                                          0, 0, width, height);
-      return COGL_TEXTURE (sub_texture);
-    }
-#endif
-
-  if (x_pot_waste != 0 || y_pot_waste != 0)
-    {
-      CoglTexture *tex =
-        COGL_TEXTURE (_cogl_texture_2d_sliced_new_from_foreign (ctx,
-                                                                gl_handle,
-                                                                gl_target,
-                                                                width,
-                                                                height,
-                                                                x_pot_waste,
-                                                                y_pot_waste,
-                                                                format));
-      _cogl_texture_set_internal_format (tex, format);
-
-      cogl_texture_allocate (tex, NULL);
-      return tex;
-    }
-  else
-    {
-      CoglTexture *tex =
-        COGL_TEXTURE (cogl_texture_2d_gl_new_from_foreign (ctx,
-                                                           gl_handle,
-                                                           width,
-                                                           height,
-                                                           format));
-      _cogl_texture_set_internal_format (tex, format);
-
-      cogl_texture_allocate (tex, NULL);
-      return tex;
-    }
-}
-
 CoglTexture *
 cogl_texture_new_from_sub_texture (CoglTexture *full_texture,
                                    int sub_x,

cogl/cogl/deprecated/cogl-auto-texture.h

@@ -125,44 +125,6 @@ cogl_texture_new_from_data (int width,
                             int rowstride,
                             const uint8_t *data);
 
-/**
- * cogl_texture_new_from_foreign:
- * @gl_handle: opengl handle of foreign texture.
- * @gl_target: opengl target type of foreign texture
- * @width: width of foreign texture
- * @height: height of foreign texture.
- * @x_pot_waste: horizontal waste on the right hand edge of the texture.
- * @y_pot_waste: vertical waste on the bottom edge of the texture.
- * @format: format of the foreign texture.
- *
- * Creates a #CoglTexture based on an existing OpenGL texture; the
- * width, height and format are passed along since it is not always
- * possible to query these from OpenGL.
- *
- * The waste arguments allow you to create a Cogl texture that maps to
- * a region smaller than the real OpenGL texture. For instance if your
- * hardware only supports power-of-two textures you may load a
- * non-power-of-two image into a larger power-of-two texture and use
- * the waste arguments to tell Cogl which region should be mapped to
- * the texture coordinate range [0:1].
- *
- * Return value: (transfer full): A newly created #CoglTexture or
- *               %NULL on failure
- *
- * Since: 0.8
- * Deprecated: 1.18: Use specific constructors such as
- *                   cogl_texture_2d_new_from_foreign()
- */
-COGL_DEPRECATED_FOR (cogl_texture_2d_new_from_foreign)
-CoglTexture *
-cogl_texture_new_from_foreign (unsigned int gl_handle,
-                               unsigned int gl_target,
-                               unsigned int width,
-                               unsigned int height,
-                               unsigned int x_pot_waste,
-                               unsigned int y_pot_waste,
-                               CoglPixelFormat format);
-
 /**
  * cogl_texture_new_from_bitmap:
  * @bitmap: A #CoglBitmap pointer

cogl/cogl/deprecated/cogl-material-compat.h

@@ -756,10 +756,6 @@ cogl_material_get_user_program (CoglMaterial *material);
  * meantime we hope this will handle most practical GLSL and ARBfp
  * requirements.
  *
- * Also remember you need to check for either the
- * %COGL_FEATURE_SHADERS_GLSL or %COGL_FEATURE_SHADERS_ARBFP before
- * using the cogl_program or cogl_shader API.
- *
  * Since: 1.4
  * Deprecated: 1.16: Use #CoglSnippet api instead instead
  */

cogl/cogl/deprecated/cogl-shader.h

@@ -48,11 +48,6 @@ G_BEGIN_DECLS
  * Cogl allows accessing the GL programmable pipeline in order to create
  * vertex and fragment shaders.
  *
- * The shader source code can either be GLSL or ARBfp. If the source
- * code is ARBfp, it must begin with the string “!!ARBfp1.0”. The
- * application should check for the %COGL_FEATURE_SHADERS_GLSL or
- * %COGL_FEATURE_SHADERS_ARBFP features before using shaders.
- *
  * When using GLSL Cogl provides replacement names for most of the
  * builtin varyings and uniforms. It is recommended to use these names
  * wherever possible to increase portability between OpenGL 2.0 and

cogl/cogl/driver/gl/cogl-clip-stack-gl.c

@@ -435,12 +435,7 @@ _cogl_clip_stack_gl_flush (CoglClipStack *stack,
      anything */
   if (ctx->current_clip_stack_valid)
     {
-      if (ctx->current_clip_stack == stack &&
-          (ctx->needs_viewport_scissor_workaround == FALSE ||
-           (framebuffer->viewport_age ==
-            framebuffer->viewport_age_for_scissor_workaround &&
-            ctx->viewport_scissor_workaround_framebuffer ==
-            framebuffer)))
+      if (ctx->current_clip_stack == stack)
         return;
 
       _cogl_clip_stack_unref (ctx->current_clip_stack);
@@ -457,10 +452,8 @@ _cogl_clip_stack_gl_flush (CoglClipStack *stack,
   GE( ctx, glDisable (GL_STENCIL_TEST) );
 
   /* If the stack is empty then there's nothing else to do
-   *
-   * See comment below about ctx->needs_viewport_scissor_workaround
    */
-  if (stack == NULL && !ctx->needs_viewport_scissor_workaround)
+  if (stack == NULL)
     {
       COGL_NOTE (CLIPPING, "Flushed empty clip stack");
 
@@ -477,31 +470,6 @@ _cogl_clip_stack_gl_flush (CoglClipStack *stack,
                                &scissor_x0, &scissor_y0,
                                &scissor_x1, &scissor_y1);
 
-  /* XXX: ONGOING BUG: Intel viewport scissor
-   *
-   * Intel gen6 drivers don't correctly handle offset viewports, since
-   * primitives aren't clipped within the bounds of the viewport.  To
-   * workaround this we push our own clip for the viewport that will
-   * use scissoring to ensure we clip as expected.
-   *
-   * TODO: file a bug upstream!
-   */
-  if (ctx->needs_viewport_scissor_workaround)
-    {
-      _cogl_util_scissor_intersect (framebuffer->viewport_x,
-                                    framebuffer->viewport_y,
-                                    framebuffer->viewport_x +
-                                      framebuffer->viewport_width,
-                                    framebuffer->viewport_y +
-                                      framebuffer->viewport_height,
-                                    &scissor_x0, &scissor_y0,
-                                    &scissor_x1, &scissor_y1);
-      framebuffer->viewport_age_for_scissor_workaround =
-        framebuffer->viewport_age;
-      ctx->viewport_scissor_workaround_framebuffer =
-        framebuffer;
-    }
-
   /* Enable scissoring as soon as possible */
   if (scissor_x0 >= scissor_x1 || scissor_y0 >= scissor_y1)
     scissor_x0 = scissor_y0 = scissor_x1 = scissor_y1 = scissor_y_start = 0;

cogl/cogl/driver/gl/cogl-framebuffer-gl.c

@@ -195,20 +195,6 @@ _cogl_framebuffer_gl_flush_projection_state (CoglFramebuffer *framebuffer)
                                              projection_entry);
 }
 
-static void
-_cogl_framebuffer_gl_flush_color_mask_state (CoglFramebuffer *framebuffer)
-{
-  CoglContext *context = framebuffer->context;
-
-  /* The color mask state is really owned by a CoglPipeline so to
-   * ensure the color mask is updated the next time we draw something
-   * we need to make sure the logic ops for the pipeline are
-   * re-flushed... */
-  context->current_pipeline_changes_since_flush |=
-    COGL_PIPELINE_STATE_LOGIC_OPS;
-  context->current_pipeline_age--;
-}
-
 static void
 _cogl_framebuffer_gl_flush_front_face_winding_state (CoglFramebuffer *framebuffer)
 {
@@ -437,9 +423,6 @@ _cogl_framebuffer_gl_flush_state (CoglFramebuffer *draw_buffer,
         case COGL_FRAMEBUFFER_STATE_INDEX_PROJECTION:
           _cogl_framebuffer_gl_flush_projection_state (draw_buffer);
           break;
-        case COGL_FRAMEBUFFER_STATE_INDEX_COLOR_MASK:
-          _cogl_framebuffer_gl_flush_color_mask_state (draw_buffer);
-          break;
         case COGL_FRAMEBUFFER_STATE_INDEX_FRONT_FACE_WINDING:
           _cogl_framebuffer_gl_flush_front_face_winding_state (draw_buffer);
           break;
@@ -968,20 +951,6 @@ _cogl_framebuffer_gl_clear (CoglFramebuffer *framebuffer,
     {
       GE( ctx, glClearColor (red, green, blue, alpha) );
       gl_buffers |= GL_COLOR_BUFFER_BIT;
-
-      if (ctx->current_gl_color_mask != framebuffer->color_mask)
-        {
-          CoglColorMask color_mask = framebuffer->color_mask;
-          GE( ctx, glColorMask (!!(color_mask & COGL_COLOR_MASK_RED),
-                                !!(color_mask & COGL_COLOR_MASK_GREEN),
-                                !!(color_mask & COGL_COLOR_MASK_BLUE),
-                                !!(color_mask & COGL_COLOR_MASK_ALPHA)));
-          ctx->current_gl_color_mask = color_mask;
-          /* Make sure the ColorMask is updated when the next primitive is drawn */
-          ctx->current_pipeline_changes_since_flush |=
-            COGL_PIPELINE_STATE_LOGIC_OPS;
-          ctx->current_pipeline_age--;
-        }
     }
 
   if (buffers & COGL_BUFFER_BIT_DEPTH)

cogl/cogl/driver/gl/cogl-pipeline-fragend-glsl.c

@@ -233,15 +233,9 @@ add_layer_declaration_cb (CoglPipelineLayer *layer,
                           void *user_data)
 {
   CoglPipelineShaderState *shader_state = user_data;
-  CoglTextureType texture_type =
-    _cogl_pipeline_layer_get_texture_type (layer);
-  const char *target_string;
-
-  _cogl_gl_util_get_texture_target_string (texture_type, &target_string, NULL);
 
   g_string_append_printf (shader_state->header,
-                          "uniform sampler%s cogl_sampler%i;\n",
-                          target_string,
+                          "uniform sampler2D cogl_sampler%i;\n",
                           layer->index);
 
   return TRUE;
@@ -411,20 +405,12 @@ ensure_texture_lookup_generated (CoglPipelineShaderState *shader_state,
 {
   int unit_index = _cogl_pipeline_layer_get_unit_index (layer);
   CoglPipelineSnippetData snippet_data;
-  CoglTextureType texture_type;
-  const char *target_string, *tex_coord_swizzle;
 
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
   if (shader_state->unit_state[unit_index].sampled)
     return;
 
-  texture_type =
-    _cogl_pipeline_layer_get_texture_type (layer);
-  _cogl_gl_util_get_texture_target_string (texture_type,
-                                           &target_string,
-                                           &tex_coord_swizzle);
-
   shader_state->unit_state[unit_index].sampled = TRUE;
 
   g_string_append_printf (shader_state->header,
@@ -455,20 +441,18 @@ ensure_texture_lookup_generated (CoglPipelineShaderState *shader_state,
     {
       g_string_append_printf (shader_state->header,
                               "vec4\n"
-                              "cogl_real_texture_lookup%i (sampler%s tex,\n"
+                              "cogl_real_texture_lookup%i (sampler2D tex,\n"
                               "                            vec4 coords)\n"
                               "{\n"
                               "  return ",
-                              layer->index,
-                              target_string);
+                              layer->index);
 
       if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_DISABLE_TEXTURING)))
         g_string_append (shader_state->header,
                          "vec4 (1.0, 1.0, 1.0, 1.0);\n");
       else
-        g_string_append_printf (shader_state->header,
-                                "texture%s (tex, coords.%s);\n",
-                                target_string, tex_coord_swizzle);
+        g_string_append (shader_state->header,
+                         "texture2D (tex, coords.st);\n");
 
       g_string_append (shader_state->header, "}\n");
     }
@@ -487,8 +471,7 @@ ensure_texture_lookup_generated (CoglPipelineShaderState *shader_state,
   snippet_data.return_variable = "cogl_texel";
   snippet_data.arguments = "cogl_sampler, cogl_tex_coord";
   snippet_data.argument_declarations =
-    g_strdup_printf ("sampler%s cogl_sampler, vec4 cogl_tex_coord",
-                     target_string);
+    g_strdup ("sampler2D cogl_sampler, vec4 cogl_tex_coord");
   snippet_data.source_buf = shader_state->header;
 
   _cogl_pipeline_snippet_generate_code (&snippet_data);

cogl/cogl/driver/gl/cogl-pipeline-opengl.c

@@ -581,23 +581,6 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state (
       flush_depth_state (ctx, depth_state);
     }
 
-  if (pipelines_difference & COGL_PIPELINE_STATE_LOGIC_OPS)
-    {
-      CoglPipeline *authority =
-        _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_LOGIC_OPS);
-      CoglPipelineLogicOpsState *logic_ops_state = &authority->big_state->logic_ops_state;
-      CoglColorMask color_mask = logic_ops_state->color_mask;
-
-      if (ctx->current_draw_buffer)
-        color_mask &= ctx->current_draw_buffer->color_mask;
-
-      GE (ctx, glColorMask (!!(color_mask & COGL_COLOR_MASK_RED),
-                            !!(color_mask & COGL_COLOR_MASK_GREEN),
-                            !!(color_mask & COGL_COLOR_MASK_BLUE),
-                            !!(color_mask & COGL_COLOR_MASK_ALPHA)));
-      ctx->current_gl_color_mask = color_mask;
-    }
-
   if (pipelines_difference & COGL_PIPELINE_STATE_CULL_FACE)
     {
       CoglPipeline *authority =
@@ -690,22 +673,13 @@ get_max_activateable_texture_units (void)
 #ifdef HAVE_COGL_GL
       if (!_cogl_has_private_feature (ctx, COGL_PRIVATE_FEATURE_GL_EMBEDDED))
         {
-          /* GL_MAX_TEXTURE_COORDS is provided for both GLSL and ARBfp. It
-             defines the number of texture coordinates that can be
-             uploaded (but doesn't necessarily relate to how many texture
-             images can be sampled) */
-          if (cogl_has_feature (ctx, COGL_FEATURE_ID_GLSL))
-            /* Previously this code subtracted the value by one but there
-               was no explanation for why it did this and it doesn't seem
-               to make sense so it has been removed */
-            GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_COORDS,
-                                    values + n_values++));
+          /* GL_MAX_TEXTURE_COORDS defines the number of texture coordinates
+           * that can be uploaded (but doesn't necessarily relate to how many
+           * texture images can be sampled) */
+          GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_COORDS, values + n_values++));
 
-          /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS is defined for GLSL but
-             not ARBfp */
-          if (cogl_has_feature (ctx, COGL_FEATURE_ID_GLSL))
-            GE (ctx, glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
-                                    values + n_values++));
+          GE (ctx, glGetIntegerv (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
+                                  values + n_values++));
         }
 #endif /* HAVE_COGL_GL */
 
@@ -790,18 +764,7 @@ flush_layers_common_gl_state_cb (CoglPipelineLayer *layer, void *user_data)
       GLenum gl_target;
 
       if (texture == NULL)
-        switch (_cogl_pipeline_layer_get_texture_type (layer))
-          {
-          case COGL_TEXTURE_TYPE_2D:
-            texture = COGL_TEXTURE (ctx->default_gl_texture_2d_tex);
-            break;
-          case COGL_TEXTURE_TYPE_3D:
-            texture = COGL_TEXTURE (ctx->default_gl_texture_3d_tex);
-            break;
-          case COGL_TEXTURE_TYPE_RECTANGLE:
-            texture = COGL_TEXTURE (ctx->default_gl_texture_rect_tex);
-            break;
-          }
+        texture = COGL_TEXTURE (ctx->default_gl_texture_2d_tex);
 
       cogl_texture_get_gl_texture (texture,
                                    &gl_texture,

cogl/cogl/driver/gl/cogl-pipeline-progend-glsl.c

@@ -644,9 +644,6 @@ _cogl_pipeline_progend_glsl_start (CoglPipeline *pipeline)
 
   _COGL_GET_CONTEXT (ctx, FALSE);
 
-  if (!cogl_has_feature (ctx, COGL_FEATURE_ID_GLSL))
-    return FALSE;
-
   user_program = cogl_pipeline_get_user_program (pipeline);
   if (user_program &&
       _cogl_program_get_language (user_program) != COGL_SHADER_LANGUAGE_GLSL)

cogl/cogl/driver/gl/cogl-pipeline-vertend-glsl.c

@@ -169,15 +169,9 @@ add_layer_declaration_cb (CoglPipelineLayer *layer,
                           void *user_data)
 {
   CoglPipelineShaderState *shader_state = user_data;
-  CoglTextureType texture_type =
-    _cogl_pipeline_layer_get_texture_type (layer);
-  const char *target_string;
-
-  _cogl_gl_util_get_texture_target_string (texture_type, &target_string, NULL);
 
   g_string_append_printf (shader_state->header,
-                          "uniform sampler%s cogl_sampler%i;\n",
-                          target_string,
+                          "uniform sampler2D cogl_sampler%i;\n",
                           layer->index);
 
   return TRUE;

cogl/cogl/driver/gl/cogl-texture-2d-gl.c

@@ -83,13 +83,6 @@ _cogl_texture_2d_gl_can_create (CoglContext *ctx,
   GLenum gl_format;
   GLenum gl_type;
 
-  /* If NPOT textures aren't supported then the size must be a power
-     of two */
-  if (!cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC) &&
-      (!_cogl_util_is_pot (width) ||
-       !_cogl_util_is_pot (height)))
-    return FALSE;
-
   ctx->driver_vtable->pixel_format_to_gl (ctx,
                                           internal_format,
                                           &gl_intformat,

cogl/cogl/driver/gl/cogl-texture-gl.c

@@ -32,7 +32,6 @@
 #include <strings.h>
 
 #include "cogl-context-private.h"
-#include "cogl-texture-3d-private.h"
 #include "cogl-util.h"
 #include "driver/gl/cogl-util-gl-private.h"
 #include "driver/gl/cogl-texture-gl-private.h"

cogl/cogl/driver/gl/cogl-util-gl-private.h

@@ -85,11 +85,6 @@ _cogl_gl_util_clear_gl_errors (CoglContext *ctx);
 gboolean
 _cogl_gl_util_catch_out_of_memory (CoglContext *ctx, CoglError **error);
 
-void
-_cogl_gl_util_get_texture_target_string (CoglTextureType texture_type,
-                                         const char **target_string_out,
-                                         const char **swizzle_out);
-
 /* Parses a GL version number stored in a string. @version_string must
  * point to the beginning of the version number (ie, it can't point to
  * the "OpenGL ES" part on GLES). The version number can be followed

cogl/cogl/driver/gl/cogl-util-gl.c

@@ -127,49 +127,6 @@ _cogl_gl_util_catch_out_of_memory (CoglContext *ctx, CoglError **error)
   return FALSE;
 }
 
-void
-_cogl_gl_util_get_texture_target_string (CoglTextureType texture_type,
-                                         const char **target_string_out,
-                                         const char **swizzle_out)
-{
-  const char *target_string, *tex_coord_swizzle;
-
-  switch (texture_type)
-    {
-#if 0 /* TODO */
-    case COGL_TEXTURE_TYPE_1D:
-      target_string = "1D";
-      tex_coord_swizzle = "s";
-      break;
-#endif
-
-    case COGL_TEXTURE_TYPE_2D:
-      target_string = "2D";
-      tex_coord_swizzle = "st";
-      break;
-
-    case COGL_TEXTURE_TYPE_3D:
-      target_string = "3D";
-      tex_coord_swizzle = "stp";
-      break;
-
-    case COGL_TEXTURE_TYPE_RECTANGLE:
-      target_string = "2DRect";
-      tex_coord_swizzle = "st";
-      break;
-
-    default:
-      target_string = "Unknown";
-      tex_coord_swizzle = NULL;
-      g_assert_not_reached ();
-    }
-
-  if (target_string_out)
-    *target_string_out = target_string;
-  if (swizzle_out)
-    *swizzle_out = tex_coord_swizzle;
-}
-
 gboolean
 _cogl_gl_util_parse_gl_version (const char *version_string,
                                 int *major_out,

cogl/cogl/driver/gl/gl/cogl-driver-gl.c

@@ -317,31 +317,13 @@ check_gl_version (CoglContext *ctx,
       return FALSE;
     }
 
-  /* GL 1.3 supports all of the required functionality in core */
-  if (COGL_CHECK_GL_VERSION (major, minor, 1, 3))
-    return TRUE;
-
-  /* OpenGL 1.2 is only supported if we have the multitexturing
-     extension */
-  if (!_cogl_check_extension ("GL_ARB_multitexture", gl_extensions))
+  /* We require GLSL 1.20, which is implied by OpenGL 2.1. */
+  if (!COGL_CHECK_GL_VERSION (major, minor, 2, 1))
     {
       _cogl_set_error (error,
-                   COGL_DRIVER_ERROR,
-                   COGL_DRIVER_ERROR_INVALID_VERSION,
-                   "The OpenGL driver is missing "
-                   "the GL_ARB_multitexture extension");
-      return FALSE;
-    }
-
-  /* OpenGL 1.2 is required */
-  if (!COGL_CHECK_GL_VERSION (major, minor, 1, 2))
-    {
-      _cogl_set_error (error,
-                   COGL_DRIVER_ERROR,
-                   COGL_DRIVER_ERROR_INVALID_VERSION,
-                   "The OpenGL version of your driver (%i.%i) "
-                   "is not compatible with Cogl",
-                   major, minor);
+                       COGL_DRIVER_ERROR,
+                       COGL_DRIVER_ERROR_INVALID_VERSION,
+                       "OpenGL 2.1 or better is required");
       return FALSE;
     }
 
@@ -356,6 +338,7 @@ _cogl_driver_update_features (CoglContext *ctx,
   unsigned long private_features
     [COGL_FLAGS_N_LONGS_FOR_SIZE (COGL_N_PRIVATE_FEATURES)] = { 0 };
   char **gl_extensions;
+  const char *glsl_version;
   int gl_major = 0, gl_minor = 0;
   int i;
 
@@ -403,23 +386,13 @@ _cogl_driver_update_features (CoglContext *ctx,
   _cogl_gpu_info_init (ctx, &ctx->gpu);
 
   ctx->glsl_major = 1;
-  ctx->glsl_minor = 1;
+  ctx->glsl_minor = 2;
+  ctx->glsl_version_to_use = 120;
 
-  if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 2, 0))
-    {
-      const char *glsl_version =
-        (char *)ctx->glGetString (GL_SHADING_LANGUAGE_VERSION);
-      _cogl_gl_util_parse_gl_version (glsl_version,
-                                      &ctx->glsl_major,
-                                      &ctx->glsl_minor);
-    }
-
-  if (COGL_CHECK_GL_VERSION (ctx->glsl_major, ctx->glsl_minor, 1, 2))
-    /* We want to use version 120 if it is available so that the
-     * gl_PointCoord can be used. */
-    ctx->glsl_version_to_use = 120;
-  else
-    ctx->glsl_version_to_use = 110;
+  glsl_version = (char *)ctx->glGetString (GL_SHADING_LANGUAGE_VERSION);
+  _cogl_gl_util_parse_gl_version (glsl_version,
+                                  &ctx->glsl_major,
+                                  &ctx->glsl_minor);
 
   flags = (COGL_FEATURE_TEXTURE_READ_PIXELS
            | COGL_FEATURE_UNSIGNED_INT_INDICES
@@ -427,31 +400,13 @@ _cogl_driver_update_features (CoglContext *ctx,
   COGL_FLAGS_SET (ctx->features,
                   COGL_FEATURE_ID_UNSIGNED_INT_INDICES, TRUE);
   COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_DEPTH_RANGE, TRUE);
-
-  if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 1, 4))
-    COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_MIRRORED_REPEAT, TRUE);
+  COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_MIRRORED_REPEAT, TRUE);
 
   _cogl_feature_check_ext_functions (ctx,
                                      gl_major,
                                      gl_minor,
                                      gl_extensions);
 
-  if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 2, 0) ||
-      _cogl_check_extension ("GL_ARB_texture_non_power_of_two", gl_extensions))
-    {
-      flags |= COGL_FEATURE_TEXTURE_NPOT
-        | COGL_FEATURE_TEXTURE_NPOT_BASIC
-        | COGL_FEATURE_TEXTURE_NPOT_MIPMAP
-        | COGL_FEATURE_TEXTURE_NPOT_REPEAT;
-      COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_TEXTURE_NPOT, TRUE);
-      COGL_FLAGS_SET (ctx->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
-      COGL_FLAGS_SET (ctx->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, TRUE);
-      COGL_FLAGS_SET (ctx->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT, TRUE);
-    }
-
   if (_cogl_check_extension ("GL_MESA_pack_invert", gl_extensions))
     COGL_FLAGS_SET (private_features,
                     COGL_PRIVATE_FEATURE_MESA_PACK_INVERT, TRUE);
@@ -483,64 +438,12 @@ _cogl_driver_update_features (CoglContext *ctx,
       COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_DEPTH_TEXTURE, TRUE);
     }
 
-  if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 2, 1) ||
-      _cogl_check_extension ("GL_EXT_pixel_buffer_object", gl_extensions))
-    COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_PBOS, TRUE);
+  COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_PBOS, TRUE);
+  COGL_FLAGS_SET (private_features,
+                  COGL_PRIVATE_FEATURE_BLEND_CONSTANT, TRUE);
 
-  if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 1, 4) ||
-      _cogl_check_extension ("GL_EXT_blend_color", gl_extensions))
-    COGL_FLAGS_SET (private_features,
-                    COGL_PRIVATE_FEATURE_BLEND_CONSTANT, TRUE);
-
-  if (ctx->glCreateProgram)
-    {
-      flags |= COGL_FEATURE_SHADERS_GLSL;
-      COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_GLSL, TRUE);
-    }
-  else
-    {
-      /* If all of the old GLSL extensions are available then we can fake
-       * the GL 2.0 GLSL support by diverting to the old function names */
-      if (ctx->glCreateProgramObject && /* GL_ARB_shader_objects */
-           ctx->glVertexAttribPointer && /* GL_ARB_vertex_shader */
-           _cogl_check_extension ("GL_ARB_fragment_shader", gl_extensions))
-        {
-          ctx->glCreateShader = ctx->glCreateShaderObject;
-          ctx->glCreateProgram = ctx->glCreateProgramObject;
-          ctx->glDeleteShader = ctx->glDeleteObject;
-          ctx->glDeleteProgram = ctx->glDeleteObject;
-          ctx->glAttachShader = ctx->glAttachObject;
-          ctx->glUseProgram = ctx->glUseProgramObject;
-          ctx->glGetProgramInfoLog = ctx->glGetInfoLog;
-          ctx->glGetShaderInfoLog = ctx->glGetInfoLog;
-          ctx->glGetShaderiv = ctx->glGetObjectParameteriv;
-          ctx->glGetProgramiv = ctx->glGetObjectParameteriv;
-          ctx->glDetachShader = ctx->glDetachObject;
-          ctx->glGetAttachedShaders = ctx->glGetAttachedObjects;
-          /* FIXME: there doesn't seem to be an equivalent for glIsShader
-           * and glIsProgram. This doesn't matter for now because Cogl
-           * doesn't use these but if we add support for simulating a
-           * GLES2 context on top of regular GL then we'll need to do
-           * something here */
-
-          flags |= COGL_FEATURE_SHADERS_GLSL;
-          COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_GLSL, TRUE);
-        }
-    }
-
-  if ((COGL_CHECK_GL_VERSION (gl_major, gl_minor, 2, 0) ||
-       _cogl_check_extension ("GL_ARB_point_sprite", gl_extensions)) &&
-
-      /* If GLSL is supported then we only enable point sprite support
-       * too if we have glsl >= 1.2 otherwise we don't have the
-       * gl_PointCoord builtin which we depend on in the glsl backend.
-       */
-      (!COGL_FLAGS_GET (ctx->features, COGL_FEATURE_ID_GLSL) ||
-       COGL_CHECK_GL_VERSION (ctx->glsl_major, ctx->glsl_minor, 1, 2)))
-    {
-      flags |= COGL_FEATURE_POINT_SPRITE;
-      COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_POINT_SPRITE, TRUE);
-    }
+  flags |= COGL_FEATURE_POINT_SPRITE;
+  COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_POINT_SPRITE, TRUE);
 
   if (ctx->glGenBuffers)
     {
@@ -553,19 +456,6 @@ _cogl_driver_update_features (CoglContext *ctx,
                       COGL_FEATURE_ID_MAP_BUFFER_FOR_WRITE, TRUE);
     }
 
-  if (_cogl_check_extension ("GL_ARB_texture_rectangle", gl_extensions))
-    {
-      flags |= COGL_FEATURE_TEXTURE_RECTANGLE;
-      COGL_FLAGS_SET (ctx->features,
-                      COGL_FEATURE_ID_TEXTURE_RECTANGLE, TRUE);
-    }
-
-  if (ctx->glTexImage3D)
-    {
-      flags |= COGL_FEATURE_TEXTURE_3D;
-      COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_TEXTURE_3D, TRUE);
-    }
-
   if (ctx->glEGLImageTargetTexture2D)
     COGL_FLAGS_SET (private_features,
                     COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE, TRUE);
@@ -584,17 +474,9 @@ _cogl_driver_update_features (CoglContext *ctx,
     COGL_FLAGS_SET (private_features,
                     COGL_PRIVATE_FEATURE_TEXTURE_SWIZZLE, TRUE);
 
-  /* The per-vertex point size is only available via GLSL with the
-   * gl_PointSize builtin. This is only available in GL 2.0 (not the
-   * GLSL extensions) */
-  if (COGL_CHECK_GL_VERSION (gl_major, gl_minor, 2, 0))
-    {
-      COGL_FLAGS_SET (ctx->features,
-                      COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE,
-                      TRUE);
-      COGL_FLAGS_SET (private_features,
-                      COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE, TRUE);
-    }
+  COGL_FLAGS_SET (ctx->features, COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE, TRUE);
+  COGL_FLAGS_SET (private_features,
+                  COGL_PRIVATE_FEATURE_ENABLE_PROGRAM_POINT_SIZE, TRUE);
 
   if (ctx->driver == COGL_DRIVER_GL)
     {

cogl/cogl/driver/gl/gl/cogl-texture-driver-gl.c

@@ -71,7 +71,6 @@ _cogl_texture_driver_gen (CoglContext *ctx,
   switch (gl_target)
     {
     case GL_TEXTURE_2D:
-    case GL_TEXTURE_3D:
       /* In case automatic mipmap generation gets disabled for this
        * texture but a minification filter depending on mipmap
        * interpolation is selected then we initialize the max mipmap
@@ -131,9 +130,6 @@ prep_gl_for_pixels_upload_full (CoglContext *ctx,
   GE( ctx, glPixelStorei (GL_UNPACK_SKIP_PIXELS, pixels_src_x) );
   GE( ctx, glPixelStorei (GL_UNPACK_SKIP_ROWS, pixels_src_y) );
 
-  if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_3D))
-    GE( ctx, glPixelStorei (GL_UNPACK_IMAGE_HEIGHT, image_height) );
-
   _cogl_texture_gl_prep_alignment_for_pixels_upload (ctx, pixels_rowstride);
 }
 
@@ -161,9 +157,6 @@ prep_gl_for_pixels_download_full (CoglContext *ctx,
   GE( ctx, glPixelStorei (GL_PACK_SKIP_PIXELS, pixels_src_x) );
   GE( ctx, glPixelStorei (GL_PACK_SKIP_ROWS, pixels_src_y) );
 
-  if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_3D))
-    GE( ctx, glPixelStorei (GL_PACK_IMAGE_HEIGHT, image_height) );
-
   _cogl_texture_gl_prep_alignment_for_pixels_download (ctx,
                                                        pixels_bpp,
                                                        image_width,
@@ -355,59 +348,6 @@ _cogl_texture_driver_upload_to_gl (CoglContext *ctx,
   return status;
 }
 
-static gboolean
-_cogl_texture_driver_upload_to_gl_3d (CoglContext *ctx,
-                                      GLenum gl_target,
-                                      GLuint gl_handle,
-                                      gboolean is_foreign,
-                                      GLint height,
-                                      GLint depth,
-                                      CoglBitmap *source_bmp,
-                                      GLint internal_gl_format,
-                                      GLuint source_gl_format,
-                                      GLuint source_gl_type,
-                                      CoglError **error)
-{
-  uint8_t *data;
-  CoglPixelFormat source_format = cogl_bitmap_get_format (source_bmp);
-  int bpp = _cogl_pixel_format_get_bytes_per_pixel (source_format);
-  gboolean status = TRUE;
-
-  data = _cogl_bitmap_gl_bind (source_bmp, COGL_BUFFER_ACCESS_READ, 0, error);
-  if (!data)
-    return FALSE;
-
-  /* Setup gl alignment to match rowstride and top-left corner */
-  prep_gl_for_pixels_upload_full (ctx,
-                                  cogl_bitmap_get_rowstride (source_bmp),
-                                  (cogl_bitmap_get_height (source_bmp) /
-                                   depth),
-                                  0, 0, bpp);
-
-  _cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign);
-
-  /* Clear any GL errors */
-  _cogl_gl_util_clear_gl_errors (ctx);
-
-  ctx->glTexImage3D (gl_target,
-                     0, /* level */
-                     internal_gl_format,
-                     cogl_bitmap_get_width (source_bmp),
-                     height,
-                     depth,
-                     0,
-                     source_gl_format,
-                     source_gl_type,
-                     data);
-
-  if (_cogl_gl_util_catch_out_of_memory (ctx, error))
-    status = FALSE;
-
-  _cogl_bitmap_gl_unbind (source_bmp);
-
-  return status;
-}
-
 static gboolean
 _cogl_texture_driver_gl_get_tex_image (CoglContext *ctx,
                                        GLenum gl_target,
@@ -423,35 +363,6 @@ _cogl_texture_driver_gl_get_tex_image (CoglContext *ctx,
   return TRUE;
 }
 
-static gboolean
-_cogl_texture_driver_size_supported_3d (CoglContext *ctx,
-                                        GLenum gl_target,
-                                        GLenum gl_format,
-                                        GLenum gl_type,
-                                        int width,
-                                        int height,
-                                        int depth)
-{
-  GLenum proxy_target;
-  GLint new_width = 0;
-
-  if (gl_target == GL_TEXTURE_3D)
-    proxy_target = GL_PROXY_TEXTURE_3D;
-  else
-    /* Unknown target, assume it's not supported */
-    return FALSE;
-
-  /* Proxy texture allows for a quick check for supported size */
-  GE( ctx, glTexImage3D (proxy_target, 0, GL_RGBA,
-                         width, height, depth, 0 /* border */,
-                         gl_format, gl_type, NULL) );
-
-  GE( ctx, glGetTexLevelParameteriv (proxy_target, 0,
-                                     GL_TEXTURE_WIDTH, &new_width) );
-
-  return new_width != 0;
-}
-
 static gboolean
 _cogl_texture_driver_size_supported (CoglContext *ctx,
                                      GLenum gl_target,
@@ -523,11 +434,9 @@ _cogl_texture_driver_gl =
     _cogl_texture_driver_prep_gl_for_pixels_upload,
     _cogl_texture_driver_upload_subregion_to_gl,
     _cogl_texture_driver_upload_to_gl,
-    _cogl_texture_driver_upload_to_gl_3d,
     _cogl_texture_driver_prep_gl_for_pixels_download,
     _cogl_texture_driver_gl_get_tex_image,
     _cogl_texture_driver_size_supported,
-    _cogl_texture_driver_size_supported_3d,
     _cogl_texture_driver_allows_foreign_gl_target,
     _cogl_texture_driver_find_best_gl_get_data_format
   };

cogl/cogl/driver/gl/gles/cogl-driver-gles.c

@@ -33,6 +33,7 @@
 #include <string.h>
 
 #include "cogl-context-private.h"
+#include "cogl-error-private.h"
 #include "cogl-feature-private.h"
 #include "cogl-renderer-private.h"
 #include "cogl-private.h"
@@ -287,20 +288,25 @@ _cogl_driver_update_features (CoglContext *context,
       gl_minor = 1;
     }
 
+  if (!COGL_CHECK_GL_VERSION (gl_major, gl_minor, 2, 0))
+    {
+      _cogl_set_error (error,
+                       COGL_DRIVER_ERROR,
+                       COGL_DRIVER_ERROR_INVALID_VERSION,
+                       "OpenGL ES 2.0 or better is required");
+      return FALSE;
+    }
+
   _cogl_feature_check_ext_functions (context,
                                      gl_major,
                                      gl_minor,
                                      gl_extensions);
 
-  flags |= COGL_FEATURE_SHADERS_GLSL | COGL_FEATURE_OFFSCREEN;
+  flags |= COGL_FEATURE_OFFSCREEN;
   /* Note GLES 2 core doesn't support mipmaps for npot textures or
    * repeat modes other than CLAMP_TO_EDGE. */
-  flags |= COGL_FEATURE_TEXTURE_NPOT_BASIC;
   flags |= COGL_FEATURE_DEPTH_RANGE;
-  COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_GLSL, TRUE);
   COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_OFFSCREEN, TRUE);
-  COGL_FLAGS_SET (context->features,
-                  COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
   COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_DEPTH_RANGE, TRUE);
   COGL_FLAGS_SET (context->features,
                   COGL_FEATURE_ID_MIRRORED_REPEAT, TRUE);
@@ -314,7 +320,6 @@ _cogl_driver_update_features (CoglContext *context,
   COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_ANY_GL, TRUE);
   COGL_FLAGS_SET (private_features, COGL_PRIVATE_FEATURE_ALPHA_TEXTURES, TRUE);
 
-  /* Both GLES 1.1 and GLES 2.0 support point sprites in core */
   flags |= COGL_FEATURE_POINT_SPRITE;
   COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_POINT_SPRITE, TRUE);
 
@@ -341,37 +346,6 @@ _cogl_driver_update_features (CoglContext *context,
       COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_DEPTH_TEXTURE, TRUE);
     }
 
-  if (_cogl_check_extension ("GL_OES_texture_npot", gl_extensions))
-    {
-      flags |= (COGL_FEATURE_TEXTURE_NPOT |
-                COGL_FEATURE_TEXTURE_NPOT_BASIC |
-                COGL_FEATURE_TEXTURE_NPOT_MIPMAP |
-                COGL_FEATURE_TEXTURE_NPOT_REPEAT);
-      COGL_FLAGS_SET (context->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT, TRUE);
-      COGL_FLAGS_SET (context->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
-      COGL_FLAGS_SET (context->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, TRUE);
-      COGL_FLAGS_SET (context->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT, TRUE);
-    }
-  else if (_cogl_check_extension ("GL_IMG_texture_npot", gl_extensions))
-    {
-      flags |= (COGL_FEATURE_TEXTURE_NPOT_BASIC |
-                COGL_FEATURE_TEXTURE_NPOT_MIPMAP);
-      COGL_FLAGS_SET (context->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
-      COGL_FLAGS_SET (context->features,
-                      COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, TRUE);
-    }
-
-  if (context->glTexImage3D)
-    {
-      flags |= COGL_FEATURE_TEXTURE_3D;
-      COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_3D, TRUE);
-    }
-
   if (context->glMapBuffer)
     {
       /* The GL_OES_mapbuffer extension doesn't support mapping for

cogl/cogl/driver/gl/gles/cogl-texture-driver-gles.c

@@ -394,152 +394,6 @@ _cogl_texture_driver_upload_to_gl (CoglContext *ctx,
   return status;
 }
 
-static gboolean
-_cogl_texture_driver_upload_to_gl_3d (CoglContext *ctx,
-                                      GLenum gl_target,
-                                      GLuint gl_handle,
-                                      gboolean is_foreign,
-                                      GLint height,
-                                      GLint depth,
-                                      CoglBitmap *source_bmp,
-                                      GLint internal_gl_format,
-                                      GLuint source_gl_format,
-                                      GLuint source_gl_type,
-                                      CoglError **error)
-{
-  CoglPixelFormat source_format = cogl_bitmap_get_format (source_bmp);
-  int bpp = _cogl_pixel_format_get_bytes_per_pixel (source_format);
-  int rowstride = cogl_bitmap_get_rowstride (source_bmp);
-  int bmp_width = cogl_bitmap_get_width (source_bmp);
-  int bmp_height = cogl_bitmap_get_height (source_bmp);
-  uint8_t *data;
-
-  _cogl_bind_gl_texture_transient (gl_target, gl_handle, is_foreign);
-
-  /* If the rowstride or image height can't be specified with just
-     GL_ALIGNMENT alone then we need to copy the bitmap because there
-     is no GL_ROW_LENGTH */
-  if (rowstride / bpp != bmp_width ||
-      height != bmp_height / depth)
-    {
-      CoglBitmap *bmp;
-      int image_height = bmp_height / depth;
-      CoglPixelFormat source_bmp_format = cogl_bitmap_get_format (source_bmp);
-      int i;
-
-      _cogl_texture_driver_prep_gl_for_pixels_upload (ctx, bmp_width * bpp, bpp);
-
-      /* Initialize the texture with empty data and then upload each
-         image with a sub-region update */
-
-      /* Clear any GL errors */
-      _cogl_gl_util_clear_gl_errors (ctx);
-
-      ctx->glTexImage3D (gl_target,
-                         0, /* level */
-                         internal_gl_format,
-                         bmp_width,
-                         height,
-                         depth,
-                         0,
-                         source_gl_format,
-                         source_gl_type,
-                         NULL);
-
-      if (_cogl_gl_util_catch_out_of_memory (ctx, error))
-        return FALSE;
-
-      bmp = _cogl_bitmap_new_with_malloc_buffer (ctx,
-                                                 bmp_width,
-                                                 height,
-                                                 source_bmp_format,
-                                                 error);
-      if (!bmp)
-        return FALSE;
-
-      for (i = 0; i < depth; i++)
-        {
-          if (!_cogl_bitmap_copy_subregion (source_bmp,
-                                            bmp,
-                                            0, image_height * i,
-                                            0, 0,
-                                            bmp_width,
-                                            height,
-                                            error))
-            {
-              cogl_object_unref (bmp);
-              return FALSE;
-            }
-
-          data = _cogl_bitmap_gl_bind (bmp,
-                                       COGL_BUFFER_ACCESS_READ, 0, error);
-          if (!data)
-            {
-              cogl_object_unref (bmp);
-              return FALSE;
-            }
-
-          /* Clear any GL errors */
-          _cogl_gl_util_clear_gl_errors (ctx);
-
-          ctx->glTexSubImage3D (gl_target,
-                                0, /* level */
-                                0, /* xoffset */
-                                0, /* yoffset */
-                                i, /* zoffset */
-                                bmp_width, /* width */
-                                height, /* height */
-                                1, /* depth */
-                                source_gl_format,
-                                source_gl_type,
-                                data);
-
-          if (_cogl_gl_util_catch_out_of_memory (ctx, error))
-            {
-              cogl_object_unref (bmp);
-              _cogl_bitmap_gl_unbind (bmp);
-              return FALSE;
-            }
-
-          _cogl_bitmap_gl_unbind (bmp);
-        }
-
-      cogl_object_unref (bmp);
-    }
-  else
-    {
-      data = _cogl_bitmap_gl_bind (source_bmp, COGL_BUFFER_ACCESS_READ, 0, error);
-      if (!data)
-        return FALSE;
-
-      _cogl_texture_driver_prep_gl_for_pixels_upload (ctx, rowstride, bpp);
-
-      /* Clear any GL errors */
-      _cogl_gl_util_clear_gl_errors (ctx);
-
-      ctx->glTexImage3D (gl_target,
-                         0, /* level */
-                         internal_gl_format,
-                         bmp_width,
-                         height,
-                         depth,
-                         0,
-                         source_gl_format,
-                         source_gl_type,
-                         data);
-
-      if (_cogl_gl_util_catch_out_of_memory (ctx, error))
-        {
-          _cogl_bitmap_gl_unbind (source_bmp);
-          return FALSE;
-        }
-
-      _cogl_bitmap_gl_unbind (source_bmp);
-    }
-
-  return TRUE;
-}
-
 /* NB: GLES doesn't support glGetTexImage2D, so cogl-texture will instead
  * fallback to a generic render + readpixels approach to downloading
  * texture data. (See _cogl_texture_draw_and_read() ) */
@@ -553,25 +407,6 @@ _cogl_texture_driver_gl_get_tex_image (CoglContext *ctx,
   return FALSE;
 }
 
-static gboolean
-_cogl_texture_driver_size_supported_3d (CoglContext *ctx,
-                                        GLenum gl_target,
-                                        GLenum gl_format,
-                                        GLenum gl_type,
-                                        int width,
-                                        int height,
-                                        int depth)
-{
-  GLint max_size;
-
-  /* GLES doesn't support a proxy texture target so let's at least
-     check whether the size is greater than
-     GL_MAX_3D_TEXTURE_SIZE_OES */
-  GE( ctx, glGetIntegerv (GL_MAX_3D_TEXTURE_SIZE_OES, &max_size) );
-
-  return width <= max_size && height <= max_size && depth <= max_size;
-}
-
 static gboolean
 _cogl_texture_driver_size_supported (CoglContext *ctx,
                                      GLenum gl_target,
@@ -622,11 +457,9 @@ _cogl_texture_driver_gles =
     _cogl_texture_driver_prep_gl_for_pixels_upload,
     _cogl_texture_driver_upload_subregion_to_gl,
     _cogl_texture_driver_upload_to_gl,
-    _cogl_texture_driver_upload_to_gl_3d,
     _cogl_texture_driver_prep_gl_for_pixels_download,
     _cogl_texture_driver_gl_get_tex_image,
     _cogl_texture_driver_size_supported,
-    _cogl_texture_driver_size_supported_3d,
     _cogl_texture_driver_allows_foreign_gl_target,
     _cogl_texture_driver_find_best_gl_get_data_format
   };

cogl/cogl/gl-prototypes/cogl-all-functions.h

@@ -109,27 +109,6 @@ COGL_EXT_FUNCTION (GLboolean, glUnmapBuffer,
                    (GLenum		 target))
 COGL_EXT_END ()
 
-COGL_EXT_BEGIN (texture_3d, 1, 2,
-                0, /* not in either GLES */
-                "OES\0",
-                "texture_3D\0")
-COGL_EXT_FUNCTION (void, glTexImage3D,
-                   (GLenum target, GLint level,
-                    GLint internalFormat,
-                    GLsizei width, GLsizei height,
-                    GLsizei depth, GLint border,
-                    GLenum format, GLenum type,
-                    const GLvoid *pixels))
-COGL_EXT_FUNCTION (void, glTexSubImage3D,
-                   (GLenum target, GLint level,
-                    GLint xoffset, GLint yoffset,
-                    GLint zoffset, GLsizei width,
-                    GLsizei height, GLsizei depth,
-                    GLenum format,
-                    GLenum type, const GLvoid *pixels))
-COGL_EXT_END ()
-
-
 
 COGL_EXT_BEGIN (offscreen_blit, 3, 0,
                 0, /* not in either GLES */

cogl/cogl/libmutter-cogl.map.in

@@ -29,8 +29,6 @@ global:
   _cogl_texture_can_hardware_repeat;
   _cogl_pipeline_prune_to_n_layers;
   _cogl_primitive_draw;
-  #test_;
-  #unit_test_;
   _cogl_winsys_glx_get_vtable;
   _cogl_winsys_egl_xlib_get_vtable;
   _cogl_winsys_egl_get_vtable;
@@ -48,6 +46,7 @@ global:
   _cogl_pixel_format_get_bytes_per_pixel*;
   _cogl_system_error_quark;
   _cogl_util_next_p2;
+  @unit_tests_symbols@
 local:
   *;
 };

cogl/cogl/meson.build

@@ -119,9 +119,7 @@ cogl_nonintrospected_headers = [
   'cogl-quaternion.h',
   'cogl-matrix-stack.h',
   'cogl-poll.h',
-  'cogl-texture-3d.h',
   'cogl-texture-2d-gl.h',
-  'cogl-texture-rectangle.h',
   'cogl-sub-texture.h',
   'cogl-atlas-texture.h',
   'cogl-meta-texture.h',
@@ -307,15 +305,11 @@ cogl_sources = [
   'cogl-texture-private.h',
   'cogl-texture-2d-private.h',
   'cogl-texture-2d-sliced-private.h',
-  'cogl-texture-3d-private.h',
   'cogl-texture-driver.h',
   'cogl-sub-texture.c',
   'cogl-texture.c',
   'cogl-texture-2d.c',
   'cogl-texture-2d-sliced.c',
-  'cogl-texture-3d.c',
-  'cogl-texture-rectangle-private.h',
-  'cogl-texture-rectangle.c',
   'cogl-rectangle-map.h',
   'cogl-rectangle-map.c',
   'cogl-atlas.h',
@@ -461,16 +455,24 @@ cogl_headers_all = [
 ]
 
 cogl_test_deps = []
+cogl_unit_tests_map_data = configuration_data()
 
 if have_cogl_tests
   cogl_test_deps += [libmutter_cogl_test_fixtures_dep]
+
+  cogl_unit_tests_map_data.set('unit_tests_symbols', 'test_*; unit_test_*;')
 endif
 
+libmutter_cogl_map = configure_file(
+  input: 'libmutter-cogl.map.in',
+  output: 'libmutter-cogl.map',
+  configuration: cogl_unit_tests_map_data,
+  install: false,
+)
+
 libmutter_cogl_name = 'mutter-cogl-' + libmutter_api_version
-libmutter_cogl_map = 'libmutter-cogl.map'
 libmutter_cogl_link_args = [
-  '-Wl,--version-script,@0@/@1@'.format(meson.current_source_dir(),
-      libmutter_cogl_map),
+  '-Wl,--version-script,@0@'.format(libmutter_cogl_map),
 ]
 libmutter_cogl = shared_library(libmutter_cogl_name,
   sources: [cogl_sources, cogl_headers_all],

cogl/cogl/winsys/cogl-texture-pixmap-x11.c

@@ -44,7 +44,6 @@
 #include "cogl-texture-driver.h"
 #include "cogl-texture-2d-private.h"
 #include "cogl-texture-2d-sliced.h"
-#include "cogl-texture-rectangle-private.h"
 #include "cogl-context-private.h"
 #include "cogl-display-private.h"
 #include "cogl-renderer-private.h"
@@ -582,29 +581,21 @@ create_fallback_texture (CoglContext *ctx,
   CoglTexture *tex;
   CoglError *skip_error = NULL;
 
-  if ((_cogl_util_is_pot (width) && _cogl_util_is_pot (height)) ||
-      (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC) &&
-       cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP)))
+  /* First try creating a fast-path non-sliced texture */
+  tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx, width, height));
+
+  _cogl_texture_set_internal_format (tex, internal_format);
+
+  /* TODO: instead of allocating storage here it would be better
+   * if we had some api that let us just check that the size is
+   * supported by the hardware so storage could be allocated
+   * lazily when uploading data. */
+  if (!cogl_texture_allocate (tex, &skip_error))
     {
-      /* First try creating a fast-path non-sliced texture */
-      tex = COGL_TEXTURE (cogl_texture_2d_new_with_size (ctx,
-                                                         width, height));
-
-      _cogl_texture_set_internal_format (tex, internal_format);
-
-      /* TODO: instead of allocating storage here it would be better
-       * if we had some api that let us just check that the size is
-       * supported by the hardware so storage could be allocated
-       * lazily when uploading data. */
-      if (!cogl_texture_allocate (tex, &skip_error))
-        {
-          cogl_error_free (skip_error);
-          cogl_object_unref (tex);
-          tex = NULL;
-        }
+      cogl_error_free (skip_error);
+      cogl_object_unref (tex);
+      tex = NULL;
     }
-  else
-    tex = NULL;
 
   if (!tex)
     {
@@ -879,33 +870,6 @@ _cogl_texture_pixmap_x11_get_data (CoglTexture *tex,
   return cogl_texture_get_data (child_tex, format, rowstride, data);
 }
 
-typedef struct _NormalizeCoordsWrapperData
-{
-  int width;
-  int height;
-  CoglMetaTextureCallback callback;
-  void *user_data;
-} NormalizeCoordsWrapperData;
-
-static void
-normalize_coords_wrapper_cb (CoglTexture *child_texture,
-                             const float *child_texture_coords,
-                             const float *meta_coords,
-                             void *user_data)
-{
-  NormalizeCoordsWrapperData *data = user_data;
-  float normalized_coords[4];
-
-  normalized_coords[0] = meta_coords[0] / data->width;
-  normalized_coords[1] = meta_coords[1] / data->height;
-  normalized_coords[2] = meta_coords[2] / data->width;
-  normalized_coords[3] = meta_coords[3] / data->height;
-
-  data->callback (child_texture,
-                  child_texture_coords, normalized_coords,
-                  data->user_data);
-}
-
 static void
 _cogl_texture_pixmap_x11_foreach_sub_texture_in_region
                                   (CoglTexture              *tex,
@@ -920,47 +884,15 @@ _cogl_texture_pixmap_x11_foreach_sub_texture_in_region
   CoglTexture *child_tex = _cogl_texture_pixmap_x11_get_texture (tex_pixmap);
 
   /* Forward on to the child texture */
-
-  /* tfp textures may be implemented in terms of a
-   * CoglTextureRectangle texture which uses un-normalized texture
-   * coordinates but we want to consistently deal with normalized
-   * texture coordinates with CoglTexturePixmapX11... */
-  if (cogl_is_texture_rectangle (child_tex))
-    {
-      NormalizeCoordsWrapperData data;
-      int width = tex->width;
-      int height = tex->height;
-
-      virtual_tx_1 *= width;
-      virtual_ty_1 *= height;
-      virtual_tx_2 *= width;
-      virtual_ty_2 *= height;
-
-      data.width = width;
-      data.height = height;
-      data.callback = callback;
-      data.user_data = user_data;
-
-      cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (child_tex),
-                                           virtual_tx_1,
-                                           virtual_ty_1,
-                                           virtual_tx_2,
-                                           virtual_ty_2,
-                                           COGL_PIPELINE_WRAP_MODE_REPEAT,
-                                           COGL_PIPELINE_WRAP_MODE_REPEAT,
-                                           normalize_coords_wrapper_cb,
-                                           &data);
-    }
-  else
-    cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (child_tex),
-                                         virtual_tx_1,
-                                         virtual_ty_1,
-                                         virtual_tx_2,
-                                         virtual_ty_2,
-                                         COGL_PIPELINE_WRAP_MODE_REPEAT,
-                                         COGL_PIPELINE_WRAP_MODE_REPEAT,
-                                         callback,
-                                         user_data);
+  cogl_meta_texture_foreach_in_region (COGL_META_TEXTURE (child_tex),
+                                       virtual_tx_1,
+                                       virtual_ty_1,
+                                       virtual_tx_2,
+                                       virtual_ty_2,
+                                       COGL_PIPELINE_WRAP_MODE_REPEAT,
+                                       COGL_PIPELINE_WRAP_MODE_REPEAT,
+                                       callback,
+                                       user_data);
 }
 
 static int
@@ -1100,18 +1032,6 @@ _cogl_texture_pixmap_x11_get_gl_format (CoglTexture *tex)
   return _cogl_texture_gl_get_format (child_tex);
 }
 
-static CoglTextureType
-_cogl_texture_pixmap_x11_get_type (CoglTexture *tex)
-{
-  CoglTexturePixmapX11 *tex_pixmap = COGL_TEXTURE_PIXMAP_X11 (tex);
-  CoglTexture *child_tex;
-
-  child_tex = _cogl_texture_pixmap_x11_get_texture (tex_pixmap);
-
-  /* Forward on to the child texture */
-  return _cogl_texture_get_type (child_tex);
-}
-
 static void
 _cogl_texture_pixmap_x11_free (CoglTexturePixmapX11 *tex_pixmap)
 {
@@ -1178,7 +1098,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_type,
     NULL, /* is_foreign */
     NULL /* set_auto_mipmap */
   };

cogl/cogl/winsys/cogl-winsys-egl-feature-functions.h

@@ -147,3 +147,9 @@ COGL_WINSYS_FEATURE_BEGIN (surfaceless_context,
                            "surfaceless_context\0",
                            COGL_EGL_WINSYS_FEATURE_SURFACELESS_CONTEXT)
 COGL_WINSYS_FEATURE_END ()
+
+COGL_WINSYS_FEATURE_BEGIN (context_priority,
+                           "IMG\0",
+                           "context_priority\0",
+                           COGL_EGL_WINSYS_FEATURE_CONTEXT_PRIORITY)
+COGL_WINSYS_FEATURE_END ()

cogl/cogl/winsys/cogl-winsys-egl-private.h

@@ -105,7 +105,8 @@ typedef enum _CoglEGLWinsysFeature
   COGL_EGL_WINSYS_FEATURE_CREATE_CONTEXT                =1L<<3,
   COGL_EGL_WINSYS_FEATURE_BUFFER_AGE                    =1L<<4,
   COGL_EGL_WINSYS_FEATURE_FENCE_SYNC                    =1L<<5,
-  COGL_EGL_WINSYS_FEATURE_SURFACELESS_CONTEXT           =1L<<6
+  COGL_EGL_WINSYS_FEATURE_SURFACELESS_CONTEXT           =1L<<6,
+  COGL_EGL_WINSYS_FEATURE_CONTEXT_PRIORITY              =1L<<7,
 } CoglEGLWinsysFeature;
 
 typedef struct _CoglRendererEGL

cogl/cogl/winsys/cogl-winsys-egl.c

@@ -71,6 +71,12 @@
 #define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
 #endif
 
+#ifndef EGL_IMG_context_priority
+#define EGL_CONTEXT_PRIORITY_LEVEL_IMG          0x3100
+#define EGL_CONTEXT_PRIORITY_HIGH_IMG           0x3101
+#define EGL_CONTEXT_PRIORITY_MEDIUM_IMG         0x3102
+#define EGL_CONTEXT_PRIORITY_LOW_IMG            0x3103
+#endif
 
 #define MAX_EGL_CONFIG_ATTRIBS 30
 
@@ -347,10 +353,11 @@ try_create_context (CoglDisplay *display,
   CoglRendererEGL *egl_renderer = renderer->winsys;
   EGLDisplay edpy;
   EGLConfig config;
-  EGLint attribs[9];
+  EGLint attribs[11];
   EGLint cfg_attribs[MAX_EGL_CONFIG_ATTRIBS];
   GError *config_error = NULL;
   const char *error_message;
+  int i = 0;
 
   _COGL_RETURN_VAL_IF_FAIL (egl_display->egl_context == NULL, TRUE);
 
@@ -388,24 +395,29 @@ try_create_context (CoglDisplay *display,
         }
 
       /* Try to get a core profile 3.1 context with no deprecated features */
-      attribs[0] = EGL_CONTEXT_MAJOR_VERSION_KHR;
-      attribs[1] = 3;
-      attribs[2] = EGL_CONTEXT_MINOR_VERSION_KHR;
-      attribs[3] = 1;
-      attribs[4] = EGL_CONTEXT_FLAGS_KHR;
-      attribs[5] = EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
-      attribs[6] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR;
-      attribs[7] = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
-      attribs[8] = EGL_NONE;
+      attribs[i++] = EGL_CONTEXT_MAJOR_VERSION_KHR;
+      attribs[i++] = 3;
+      attribs[i++] = EGL_CONTEXT_MINOR_VERSION_KHR;
+      attribs[i++] = 1;
+      attribs[i++] = EGL_CONTEXT_FLAGS_KHR;
+      attribs[i++] = EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
+      attribs[i++] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR;
+      attribs[i++] = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
     }
   else if (display->renderer->driver == COGL_DRIVER_GLES2)
     {
-      attribs[0] = EGL_CONTEXT_CLIENT_VERSION;
-      attribs[1] = 2;
-      attribs[2] = EGL_NONE;
+      attribs[i++] = EGL_CONTEXT_CLIENT_VERSION;
+      attribs[i++] = 2;
     }
-  else
-    attribs[0] = EGL_NONE;
+
+  if (egl_renderer->private_features &
+      COGL_EGL_WINSYS_FEATURE_CONTEXT_PRIORITY)
+    {
+      attribs[i++] = EGL_CONTEXT_PRIORITY_LEVEL_IMG;
+      attribs[i++] = EGL_CONTEXT_PRIORITY_HIGH_IMG;
+    }
+
+  attribs[i++] = EGL_NONE;
 
   egl_display->egl_context = eglCreateContext (edpy,
                                                config,
@@ -418,6 +430,20 @@ try_create_context (CoglDisplay *display,
       goto fail;
     }
 
+  if (egl_renderer->private_features &
+      COGL_EGL_WINSYS_FEATURE_CONTEXT_PRIORITY)
+    {
+      EGLint value = EGL_CONTEXT_PRIORITY_MEDIUM_IMG;
+
+      eglQueryContext (egl_renderer->edpy,
+                       egl_display->egl_context,
+                       EGL_CONTEXT_PRIORITY_LEVEL_IMG,
+                       &value);
+
+      if (value != EGL_CONTEXT_PRIORITY_HIGH_IMG)
+        g_warning ("Failed to obtain high priority context");
+    }
+
   if (egl_renderer->platform_vtable->context_created &&
       !egl_renderer->platform_vtable->context_created (display, error))
     return FALSE;

cogl/cogl/winsys/cogl-winsys-glx.c

@@ -44,7 +44,6 @@
 #include "cogl-glx-display-private.h"
 #include "cogl-private.h"
 #include "cogl-texture-2d-private.h"
-#include "cogl-texture-rectangle-private.h"
 #include "cogl-frame-info-private.h"
 #include "cogl-framebuffer-private.h"
 #include "cogl-onscreen-private.h"
@@ -2525,54 +2524,6 @@ get_fbconfig_for_depth (CoglContext *context,
   return found;
 }
 
-static gboolean
-should_use_rectangle (CoglContext *context)
-{
-
-  if (context->rectangle_state == COGL_WINSYS_RECTANGLE_STATE_UNKNOWN)
-    {
-      if (cogl_has_feature (context, COGL_FEATURE_ID_TEXTURE_RECTANGLE))
-        {
-          const char *rect_env;
-
-          /* Use the rectangle only if it is available and either:
-
-             the COGL_PIXMAP_TEXTURE_RECTANGLE environment variable is
-             set to 'force'
-
-             *or*
-
-             the env var is set to 'allow' or not set and NPOTs textures
-             are not available */
-
-          context->rectangle_state =
-            cogl_has_feature (context, COGL_FEATURE_ID_TEXTURE_NPOT) ?
-            COGL_WINSYS_RECTANGLE_STATE_DISABLE :
-            COGL_WINSYS_RECTANGLE_STATE_ENABLE;
-
-          if ((rect_env = g_getenv ("COGL_PIXMAP_TEXTURE_RECTANGLE")) ||
-              /* For compatibility, we'll also look at the old Clutter
-                 environment variable */
-              (rect_env = g_getenv ("CLUTTER_PIXMAP_TEXTURE_RECTANGLE")))
-            {
-              if (g_ascii_strcasecmp (rect_env, "force") == 0)
-                context->rectangle_state =
-                  COGL_WINSYS_RECTANGLE_STATE_ENABLE;
-              else if (g_ascii_strcasecmp (rect_env, "disable") == 0)
-                context->rectangle_state =
-                  COGL_WINSYS_RECTANGLE_STATE_DISABLE;
-              else if (g_ascii_strcasecmp (rect_env, "allow"))
-                g_warning ("Unknown value for COGL_PIXMAP_TEXTURE_RECTANGLE, "
-                           "should be 'force' or 'disable'");
-            }
-        }
-      else
-        context->rectangle_state = COGL_WINSYS_RECTANGLE_STATE_DISABLE;
-    }
-
-  return context->rectangle_state == COGL_WINSYS_RECTANGLE_STATE_ENABLE;
-}
-
 static gboolean
 try_create_glx_pixmap (CoglContext *context,
                        CoglTexturePixmapX11 *tex_pixmap,
@@ -2589,7 +2540,6 @@ try_create_glx_pixmap (CoglContext *context,
   GLXFBConfig fb_config = (GLXFBConfig)0;
   int attribs[7];
   int i = 0;
-  GLenum target;
   CoglXlibTrapState trap_state;
 
   unsigned int depth = tex_pixmap->depth;
@@ -2610,14 +2560,6 @@ try_create_glx_pixmap (CoglContext *context,
       return FALSE;
     }
 
-  if (should_use_rectangle (context))
-    {
-      target = GLX_TEXTURE_RECTANGLE_EXT;
-      glx_tex_pixmap->can_mipmap = FALSE;
-    }
-  else
-    target = GLX_TEXTURE_2D_EXT;
-
   if (!glx_tex_pixmap->can_mipmap)
     mipmap = FALSE;
 
@@ -2638,7 +2580,7 @@ try_create_glx_pixmap (CoglContext *context,
   attribs[i++] = mipmap;
 
   attribs[i++] = GLX_TEXTURE_TARGET_EXT;
-  attribs[i++] = target;
+  attribs[i++] = GLX_TEXTURE_2D_EXT;
 
   attribs[i++] = None;
 
@@ -2821,49 +2763,21 @@ _cogl_winsys_texture_pixmap_x11_update (CoglTexturePixmapX11 *tex_pixmap,
                         COGL_PIXEL_FORMAT_RGBA_8888_PRE :
                         COGL_PIXEL_FORMAT_RGB_888);
 
-      if (should_use_rectangle (ctx))
-        {
-          texture_info->glx_tex = COGL_TEXTURE (
-            cogl_texture_rectangle_new_with_size (ctx,
-                                                  tex->width,
-                                                  tex->height));
+      texture_info->glx_tex = COGL_TEXTURE (
+        cogl_texture_2d_new_with_size (ctx, tex->width, tex->height));
 
-          _cogl_texture_set_internal_format (tex, texture_format);
+      _cogl_texture_set_internal_format (tex, texture_format);
 
-          if (cogl_texture_allocate (texture_info->glx_tex, &error))
-            COGL_NOTE (TEXTURE_PIXMAP, "Created a texture rectangle for %p",
-                       tex_pixmap);
-          else
-            {
-              COGL_NOTE (TEXTURE_PIXMAP, "Falling back for %p because a "
-                         "texture rectangle could not be created: %s",
-                         tex_pixmap, error->message);
-              cogl_error_free (error);
-              free_glx_pixmap (ctx, glx_tex_pixmap);
-              return FALSE;
-            }
-        }
+      if (cogl_texture_allocate (texture_info->glx_tex, &error))
+        COGL_NOTE (TEXTURE_PIXMAP, "Created a texture 2d for %p", tex_pixmap);
       else
         {
-          texture_info->glx_tex = COGL_TEXTURE (
-            cogl_texture_2d_new_with_size (ctx,
-                                           tex->width,
-                                           tex->height));
-
-          _cogl_texture_set_internal_format (tex, texture_format);
-
-          if (cogl_texture_allocate (texture_info->glx_tex, &error))
-            COGL_NOTE (TEXTURE_PIXMAP, "Created a texture 2d for %p",
-                       tex_pixmap);
-          else
-            {
-              COGL_NOTE (TEXTURE_PIXMAP, "Falling back for %p because a "
-                         "texture 2d could not be created: %s",
-                         tex_pixmap, error->message);
-              cogl_error_free (error);
-              free_glx_pixmap (ctx, glx_tex_pixmap);
-              return FALSE;
-            }
+          COGL_NOTE (TEXTURE_PIXMAP, "Falling back for %p because a "
+                     "texture 2d could not be created: %s",
+                     tex_pixmap, error->message);
+          cogl_error_free (error);
+          free_glx_pixmap (ctx, glx_tex_pixmap);
+          return FALSE;
         }
     }
 

cogl/cogl/winsys/cogl-winsys-private.h

@@ -64,13 +64,6 @@ typedef enum /*< prefix=COGL_WINSYS_ERROR >*/
   COGL_WINSYS_ERROR_CREATE_GLES2_CONTEXT,
 } CoglWinsysError;
 
-typedef enum
-{
-  COGL_WINSYS_RECTANGLE_STATE_UNKNOWN,
-  COGL_WINSYS_RECTANGLE_STATE_DISABLE,
-  COGL_WINSYS_RECTANGLE_STATE_ENABLE
-} CoglWinsysRectangleState;
-
 typedef struct _CoglWinsysVtable
 {
   CoglWinsysID id;