x11: Limit touch replay pointer events to when replaying

When a touch sequence was rejected, the emulated pointer events would be
replayed with old timestamps. This caused issues with grabs as they
would be ignored due to being too old. This was mitigated by making sure
device event timestamps never travelled back in time by tampering with
any event that had a timestamp seemingly in the past.

This failed when the most recent timestamp that had been received were
much older than the timestamp of the new event. This could for example
happen when a session was left not interacted with for 40+ days or so;
when interacted with again, as any new timestamp would according to
XSERVER_TIME_IS_BEFORE() still be in the past compared to the "most
recent" one. The effect is that we'd always use the `latest_evtime` for
all new device events without ever updating it.

The end result of this was that passive grabs would become active when
interacted with, but would then newer be released, as the timestamps to
XIAllowEvents() would out of date, resulting in the desktop effectively
freezing, as the Shell would have an active pointer grab.

To avoid the situation where we get stuck with an old `latest_evtime`
timestamp, limit the tampering with device event timestamp to 1) only
pointer events, and 2) only during the replay sequence. The second part
is implemented by sending an asynchronous message via the X server after
rejecting a touch sequence, only potentially tampering with the device
event timestamps until the reply. This should avoid the stuck timestamp
as in those situations, we'll always have a relatively up to date
`latest_evtime` meaning XSERVER_TIME_IS_BEFORE() will not get confused.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/886

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-image: registry.gitlab.gnome.org/gnome/mutter/master:v2
+image: registry.gitlab.gnome.org/gnome/mutter/master:v1
 
 stages:
  - review
@@ -7,8 +7,6 @@ stages:
 
 check-commit-log:
   stage: review
-  variables:
-    GIT_DEPTH: "100"
   script:
     - ./.gitlab-ci/check-commit-log.sh
   only:
@@ -17,7 +15,7 @@ check-commit-log:
 build-mutter:
   stage: build
   script:
-    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror --prefix /usr
+    - meson . build -Dbuildtype=debugoptimized -Degl_device=true -Dwayland_eglstream=true --werror
     - ninja -C build
     - ninja -C build install
   artifacts:
@@ -35,31 +33,12 @@ test-mutter:
   variables:
     XDG_RUNTIME_DIR: "$CI_PROJECT_DIR/runtime-dir"
     GSETTINGS_SCHEMA_DIR: "$CI_PROJECT_DIR/build/data"
-    G_SLICE: "always-malloc"
-    MALLOC_CHECK_: "3"
-    NO_AT_BRIDGE: "1"
-    MALLOC_PERTURB_: "123"
   script:
-    - dconf update
     - mkdir -m 700 $XDG_RUNTIME_DIR
     - glib-compile-schemas $GSETTINGS_SCHEMA_DIR
     - >
       dbus-run-session -- xvfb-run -s '+iglx -noreset'
-      meson test -C build --no-rebuild -t 10 --verbose --no-stdsplit --print-errorlogs --wrap catchsegv
-  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
+      meson test -C build --no-rebuild -t 10 --verbose --no-stdsplit --wrap catchsegv
   only:
     - merge_requests
     - /^.*$/

.gitlab-ci/Dockerfile

@@ -1,26 +1,17 @@
-FROM fedora:30
+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 '*/xvfb-run' gdm-lib accountsservice-libs && \
+    dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 && \
 
     # Unpackaged versions
-    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 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 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

@@ -1,35 +0,0 @@
-#!/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,42 +1,13 @@
-3.33.2
+3.32.2
 ======
-* Fix rendering lag on Xorg [Daniel; !520, !281]
-* Misc. bug fixes and cleanups [Carlos, Marco, Jonas D., Florian, Niels,
-  Daniel, Benjamin, Jonas Å., Ignacio, Vasilis; #598, !576, !547, !578,
-  !583, !582, !469, !524, !119, !571, !584, !585, !586, #425]
-
-Contributors:
-  Jonas Ådahl, Benjamin Berg, Jonas Dreßler, Carlos Garnacho, Niels De Graef,
-  Vasilis Liaskovitis, Florian Müllner, Ignacio Casal Quinteiro,
-  Marco Trevisan (Treviño), Daniel van Vugt
-
-Translators:
-  Daniel Mustieles [es]
-
-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]
+* Fix spurious idle signals that prevent session unblank [Jonas; !543]
+* Misc. bug fixes and cleanups [Olivier, Marco, Carlos; !552, !557, #586]
 
 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]
+  Jonas Ådahl, Olivier Fourdan, Carlos Garnacho, Marco Trevisan (Treviño)
 
 3.32.1
 ======

clutter/clutter/cally/cally-actor.c

@@ -1044,8 +1044,10 @@ _cally_actor_clean_action_list (CallyActor *cally_actor)
 
   if (priv->action_list)
     {
-      g_list_free_full (priv->action_list,
-                        (GDestroyNotify) _cally_actor_destroy_action_info);
+      g_list_foreach (priv->action_list,
+                      (GFunc) _cally_actor_destroy_action_info,
+                      NULL);
+      g_list_free (priv->action_list);
       priv->action_list = NULL;
     }
 }

clutter/clutter/clutter-actor-meta.c

@@ -577,7 +577,8 @@ _clutter_meta_group_clear_metas (ClutterMetaGroup *group)
 {
   g_list_foreach (group->meta, (GFunc) _clutter_actor_meta_set_actor, NULL);
 
-  g_list_free_full (group->meta, g_object_unref);
+  g_list_foreach (group->meta, (GFunc) g_object_unref, NULL);
+  g_list_free (group->meta);
   group->meta = NULL;
 }
 

clutter/clutter/clutter-actor.c

@@ -807,9 +807,6 @@ 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 */
@@ -5986,7 +5983,6 @@ 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),
@@ -6023,18 +6019,6 @@ 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);
@@ -8849,9 +8833,9 @@ _clutter_actor_queue_redraw_full (ClutterActor             *self,
    *
    * later during _clutter_stage_do_update(), once relayouting is done
    * and the scenegraph has been updated we will call:
-   * clutter_stage_maybe_finish_queue_redraws().
+   * _clutter_stage_finish_queue_redraws().
    *
-   * clutter_stage_maybe_finish_queue_redraws() will call
+   * _clutter_stage_finish_queue_redraws() will call
    * _clutter_actor_finish_queue_redraw() for each listed actor.
    *
    * Note: actors *are* allowed to queue further redraws during this
@@ -15900,12 +15884,10 @@ clutter_actor_get_pango_context (ClutterActor *self)
     {
       priv->pango_context = clutter_actor_create_pango_context (self);
 
-      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);
+      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);
     }
   else
     update_pango_context (backend, priv->pango_context);

clutter/clutter/clutter-binding-pool.c

@@ -235,7 +235,8 @@ clutter_binding_pool_finalize (GObject *gobject)
 
   g_hash_table_destroy (pool->entries_hash);
 
-  g_slist_free_full (pool->entries, (GDestroyNotify) binding_entry_free);
+  g_slist_foreach (pool->entries, (GFunc) binding_entry_free, NULL);
+  g_slist_free (pool->entries);
 
   G_OBJECT_CLASS (clutter_binding_pool_parent_class)->finalize (gobject);
 }

clutter/clutter/clutter-blur-effect.c

@@ -249,7 +249,9 @@ 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);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
+                                            0, /* layer number */
+                                            COGL_TEXTURE_TYPE_2D);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);

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

@@ -438,7 +438,9 @@ 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);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
+                                            0, /* layer number */
+                                            COGL_TEXTURE_TYPE_2D);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);

clutter/clutter/clutter-click-action.c

@@ -355,10 +355,6 @@ 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,7 +293,9 @@ 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);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
+                                            0, /* layer number */
+                                            COGL_TEXTURE_TYPE_2D);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);

clutter/clutter/clutter-deform-effect.c

@@ -282,7 +282,6 @@ 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,7 +297,9 @@ 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);
+      cogl_pipeline_set_layer_null_texture (klass->base_pipeline,
+                                            0, /* layer number */
+                                            COGL_TEXTURE_TYPE_2D);
     }
 
   self->pipeline = cogl_pipeline_copy (klass->base_pipeline);

clutter/clutter/clutter-enums.h

@@ -909,6 +909,7 @@ 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.
@@ -927,6 +928,7 @@ 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,9 +1021,6 @@ 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,7 +269,6 @@ struct _ClutterCrossingEvent
   gfloat x;
   gfloat y;
   ClutterInputDevice *device;
-  ClutterEventSequence *sequence;
   ClutterActor *related;
 };
 

clutter/clutter/clutter-feature.c

@@ -64,13 +64,17 @@ 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;
   
-  clutter_flags |= CLUTTER_FEATURE_SHADERS_GLSL;
+  if (cogl_flags & COGL_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,7 +834,6 @@ _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
@@ -871,7 +870,6 @@ _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 */
@@ -1036,10 +1034,9 @@ _clutter_input_device_update (ClutterInputDevice   *device,
   ClutterActor *new_cursor_actor;
   ClutterActor *old_cursor_actor;
   ClutterPoint point = { -1, -1 };
-  ClutterInputDeviceType device_type = device->device_type;
 
-  g_assert (device_type != CLUTTER_KEYBOARD_DEVICE &&
-            device_type != CLUTTER_PAD_DEVICE);
+  if (device->device_type == CLUTTER_KEYBOARD_DEVICE)
+    return NULL;
 
   stage = device->stage;
   if (G_UNLIKELY (stage == NULL))

clutter/clutter/clutter-main.c

@@ -2004,36 +2004,6 @@ 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)
@@ -2207,7 +2177,7 @@ _clutter_process_event_details (ClutterActor        *stage,
           {
             ClutterActor *actor = NULL;
 
-            emit_crossing_event (event, device);
+            emit_pointer_event (event, device);
 
             actor = _clutter_input_device_update (device, NULL, FALSE);
             if (actor != stage)
@@ -2219,12 +2189,12 @@ _clutter_process_event_details (ClutterActor        *stage,
                 crossing->crossing.related = stage;
                 crossing->crossing.source = actor;
 
-                emit_crossing_event (crossing, device);
+                emit_pointer_event (crossing, device);
                 clutter_event_free (crossing);
               }
           }
         else
-          emit_crossing_event (event, device);
+          emit_pointer_event (event, device);
         break;
 
       case CLUTTER_LEAVE:
@@ -2243,10 +2213,10 @@ _clutter_process_event_details (ClutterActor        *stage,
             crossing->crossing.related = stage;
             crossing->crossing.source = device->cursor_actor;
 
-            emit_crossing_event (crossing, device);
+            emit_pointer_event (crossing, device);
             clutter_event_free (crossing);
           }
-        emit_crossing_event (event, device);
+        emit_pointer_event (event, device);
         break;
 
       case CLUTTER_DESTROY_NOTIFY:

clutter/clutter/clutter-master-clock-default.c

@@ -412,7 +412,8 @@ master_clock_advance_timelines (ClutterMasterClockDefault *master_clock)
   for (l = timelines; l != NULL; l = l->next)
     _clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000);
 
-  g_slist_free_full (timelines, g_object_unref);
+  g_slist_foreach (timelines, (GFunc) g_object_unref, NULL);
+  g_slist_free (timelines);
 
 #ifdef CLUTTER_ENABLE_DEBUG
   if (_clutter_diagnostic_enabled ())
@@ -573,7 +574,8 @@ clutter_clock_dispatch (GSource     *source,
 
   master_clock_reschedule_stage_updates (master_clock, stages);
 
-  g_slist_free_full (stages, g_object_unref);
+  g_slist_foreach (stages, (GFunc) g_object_unref, NULL);
+  g_slist_free (stages);
 
   master_clock->prev_tick = master_clock->cur_tick;
 

clutter/clutter/clutter-paint-nodes.c

@@ -75,7 +75,8 @@ _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_pipeline_set_layer_null_texture (default_texture_pipeline, 0,
+                                        COGL_TEXTURE_TYPE_2D);
   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/clutter-path.c

@@ -295,7 +295,8 @@ clutter_path_clear (ClutterPath *path)
 {
   ClutterPathPrivate *priv = path->priv;
 
-  g_slist_free_full (priv->nodes, (GDestroyNotify) clutter_path_node_full_free);
+  g_slist_foreach (priv->nodes, (GFunc) clutter_path_node_full_free, NULL);
+  g_slist_free (priv->nodes);
 
   priv->nodes = priv->nodes_tail = NULL;
   priv->nodes_dirty = TRUE;
@@ -658,7 +659,8 @@ clutter_path_parse_description (const gchar  *p,
   return TRUE;
 
  fail:
-  g_slist_free_full (nodes, (GDestroyNotify) clutter_path_node_full_free);
+  g_slist_foreach (nodes, (GFunc) clutter_path_node_full_free, NULL);
+  g_slist_free (nodes);
   return FALSE;
 }
 

clutter/clutter/clutter-private.h

@@ -303,11 +303,6 @@ gboolean        _clutter_util_matrix_decompose  (const ClutterMatrix *src,
                                                  ClutterVertex       *translate_p,
                                                  ClutterVertex4      *perspective_p);
 
-PangoDirection _clutter_pango_unichar_direction (gunichar ch);
-
-PangoDirection _clutter_pango_find_base_dir     (const gchar *text,
-                                                 gint         length);
-
 typedef struct _ClutterPlane
 {
   float v0[3];

clutter/clutter/clutter-script-parser.c

@@ -2021,7 +2021,8 @@ add_children (ClutterScript *script,
       clutter_container_add_actor (container, CLUTTER_ACTOR (object));
     }
 
-  g_list_free_full (oinfo->children, g_free);
+  g_list_foreach (oinfo->children, (GFunc) g_free, NULL);
+  g_list_free (oinfo->children);
 
   oinfo->children = unresolved;
 }

clutter/clutter/clutter-script.c

@@ -346,12 +346,15 @@ object_info_free (gpointer data)
       g_free (oinfo->class_name);
       g_free (oinfo->type_func);
 
-      g_list_free_full (oinfo->properties, property_info_free);
+      g_list_foreach (oinfo->properties, (GFunc) property_info_free, NULL);
+      g_list_free (oinfo->properties);
 
-      g_list_free_full (oinfo->signals, signal_info_free);
+      g_list_foreach (oinfo->signals, (GFunc) signal_info_free, NULL);
+      g_list_free (oinfo->signals);
 
       /* these are ids */
-      g_list_free_full (oinfo->children, g_free);
+      g_list_foreach (oinfo->children, (GFunc) g_free, NULL);
+      g_list_free (oinfo->children);
 
       /* we unref top-level objects and leave the actors alone,
        * unless we are unmerging in which case we have to destroy
@@ -843,7 +846,8 @@ clutter_script_unmerge_objects (ClutterScript *script,
   for (l = data.ids; l != NULL; l = l->next)
     g_hash_table_remove (priv->objects, l->data);
 
-  g_slist_free_full (data.ids, g_free);
+  g_slist_foreach (data.ids, (GFunc) g_free, NULL);
+  g_slist_free (data.ids);
 
   clutter_script_ensure_objects (script);
 }

clutter/clutter/clutter-stage-manager.c

@@ -89,8 +89,8 @@ clutter_stage_manager_dispose (GObject *gobject)
 
   stage_manager = CLUTTER_STAGE_MANAGER (gobject);
 
-  g_slist_free_full (stage_manager->stages,
-                     (GDestroyNotify) clutter_actor_destroy);
+  g_slist_foreach (stage_manager->stages, (GFunc) clutter_actor_destroy, NULL);
+  g_slist_free (stage_manager->stages);
   stage_manager->stages = NULL;
 
   G_OBJECT_CLASS (clutter_stage_manager_parent_class)->dispose (gobject);

clutter/clutter/clutter-stage.c

@@ -1303,8 +1303,14 @@ clutter_stage_real_queue_redraw (ClutterActor       *actor,
     return TRUE;
 
   if (_clutter_stage_window_ignoring_redraw_clips (stage_window))
-    return FALSE;
+    {
+      _clutter_stage_window_add_redraw_clip (stage_window, NULL);
+      return FALSE;
+    }
 
+  /* Convert the clip volume into stage coordinates and then into an
+   * axis aligned stage coordinates bounding box...
+   */
   if (redraw_clip == NULL)
     {
       _clutter_stage_window_add_redraw_clip (stage_window, NULL);
@@ -1314,8 +1320,6 @@ clutter_stage_real_queue_redraw (ClutterActor       *actor,
   if (redraw_clip->is_empty)
     return TRUE;
 
-  /* Convert the clip volume into stage coordinates and then into an
-   * axis aligned stage coordinates bounding box... */
   _clutter_paint_volume_get_stage_paint_box (redraw_clip,
                                              stage,
                                              &bounding_box);

clutter/clutter/clutter-text.c

@@ -751,7 +751,7 @@ clutter_text_create_layout_no_cache (ClutterText       *text,
       if (priv->password_char != 0)
         pango_dir = PANGO_DIRECTION_NEUTRAL;
       else
-        pango_dir = _clutter_pango_find_base_dir (contents, contents_len);
+        pango_dir = pango_find_base_dir (contents, contents_len);
 
       if (pango_dir == PANGO_DIRECTION_NEUTRAL)
         {

clutter/clutter/clutter-util.c

@@ -32,7 +32,6 @@
 
 #include "clutter-build-config.h"
 
-#include <fribidi.h>
 #include <math.h>
 
 #include "clutter-debug.h"
@@ -106,9 +105,8 @@ _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
     }
 }
 
-void
-_clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
-                                   ClutterRect                 *dest)
+void _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
+                                        ClutterRect                 *dest)
 {
   *dest = (ClutterRect) {
     .origin = {
@@ -122,9 +120,8 @@ _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
   };
 }
 
-void
-_clutter_util_rectangle_int_extents (const  ClutterRect    *src,
-                                     cairo_rectangle_int_t *dest)
+void _clutter_util_rectangle_int_extents (const  ClutterRect    *src,
+                                          cairo_rectangle_int_t *dest)
 {
   ClutterRect tmp = *src;
 
@@ -138,11 +135,10 @@ _clutter_util_rectangle_int_extents (const  ClutterRect    *src,
   };
 }
 
-void
-_clutter_util_rectangle_offset (const cairo_rectangle_int_t *src,
-                                int                          x,
-                                int                          y,
-                                cairo_rectangle_int_t       *dest)
+void _clutter_util_rectangle_offset (const cairo_rectangle_int_t *src,
+                                     int                          x,
+                                     int                          y,
+                                     cairo_rectangle_int_t       *dest)
 {
   *dest = *src;
 
@@ -700,45 +696,3 @@ clutter_interval_register_progress_func (GType               value_type,
 
   G_UNLOCK (progress_funcs);
 }
-
-PangoDirection
-_clutter_pango_unichar_direction (gunichar ch)
-{
-  FriBidiCharType fribidi_ch_type;
-
-  G_STATIC_ASSERT (sizeof (FriBidiChar) == sizeof (gunichar));
-
-  fribidi_ch_type = fribidi_get_bidi_type (ch);
-
-  if (!FRIBIDI_IS_STRONG (fribidi_ch_type))
-    return PANGO_DIRECTION_NEUTRAL;
-  else if (FRIBIDI_IS_RTL (fribidi_ch_type))
-    return PANGO_DIRECTION_RTL;
-  else
-    return PANGO_DIRECTION_LTR;
-}
-
-PangoDirection
-_clutter_pango_find_base_dir (const gchar *text,
-                              gint         length)
-{
-  PangoDirection dir = PANGO_DIRECTION_NEUTRAL;
-  const gchar *p;
-
-  g_return_val_if_fail (text != NULL || length == 0, PANGO_DIRECTION_NEUTRAL);
-
-  p = text;
-  while ((length < 0 || p < text + length) && *p)
-    {
-      gunichar wc = g_utf8_get_char (p);
-
-      dir = _clutter_pango_unichar_direction (wc);
-
-      if (dir != PANGO_DIRECTION_NEUTRAL)
-        break;
-
-      p = g_utf8_next_char (p);
-    }
-
-  return dir;
-}

clutter/clutter/cogl/clutter-stage-cogl.c

@@ -77,10 +77,6 @@ enum
   PROP_LAST
 };
 
-static void
-clutter_stage_cogl_schedule_update (ClutterStageWindow *stage_window,
-                                    gint                sync_delay);
-
 static void
 clutter_stage_cogl_unrealize (ClutterStageWindow *stage_window)
 {
@@ -126,16 +122,6 @@ _clutter_stage_cogl_presented (ClutterStageCogl *stage_cogl,
     }
 
   _clutter_stage_presented (stage_cogl->wrapper, frame_event, frame_info);
-
-  if (frame_event == COGL_FRAME_EVENT_COMPLETE &&
-      stage_cogl->update_time != -1)
-    {
-      ClutterStageWindow *stage_window = CLUTTER_STAGE_WINDOW (stage_cogl);
-
-      stage_cogl->update_time = -1;
-      clutter_stage_cogl_schedule_update (stage_window,
-                                          stage_cogl->last_sync_delay);
-    }
 }
 
 static gboolean
@@ -166,15 +152,10 @@ clutter_stage_cogl_schedule_update (ClutterStageWindow *stage_window,
   gint64 now;
   float refresh_rate;
   gint64 refresh_interval;
-  int64_t min_render_time_allowed;
-  int64_t max_render_time_allowed;
-  int64_t next_presentation_time;
 
   if (stage_cogl->update_time != -1)
     return;
 
-  stage_cogl->last_sync_delay = sync_delay;
-
   now = g_get_monotonic_time ();
 
   if (sync_delay < 0)
@@ -203,18 +184,10 @@ clutter_stage_cogl_schedule_update (ClutterStageWindow *stage_window,
   if (refresh_interval == 0)
     refresh_interval = 16667; /* 1/60th second */
 
-  min_render_time_allowed = refresh_interval / 2;
-  max_render_time_allowed = refresh_interval - 1000 * sync_delay;
+  stage_cogl->update_time = stage_cogl->last_presentation_time + 1000 * sync_delay;
 
-  if (min_render_time_allowed > max_render_time_allowed)
-    min_render_time_allowed = max_render_time_allowed;
-
-  next_presentation_time = stage_cogl->last_presentation_time + refresh_interval;
-
-  while (next_presentation_time < now + min_render_time_allowed)
-    next_presentation_time += refresh_interval;
-
-  stage_cogl->update_time = next_presentation_time - max_render_time_allowed;
+  while (stage_cogl->update_time < now)
+    stage_cogl->update_time += refresh_interval;
 }
 
 static gint64
@@ -300,7 +273,7 @@ clutter_stage_cogl_ignoring_redraw_clips (ClutterStageWindow *stage_window)
 }
 
 /* A redraw clip represents (in stage coordinates) the bounding box of
- * something that needs to be redrawn. Typically they are added to the
+ * something that needs to be redraw. Typically they are added to the
  * StageWindow as a result of clutter_actor_queue_clipped_redraw() by
  * actors such as ClutterGLXTexturePixmap. All redraw clips are
  * discarded after the next paint.
@@ -529,8 +502,8 @@ fill_current_damage_history_and_step (ClutterStageView *view)
   *current_fb_damage = (cairo_rectangle_int_t) {
     .x = 0,
     .y = 0,
-    .width = ceilf (view_rect.width * fb_scale),
-    .height = ceilf (view_rect.height * fb_scale)
+    .width = view_rect.width * fb_scale,
+    .height = view_rect.height * fb_scale
   };
   view_priv->damage_index++;
 }

clutter/clutter/cogl/clutter-stage-cogl.h

@@ -59,8 +59,6 @@ struct _ClutterStageCogl
    * junk frames to start with. */
   unsigned int frame_count;
 
-  gint last_sync_delay;
-
   cairo_rectangle_int_t bounding_redraw_clip;
 
   guint initialized_redraw_clip : 1;

clutter/clutter/deprecated/clutter-texture.c

@@ -1277,7 +1277,9 @@ 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);
+      cogl_pipeline_set_layer_null_texture (pipeline,
+                                            0, /* layer_index */
+                                            COGL_TEXTURE_TYPE_2D);
     }
 
   g_assert (texture_template_pipeline != NULL);

clutter/clutter/x11/clutter-keymap-x11.c

@@ -250,8 +250,7 @@ get_direction (XkbDescPtr xkb,
     {
       int level = 0;
       KeySym sym = XkbKeySymEntry (xkb, code, level, group);
-      PangoDirection dir =
-        _clutter_pango_unichar_direction (clutter_keysym_to_unicode (sym));
+      PangoDirection dir = pango_unichar_direction (clutter_keysym_to_unicode (sym));
 
       switch (dir)
         {

clutter/meson.build

@@ -1,5 +1,7 @@
 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]
@@ -38,7 +40,6 @@ clutter_pkg_deps = [
 ]
 
 clutter_pkg_private_deps = [
-  fribidi_dep,
   gdk_pixbuf_dep,
   gthread_dep,
   gmodule_no_export_dep,

clutter/tests/conform/actor-destroy.c

@@ -114,12 +114,12 @@ test_destroy_destroy (ClutterActor *self)
       test->tex = NULL;
     }
 
-  g_assert_nonnull (test->children);
+  g_list_foreach (test->children, (GFunc) clutter_actor_destroy, NULL);
+  g_list_free (test->children);
+  test->children = NULL;
 
   if (CLUTTER_ACTOR_CLASS (test_destroy_parent_class)->destroy)
     CLUTTER_ACTOR_CLASS (test_destroy_parent_class)->destroy (self);
-
-  g_assert_null (test->children);
 }
 
 static void

clutter/tests/conform/meson.build

@@ -1,3 +1,6 @@
+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',
@@ -49,8 +52,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', meson.current_source_dir())
-test_env.set('G_TEST_BUILDDIR', meson.current_build_dir())
+test_env.set('G_TEST_SRCDIR', clutter_tests_conform_srcdir)
+test_env.set('G_TEST_BUILDDIR', clutter_tests_conform_builddir)
 test_env.set('G_ENABLE_DIAGNOSTIC', '0')
 test_env.set('CLUTTER_ENABLE_DIAGNOSTIC', '0')
 test_env.set('CLUTTER_SCALE', '1')
@@ -71,8 +74,7 @@ foreach test : clutter_conform_tests
     install: false,
   )
 
-  test(test, test_executable,
-    suite: ['clutter', 'clutter/conform'],
+  test('clutter/conform/@0@'.format(test), test_executable,
     env: test_env
   )
 endforeach

clutter/tests/conform/timeline.c

@@ -38,7 +38,8 @@ timeline_data_init (TimelineData *data, int timeline_num)
 static void
 timeline_data_destroy (TimelineData *data)
 {
-  g_slist_free_full (data->markers_hit, g_free);
+  g_slist_foreach (data->markers_hit, (GFunc) g_free, NULL);
+  g_slist_free (data->markers_hit);
 }
 
 static void

clutter/tests/interactive/meson.build

@@ -1,5 +1,7 @@
-clutter_tests_interactive_srcdir = meson.current_source_dir()
+clutter_tests_interactive_srcdir = join_paths(clutter_srcdir, 'tests/interactive')
+
 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),
@@ -29,6 +31,7 @@ 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

@@ -0,0 +1,276 @@
+#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(clutter_tests_interactive_srcdir),
+  '-DTESTS_DATA_DIR="@0@"'.format(join_paths(clutter_srcdir, 'tests/interactive')),
   '-DG_DISABLE_SINGLE_INCLUDES',
   '-DGLIB_DISABLE_DEPRECATION_WARNINGS',
   '-DCOGL_DISABLE_DEPRECATION_WARNINGS',

cogl/cogl-pango/cogl-pango-display-list.c

@@ -483,8 +483,8 @@ _cogl_pango_display_list_node_free (CoglPangoDisplayListNode *node)
 void
 _cogl_pango_display_list_clear (CoglPangoDisplayList *dl)
 {
-  g_slist_free_full (dl->nodes, (GDestroyNotify)
-                     _cogl_pango_display_list_node_free);
+  g_slist_foreach (dl->nodes, (GFunc) _cogl_pango_display_list_node_free, NULL);
+  g_slist_free (dl->nodes);
   dl->nodes = NULL;
   dl->last_node = NULL;
 }

cogl/cogl/cogl-atlas-texture.c

@@ -1013,6 +1013,12 @@ _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 =
   {
@@ -1034,6 +1040,7 @@ 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,21 +562,29 @@ create_migration_texture (CoglContext *ctx,
   CoglTexture *tex;
   CoglError *skip_error = NULL;
 
-  /* 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))
+  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)))
     {
-      cogl_error_free (skip_error);
-      cogl_object_unref (tex);
-      tex = NULL;
+      /* 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;
+        }
     }
+  else
+    tex = NULL;
 
   if (!tex)
     {

cogl/cogl/cogl-bitmap.h

@@ -43,7 +43,6 @@ typedef struct _CoglBitmap CoglBitmap;
 #include <cogl/cogl-buffer.h>
 #include <cogl/cogl-context.h>
 #include <cogl/cogl-pixel-buffer.h>
-#include <cogl/cogl-pixel-format.h>
 
 #include <glib-object.h>
 

cogl/cogl/cogl-context-private.h

@@ -50,6 +50,8 @@
 #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"
@@ -101,6 +103,9 @@ 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;
@@ -164,6 +169,8 @@ 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. */
@@ -262,6 +269,7 @@ struct _CoglContext
   GLuint                  current_gl_program;
 
   gboolean current_gl_dither_enabled;
+  CoglColorMask current_gl_color_mask;
   GLenum current_gl_draw_buffer;
 
   /* Clipping */
@@ -293,6 +301,8 @@ 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,6 +40,8 @@
 #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"
@@ -104,6 +106,30 @@ _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 *
@@ -127,8 +153,10 @@ 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 ();
 
@@ -169,6 +197,9 @@ 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)
@@ -234,6 +265,22 @@ 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 ();
@@ -276,6 +323,8 @@ 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;
@@ -317,6 +366,7 @@ 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;
 
@@ -403,6 +453,41 @@ 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;
@@ -441,6 +526,10 @@ _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,14 +174,33 @@ 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().
@@ -217,6 +236,13 @@ 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,11 +130,22 @@ 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,7 +77,9 @@ 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,10 +61,12 @@ 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,10 +83,11 @@ 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_FRONT_FACE_WINDING = 6,
-  COGL_FRAMEBUFFER_STATE_INDEX_DEPTH_WRITE        = 7,
-  COGL_FRAMEBUFFER_STATE_INDEX_STEREO_MODE        = 8,
-  COGL_FRAMEBUFFER_STATE_INDEX_MAX                = 9
+  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
 } CoglFramebufferStateIndex;
 
 typedef enum _CoglFramebufferState
@@ -97,9 +98,10 @@ typedef enum _CoglFramebufferState
   COGL_FRAMEBUFFER_STATE_DITHER             = 1<<3,
   COGL_FRAMEBUFFER_STATE_MODELVIEW          = 1<<4,
   COGL_FRAMEBUFFER_STATE_PROJECTION         = 1<<5,
-  COGL_FRAMEBUFFER_STATE_FRONT_FACE_WINDING = 1<<6,
-  COGL_FRAMEBUFFER_STATE_DEPTH_WRITE        = 1<<7,
-  COGL_FRAMEBUFFER_STATE_STEREO_MODE        = 1<<8
+  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
 } CoglFramebufferState;
 
 #define COGL_FRAMEBUFFER_STATE_ALL ((1<<COGL_FRAMEBUFFER_STATE_INDEX_MAX) - 1)
@@ -153,6 +155,7 @@ 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,6 +123,8 @@ _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;
@@ -189,6 +191,9 @@ _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)
@@ -255,11 +260,13 @@ 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))
@@ -354,6 +361,31 @@ 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. */
@@ -363,6 +395,16 @@ 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
@@ -510,7 +552,12 @@ cogl_framebuffer_set_viewport (CoglFramebuffer *framebuffer,
   framebuffer->viewport_age++;
 
   if (context->current_draw_buffer == framebuffer)
-    context->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_VIEWPORT;
+    {
+      context->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_VIEWPORT;
+
+      if (context->needs_viewport_scissor_workaround)
+        context->current_draw_buffer_changes |= COGL_FRAMEBUFFER_STATE_CLIP;
+    }
 }
 
 float
@@ -784,7 +831,27 @@ _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)
-    return COGL_FRAMEBUFFER_STATE_VIEWPORT;
+    {
+      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;
+    }
   else
     return 0;
 }
@@ -827,6 +894,17 @@ _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)
@@ -893,6 +971,10 @@ _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);
@@ -998,6 +1080,29 @@ 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)
 {
@@ -1992,6 +2097,15 @@ 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)
 {
@@ -2043,8 +2157,6 @@ draw_wireframe (CoglContext *ctx,
 
   if (!wire_pipeline)
     {
-      static CoglSnippet *snippet = NULL;
-
       wire_pipeline =
         _cogl_pipeline_weak_copy (pipeline, pipeline_destroyed_cb, NULL);
 
@@ -2056,20 +2168,29 @@ 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. */
-
-      /* The snippet is cached so that it will reuse the program
-       * from the pipeline cache if possible */
-      if (snippet == NULL)
+      if (cogl_has_feature (framebuffer->context, COGL_FEATURE_ID_GLSL))
         {
-          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");
-        }
+          static CoglSnippet *snippet = NULL;
 
-      cogl_pipeline_add_snippet (wire_pipeline, snippet);
+          /* 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
+        {
+          cogl_pipeline_foreach_layer (wire_pipeline, remove_layer_cb, NULL);
+          cogl_pipeline_set_color4f (wire_pipeline, 0, 1, 0, 1);
+        }
     }
 
   /* temporarily disable the wireframe to avoid recursion! */

cogl/cogl/cogl-framebuffer.h

@@ -816,6 +816,38 @@ 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
@@ -1129,8 +1161,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 are associated with layers of the given
- * @pipeline.
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
+ * 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
@@ -1171,8 +1203,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 are associated with layers of the given
- * @pipeline.
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
+ * are associated with layers of the given @pipeline.
  *
  * Stability: unstable
  * Since: 1.10
@@ -1214,8 +1246,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 are associated with layers of the given
- * @pipeline.
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
+ * 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
@@ -1280,8 +1312,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 are associated with layers of the given
- * @pipeline.
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or
+ * #CoglTexture3D 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(),
@@ -1348,8 +1380,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 are associated with layers of the given
- * @pipeline.
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or
+ * #CoglTexture3D 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(),
@@ -1443,6 +1475,11 @@ 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
  */
@@ -1495,7 +1532,9 @@ 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.
+ * level textures such as #CoglTexture2D and additionally they
+ * should be textures that can be sampled using normalized coordinates
+ * (so not #CoglTextureRectangle textures).</note>
  *
  * 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
@@ -1509,6 +1548,11 @@ 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
@@ -1612,6 +1656,11 @@ 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,8 +366,9 @@ 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 but not for high level
- * meta textures such as #CoglTexture2DSliced</note>
+ * #CoglTexture<!-- -->s such as #CoglTexture2D or #CoglTexture3D 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,12 +100,21 @@ _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 image_external_extension[] =
+      static const char texture_3d_extension[] =
         "#extension GL_OES_EGL_image_external : require\n";
-      strings[count] = image_external_extension;
-      lengths[count++] = sizeof (image_external_extension) - 1;
+      strings[count] = texture_3d_extension;
+      lengths[count++] = sizeof (texture_3d_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-private.h"
+#include "cogl-texture-rectangle-private.h"
 
 #include <string.h>
 #include <math.h>
@@ -316,9 +316,16 @@ foreach_clamped_region (CoglMetaTexture *meta_texture,
 
   if (wrap_s == COGL_PIPELINE_WRAP_MODE_CLAMP_TO_EDGE)
     {
-      float max_s_coord = 1.0;
+      float max_s_coord;
       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 */
@@ -368,9 +375,16 @@ 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 = 1.0;
+      float max_t_coord;
       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 */
@@ -452,6 +466,33 @@ 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,
@@ -498,16 +539,19 @@ cogl_meta_texture_foreach_in_region (CoglMetaTexture *meta_texture,
    * coordinates beyond this point and only re-normalize just before
    * calling the user's callback... */
 
-  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;
+  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;
+    }
 
   /* XXX: at some point this wont be routed through the CoglTexture
    * vtable, instead there will be a separate CoglMetaTexture
@@ -565,6 +609,21 @@ 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,7 +42,8 @@ G_BEGIN_DECLS
 /**
  * SECTION:cogl-meta-texture
  * @short_description: Interface for high-level textures built from
- *                     low-level textures like #CoglTexture2D.
+ *                     low-level textures like #CoglTexture2D and
+ *                     #CoglTexture3D.
  *
  * Cogl helps to make it easy to deal with high level textures such
  * as #CoglAtlasTexture<!-- -->s, #CoglSubTexture<!-- -->s,
@@ -51,11 +52,12 @@ G_BEGIN_DECLS
  *
  * A #CoglMetaTexture is a texture that might internally be
  * represented by one or more low-level #CoglTexture<!-- -->s
- * 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.
+ * 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.
  *
  * 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-mutter.h

@@ -31,7 +31,7 @@
 #ifndef __COGL_MUTTER_H___
 #define __COGL_MUTTER_H___
 
-#include "cogl-config.h"
+#include "cogl-mutter-config.h"
 #include "cogl-defines.h"
 
 #include <cogl/cogl-texture.h>

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 and not with meta-texture types such as
- * #CoglTexture2DSliced.</note>
+ * #CoglTexture2D, #CoglTexture3D and #CoglTextureRectangle, 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 and not with meta-texture types such as
- * #CoglTexture2DSliced.</note>
+ * #CoglTexture2D, #CoglTexture3D and #CoglTextureRectangle, 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,6 +55,7 @@ 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,
@@ -81,6 +82,8 @@ 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 =
@@ -234,6 +237,11 @@ 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;
@@ -339,6 +347,9 @@ _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,6 +50,11 @@ 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,
@@ -88,6 +93,11 @@ _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,6 +136,87 @@ 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,
@@ -220,13 +301,69 @@ 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)
+                                      int layer_index,
+                                      CoglTextureType texture_type)
 {
+  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);
 }
 
@@ -813,6 +950,14 @@ 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,
@@ -821,7 +966,8 @@ _cogl_pipeline_layer_texture_data_equal (CoglPipelineLayer *authority0,
   if (authority0->texture == NULL)
     {
       if (authority1->texture == NULL)
-        return TRUE;
+        return (_cogl_pipeline_layer_get_texture_type (authority0) ==
+                _cogl_pipeline_layer_get_texture_type (authority1));
       else
         return FALSE;
     }
@@ -1501,6 +1647,18 @@ _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,9 +159,13 @@ 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. The default texture is a 1x1 pixel white texture.
+ * 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.
  *
  * This function is mostly useful if you want to create a base
  * pipeline that you want to create multiple copies from using
@@ -174,7 +178,8 @@ cogl_pipeline_set_layer_texture (CoglPipeline *pipeline,
  */
 void
 cogl_pipeline_set_layer_null_texture (CoglPipeline *pipeline,
-                                      int layer_index);
+                                      int layer_index,
+                                      CoglTextureType texture_type);
 
 /**
  * cogl_pipeline_get_layer_texture:

cogl/cogl/cogl-pipeline-layer.c

@@ -187,6 +187,10 @@ _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)
@@ -268,6 +272,7 @@ _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:
@@ -657,6 +662,16 @@ _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 =
@@ -752,6 +767,7 @@ _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,6 +87,7 @@ 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,
@@ -139,6 +140,8 @@ 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 =
@@ -185,6 +188,7 @@ 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 | \
@@ -196,6 +200,7 @@ 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 | \
@@ -260,6 +265,11 @@ typedef struct
   float           z_far;
 } CoglPipelineFogState;
 
+typedef struct
+{
+  CoglColorMask color_mask;
+} CoglPipelineLogicOpsState;
+
 typedef struct
 {
   CoglPipelineCullFaceMode mode;
@@ -291,6 +301,7 @@ 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,6 +218,16 @@ _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)
@@ -1193,6 +1203,49 @@ 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)
@@ -1898,6 +1951,15 @@ _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,6 +571,38 @@ 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.
@@ -626,6 +658,10 @@ 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,6 +99,7 @@ _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;
 
@@ -188,6 +189,8 @@ _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;
 
@@ -453,7 +456,11 @@ _cogl_pipeline_free (CoglPipeline *pipeline)
     }
 
   if (pipeline->differences & COGL_PIPELINE_STATE_LAYERS)
-    g_list_free_full (pipeline->layer_differences, cogl_object_unref);
+    {
+      g_list_foreach (pipeline->layer_differences,
+                      (GFunc)cogl_object_unref, NULL);
+      g_list_free (pipeline->layer_differences);
+    }
 
   if (pipeline->differences & COGL_PIPELINE_STATE_VERTEX_SNIPPETS)
     _cogl_pipeline_snippet_list_free (&pipeline->big_state->vertex_snippets);
@@ -933,7 +940,12 @@ _cogl_pipeline_copy_differences (CoglPipeline *dest,
 
       if (dest->differences & COGL_PIPELINE_STATE_LAYERS &&
           dest->layer_differences)
-        g_list_free_full (dest->layer_differences, cogl_object_unref);
+        {
+          g_list_foreach (dest->layer_differences,
+                          (GFunc)cogl_object_unref,
+                          NULL);
+          g_list_free (dest->layer_differences);
+        }
 
       for (l = src->layer_differences; l; l = l->next)
         {
@@ -1018,6 +1030,13 @@ _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,
@@ -1131,6 +1150,13 @@ _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,
@@ -1895,6 +1921,7 @@ 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",
@@ -1909,7 +1936,20 @@ fallback_layer_cb (CoglPipelineLayer *layer, void *user_data)
 
   COGL_COUNTER_INC (_cogl_uprof_context, layer_fallback_counter);
 
-  texture = COGL_TEXTURE (ctx->default_gl_texture_2d_tex);
+  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;
+    }
 
   if (texture == NULL)
     {
@@ -2283,6 +2323,11 @@ _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]))
@@ -2602,6 +2647,8 @@ _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] =
@@ -2624,7 +2671,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 == 9,
+  _COGL_STATIC_ASSERT (COGL_PIPELINE_LAYER_STATE_SPARSE_COUNT == 10,
                        "Don't forget to install a hash function for new "
                        "pipeline state and update assert at end of "
                        "_cogl_pipeline_init_state_hash_functions");
@@ -2729,6 +2776,8 @@ _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] =
@@ -2738,7 +2787,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 == 17,
+  _COGL_STATIC_ASSERT (COGL_PIPELINE_STATE_SPARSE_COUNT == 18,
                        "Make sure to install a hash function for "
                        "newly added pipeline state and update assert "
                        "in _cogl_pipeline_init_state_hash_functions");
@@ -3029,13 +3078,15 @@ _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);
 
-  /* Since the driver supports GLSL then we might be using gl_PointCoord
+  /* If 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 */
-  state |= COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS;
+  if (cogl_has_feature (context, COGL_FEATURE_ID_GLSL))
+    state |= COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS;
 
   return state;
 }

cogl/cogl/cogl-pixel-format.c

@@ -1,374 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2007,2008,2009,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.
- *
- *
- */
-
-#include "cogl-config.h"
-#include "cogl-defines.h"
-
-#include <string.h>
-#include <math.h>
-#include <stdlib.h>
-
-#include "cogl-pixel-format.h"
-
-/* An entry to map CoglPixelFormats to their respective properties */
-typedef struct _CoglPixelFormatInfo
-{
-  CoglPixelFormat cogl_format;
-  const char *format_str;
-  int bpp;                         /* Bytes per pixel                 */
-  int aligned;                     /* Aligned components? (-1 if n/a) */
-} CoglPixelFormatInfo;
-
-static const CoglPixelFormatInfo format_info_table[] = {
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_ANY,
-    .format_str = "ANY",
-    .bpp = 0,
-    .aligned = -1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_A_8,
-    .format_str = "A_8",
-    .bpp = 1,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGB_565,
-    .format_str = "RGB_565",
-    .bpp = 2,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGBA_4444,
-    .format_str = "RGBA_4444",
-    .bpp = 2,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGBA_5551,
-    .format_str = "RGBA_5551",
-    .bpp = 2,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_YUV,
-    .format_str = "YUV",
-    .bpp = 0,
-    .aligned = -1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_G_8,
-    .format_str = "G_8",
-    .bpp = 1,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RG_88,
-    .format_str = "RG_88",
-    .bpp = 2,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGB_888,
-    .format_str = "RGB_888",
-    .bpp = 3,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_BGR_888,
-    .format_str = "BGR_888",
-    .bpp = 3,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGBA_8888,
-    .format_str = "RGBA_8888",
-    .bpp = 4,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_BGRA_8888,
-    .format_str = "BGRA_8888",
-    .bpp = 4,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_ARGB_8888,
-    .format_str = "ARGB_8888",
-    .bpp = 4,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_ABGR_8888,
-    .format_str = "ABGR_8888",
-    .bpp = 4,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGBA_1010102,
-    .format_str = "RGBA_1010102",
-    .bpp = 4,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_BGRA_1010102,
-    .format_str = "BGRA_1010102",
-    .bpp = 4,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_ARGB_2101010,
-    .format_str = "ARGB_2101010",
-    .bpp = 4,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_ABGR_2101010,
-    .format_str = "ABGR_2101010",
-    .bpp = 4,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGBA_8888_PRE,
-    .format_str = "RGBA_8888_PRE",
-    .bpp = 4,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_BGRA_8888_PRE,
-    .format_str = "BGRA_8888_PRE",
-    .bpp = 4,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_ARGB_8888_PRE,
-    .format_str = "ARGB_8888_PRE",
-    .bpp = 4,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_ABGR_8888_PRE,
-    .format_str = "ABGR_8888_PRE",
-    .bpp = 4,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGBA_4444_PRE,
-    .format_str = "RGBA_4444_PRE",
-    .bpp = 2,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGBA_5551_PRE,
-    .format_str = "RGBA_5551_PRE",
-    .bpp = 2,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_RGBA_1010102_PRE,
-    .format_str = "RGBA_1010102_PRE",
-    .bpp = 4,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_BGRA_1010102_PRE,
-    .format_str = "BGRA_1010102_PRE",
-    .bpp = 4,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_ARGB_2101010_PRE,
-    .format_str = "ARGB_2101010_PRE",
-    .bpp = 4,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_ABGR_2101010_PRE,
-    .format_str = "ABGR_2101010_PRE",
-    .bpp = 4,
-    .aligned = 0
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_DEPTH_16,
-    .format_str = "DEPTH_16",
-    .bpp = 2,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_DEPTH_32,
-    .format_str = "DEPTH_32",
-    .bpp = 4,
-    .aligned = 1
-  },
-  {
-    .cogl_format = COGL_PIXEL_FORMAT_DEPTH_24_STENCIL_8,
-    .format_str = "DEPTH_24_STENCIL_8",
-    .bpp = 4,
-    .aligned = 1
-  },
-};
-
-/*
- * Returns the number of bytes-per-pixel of a given format. The bpp
- * can be extracted from the least significant nibble of the pixel
- * format (see CoglPixelFormat).
- *
- * The mapping is the following (see discussion on bug #660188):
- *
- * 0     = undefined
- * 1, 8  = 1 bpp (e.g. A_8, G_8)
- * 2     = 3 bpp, aligned (e.g. 888)
- * 3     = 4 bpp, aligned (e.g. 8888)
- * 4-6   = 2 bpp, not aligned (e.g. 565, 4444, 5551)
- * 7     = undefined yuv
- * 9     = 2 bpp, aligned
- * 10     = undefined
- * 11     = undefined
- * 12    = 3 bpp, not aligned
- * 13    = 4 bpp, not aligned (e.g. 2101010)
- * 14-15 = undefined
- */
-int
-_cogl_pixel_format_get_bytes_per_pixel (CoglPixelFormat format)
-{
-  size_t i;
-
-  for (i = 0; i < G_N_ELEMENTS (format_info_table); i++)
-    {
-      if (format_info_table[i].cogl_format == format)
-        return format_info_table[i].bpp;
-    }
-
-  g_assert_not_reached ();
-}
-
-/* Note: this also refers to the mapping defined above for
- * _cogl_pixel_format_get_bytes_per_pixel() */
-gboolean
-_cogl_pixel_format_is_endian_dependant (CoglPixelFormat format)
-{
-  int aligned = -1;
-  size_t i;
-
-  /* NB: currently checking whether the format components are aligned
-   * or not determines whether the format is endian dependent or not.
-   * In the future though we might consider adding formats with
-   * aligned components that are also endian independant. */
-
-  for (i = 0; i < G_N_ELEMENTS (format_info_table); i++)
-    {
-      if (format_info_table[i].cogl_format == format)
-        {
-          aligned = format_info_table[i].aligned;
-          break;
-        }
-    }
-
-  g_return_val_if_fail (aligned != -1, FALSE);
-
-  return aligned;
-}
-
-const char *
-cogl_pixel_format_to_string (CoglPixelFormat format)
-{
-  size_t i;
-
-  for (i = 0; i < G_N_ELEMENTS (format_info_table); i++)
-    {
-      if (format_info_table[i].cogl_format == format)
-        return format_info_table[i].format_str;
-    }
-
-  g_assert_not_reached ();
-}
-
-#ifdef COGL_HAS_LIBDRM
-
-typedef struct _PixelFormatMap {
-  uint32_t drm_format;
-  CoglPixelFormat cogl_format;
-  CoglTextureComponents cogl_components;
-} PixelFormatMap;
-
-static const PixelFormatMap pixel_format_map[] = {
-/* DRM formats are defined as little-endian, not machine endian. */
-#if G_BYTE_ORDER == G_LITTLE_ENDIAN
-  { DRM_FORMAT_RGB565,   COGL_PIXEL_FORMAT_RGB_565,       COGL_TEXTURE_COMPONENTS_RGB  },
-  { DRM_FORMAT_ABGR8888, COGL_PIXEL_FORMAT_RGBA_8888_PRE, COGL_TEXTURE_COMPONENTS_RGBA },
-  { DRM_FORMAT_XBGR8888, COGL_PIXEL_FORMAT_RGBA_8888_PRE, COGL_TEXTURE_COMPONENTS_RGB  },
-  { DRM_FORMAT_ARGB8888, COGL_PIXEL_FORMAT_BGRA_8888_PRE, COGL_TEXTURE_COMPONENTS_RGBA },
-  { DRM_FORMAT_XRGB8888, COGL_PIXEL_FORMAT_BGRA_8888_PRE, COGL_TEXTURE_COMPONENTS_RGB  },
-  { DRM_FORMAT_BGRA8888, COGL_PIXEL_FORMAT_ARGB_8888_PRE, COGL_TEXTURE_COMPONENTS_RGBA },
-  { DRM_FORMAT_BGRX8888, COGL_PIXEL_FORMAT_ARGB_8888_PRE, COGL_TEXTURE_COMPONENTS_RGB  },
-  { DRM_FORMAT_RGBA8888, COGL_PIXEL_FORMAT_ABGR_8888_PRE, COGL_TEXTURE_COMPONENTS_RGBA },
-  { DRM_FORMAT_RGBX8888, COGL_PIXEL_FORMAT_ABGR_8888_PRE, COGL_TEXTURE_COMPONENTS_RGB  },
-#elif G_BYTE_ORDER == G_BIG_ENDIAN
-  /* DRM_FORMAT_RGB565 cannot be expressed. */
-  { DRM_FORMAT_ABGR8888, COGL_PIXEL_FORMAT_ABGR_8888_PRE, COGL_TEXTURE_COMPONENTS_RGBA },
-  { DRM_FORMAT_XBGR8888, COGL_PIXEL_FORMAT_ABGR_8888_PRE, COGL_TEXTURE_COMPONENTS_RGB  },
-  { DRM_FORMAT_ARGB8888, COGL_PIXEL_FORMAT_ARGB_8888_PRE, COGL_TEXTURE_COMPONENTS_RGBA },
-  { DRM_FORMAT_XRGB8888, COGL_PIXEL_FORMAT_ARGB_8888_PRE, COGL_TEXTURE_COMPONENTS_RGB  },
-  { DRM_FORMAT_BGRA8888, COGL_PIXEL_FORMAT_BGRA_8888_PRE, COGL_TEXTURE_COMPONENTS_RGBA },
-  { DRM_FORMAT_BGRX8888, COGL_PIXEL_FORMAT_BGRA_8888_PRE, COGL_TEXTURE_COMPONENTS_RGB  },
-  { DRM_FORMAT_RGBA8888, COGL_PIXEL_FORMAT_RGBA_8888_PRE, COGL_TEXTURE_COMPONENTS_RGBA },
-  { DRM_FORMAT_RGBX8888, COGL_PIXEL_FORMAT_RGBA_8888_PRE, COGL_TEXTURE_COMPONENTS_RGB  },
-#else
-#error "unexpected G_BYTE_ORDER"
-#endif
-};
-
-gboolean
-cogl_pixel_format_from_drm_format (uint32_t               drm_format,
-                                   CoglPixelFormat       *out_format,
-                                   CoglTextureComponents *out_components)
-{
-  const size_t n = G_N_ELEMENTS (pixel_format_map);
-  size_t i;
-
-  for (i = 0; i < n; i++)
-    {
-      if (pixel_format_map[i].drm_format == drm_format)
-        break;
-    }
-
-  if (i == n)
-    return FALSE;
-
-  if (out_format)
-    *out_format = pixel_format_map[i].cogl_format;
-
-  if (out_components)
-    *out_components = pixel_format_map[i].cogl_components;
-
-  return TRUE;
-}
-
-#endif

cogl/cogl/cogl-pixel-format.h

@@ -1,335 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2008,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.
- *
- *
- */
-
-#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
-#error "Only <cogl/cogl.h> can be included directly."
-#endif
-
-#ifndef __COGL_PIXEL_FORMAT_H__
-#define __COGL_PIXEL_FORMAT_H__
-
-#include <stdint.h>
-#include <stddef.h>
-
-#ifdef COGL_HAS_LIBDRM
-#include <drm_fourcc.h>
-#endif
-
-#include <cogl/cogl-defines.h>
-
-#include <glib.h>
-#include <glib-object.h>
-
-G_BEGIN_DECLS
-
-/**
- * SECTION:cogl-pixel-format
- * @short_description: Pixel formats supported by Cogl
- *
- * The pixel format of an image descrbes how the bits of each pixel are
- * represented in memory. For example: an image can be laid out as one long
- * sequence of pixels, where each pixel is a sequence of 8 bits of Red, Green
- * and Blue. The amount of bits that are used can be different for each pixel
- * format, as well as the components (for example an Alpha layer to include
- * transparency, or non_RGBA).
- *
- * Other examples of factors that can influence the layout in memory are the
- * system's endianness.
- *
- * This file also contains methods to map Linux DRM 4CC codes to
- * CoglPixelFormats.
- */
-
-#define COGL_A_BIT              (1 << 4)
-#define COGL_BGR_BIT            (1 << 5)
-#define COGL_AFIRST_BIT         (1 << 6)
-#define COGL_PREMULT_BIT        (1 << 7)
-#define COGL_DEPTH_BIT          (1 << 8)
-#define COGL_STENCIL_BIT        (1 << 9)
-
-/* XXX: Notes to those adding new formats here...
- *
- * First this diagram outlines how we allocate the 32bits of a
- * CoglPixelFormat currently...
- *
- *                            6 bits for flags
- *                          |-----|
- *  enum        unused             4 bits for the bytes-per-pixel
- *                                 and component alignment info
- *  |------| |-------------|       |--|
- *  00000000 xxxxxxxx xxxxxxSD PFBA0000
- *                          ^ stencil
- *                           ^ depth
- *                             ^ premult
- *                              ^ alpha first
- *                               ^ bgr order
- *                                ^ has alpha
- *
- * The most awkward part about the formats is how we use the last 4
- * bits to encode the bytes per pixel and component alignment
- * information. Ideally we should have had 3 bits for the bpp and a
- * flag for alignment but we didn't plan for that in advance so we
- * instead use a small lookup table to query the bpp and whether the
- * components are byte aligned or not.
- *
- * The mapping is the following (see discussion on bug #660188):
- *
- * 0     = undefined
- * 1, 8  = 1 bpp (e.g. A_8, G_8)
- * 2     = 3 bpp, aligned (e.g. 888)
- * 3     = 4 bpp, aligned (e.g. 8888)
- * 4-6   = 2 bpp, not aligned (e.g. 565, 4444, 5551)
- * 7     = YUV: undefined bpp, undefined alignment
- * 9     = 2 bpp, aligned
- * 10    = depth, aligned (8, 16, 24, 32, 32f)
- * 11    = undefined
- * 12    = 3 bpp, not aligned
- * 13    = 4 bpp, not aligned (e.g. 2101010)
- * 14-15 = undefined
- *
- * Note: the gap at 10-11 is just because we wanted to maintain that
- * all non-aligned formats have the third bit set in case that's
- * useful later.
- *
- * Since we don't want to waste bits adding more and more flags, we'd
- * like to see most new pixel formats that can't be represented
- * uniquely with the existing flags in the least significant byte
- * simply be enumerated with sequential values in the most significant
- * enum byte.
- *
- * Note: Cogl avoids exposing any padded XRGB or RGBX formats and
- * instead we leave it up to applications to decided whether they
- * consider the A component as padding or valid data. We shouldn't
- * change this policy without good reasoning.
- *
- * So to add a new format:
- * 1) Use the mapping table above to figure out what to but in
- *    the lowest nibble.
- * 2) OR in the COGL_PREMULT_BIT, COGL_AFIRST_BIT, COGL_A_BIT and
- *    COGL_BGR_BIT flags as appropriate.
- * 3) If the result is not yet unique then also combine with an
- *    increment of the last sequence number in the most significant
- *    byte.
- *
- * The last sequence number used was 0 (i.e. no formats currently need
- *                                      a sequence number)
- * Update this note whenever a new sequence number is used.
- */
-/**
- * CoglPixelFormat:
- * @COGL_PIXEL_FORMAT_ANY: Any format
- * @COGL_PIXEL_FORMAT_A_8: 8 bits alpha mask
- * @COGL_PIXEL_FORMAT_RG_88: RG, 16 bits. Note that red-green textures
- *   are only available if %COGL_FEATURE_ID_TEXTURE_RG is advertised.
- *   See cogl_texture_set_components() for details.
- * @COGL_PIXEL_FORMAT_RGB_565: RGB, 16 bits
- * @COGL_PIXEL_FORMAT_RGBA_4444: RGBA, 16 bits
- * @COGL_PIXEL_FORMAT_RGBA_5551: RGBA, 16 bits
- * @COGL_PIXEL_FORMAT_YUV: Not currently supported
- * @COGL_PIXEL_FORMAT_G_8: Single luminance component
- * @COGL_PIXEL_FORMAT_RGB_888: RGB, 24 bits
- * @COGL_PIXEL_FORMAT_BGR_888: BGR, 24 bits
- * @COGL_PIXEL_FORMAT_RGBA_8888: RGBA, 32 bits
- * @COGL_PIXEL_FORMAT_BGRA_8888: BGRA, 32 bits
- * @COGL_PIXEL_FORMAT_ARGB_8888: ARGB, 32 bits
- * @COGL_PIXEL_FORMAT_ABGR_8888: ABGR, 32 bits
- * @COGL_PIXEL_FORMAT_RGBA_1010102 : RGBA, 32 bits, 10 bpc
- * @COGL_PIXEL_FORMAT_BGRA_1010102 : BGRA, 32 bits, 10 bpc
- * @COGL_PIXEL_FORMAT_ARGB_2101010 : ARGB, 32 bits, 10 bpc
- * @COGL_PIXEL_FORMAT_ABGR_2101010 : ABGR, 32 bits, 10 bpc
- * @COGL_PIXEL_FORMAT_RGBA_8888_PRE: Premultiplied RGBA, 32 bits
- * @COGL_PIXEL_FORMAT_BGRA_8888_PRE: Premultiplied BGRA, 32 bits
- * @COGL_PIXEL_FORMAT_ARGB_8888_PRE: Premultiplied ARGB, 32 bits
- * @COGL_PIXEL_FORMAT_ABGR_8888_PRE: Premultiplied ABGR, 32 bits
- * @COGL_PIXEL_FORMAT_RGBA_4444_PRE: Premultiplied RGBA, 16 bits
- * @COGL_PIXEL_FORMAT_RGBA_5551_PRE: Premultiplied RGBA, 16 bits
- * @COGL_PIXEL_FORMAT_RGBA_1010102_PRE: Premultiplied RGBA, 32 bits, 10 bpc
- * @COGL_PIXEL_FORMAT_BGRA_1010102_PRE: Premultiplied BGRA, 32 bits, 10 bpc
- * @COGL_PIXEL_FORMAT_ARGB_2101010_PRE: Premultiplied ARGB, 32 bits, 10 bpc
- * @COGL_PIXEL_FORMAT_ABGR_2101010_PRE: Premultiplied ABGR, 32 bits, 10 bpc
- *
- * Pixel formats used by Cogl. For the formats with a byte per
- * component, the order of the components specify the order in
- * increasing memory addresses. So for example
- * %COGL_PIXEL_FORMAT_RGB_888 would have the red component in the
- * lowest address, green in the next address and blue after that
- * regardless of the endianness of the system.
- *
- * For the formats with non byte aligned components the component
- * order specifies the order within a 16-bit or 32-bit number from
- * most significant bit to least significant. So for
- * %COGL_PIXEL_FORMAT_RGB_565, the red component would be in bits
- * 11-15, the green component would be in 6-11 and the blue component
- * would be in 1-5. Therefore the order in memory depends on the
- * endianness of the system.
- *
- * When uploading a texture %COGL_PIXEL_FORMAT_ANY can be used as the
- * internal format. Cogl will try to pick the best format to use
- * internally and convert the texture data if necessary.
- *
- * Since: 0.8
- */
-typedef enum /*< prefix=COGL_PIXEL_FORMAT >*/
-{
-  COGL_PIXEL_FORMAT_ANY           = 0,
-  COGL_PIXEL_FORMAT_A_8           = 1 | COGL_A_BIT,
-
-  COGL_PIXEL_FORMAT_RGB_565       = 4,
-  COGL_PIXEL_FORMAT_RGBA_4444     = 5 | COGL_A_BIT,
-  COGL_PIXEL_FORMAT_RGBA_5551     = 6 | COGL_A_BIT,
-  COGL_PIXEL_FORMAT_YUV           = 7,
-  COGL_PIXEL_FORMAT_G_8           = 8,
-
-  COGL_PIXEL_FORMAT_RG_88         = 9,
-
-  COGL_PIXEL_FORMAT_RGB_888       = 2,
-  COGL_PIXEL_FORMAT_BGR_888       = (2 | COGL_BGR_BIT),
-
-  COGL_PIXEL_FORMAT_RGBA_8888     = (3 | COGL_A_BIT),
-  COGL_PIXEL_FORMAT_BGRA_8888     = (3 | COGL_A_BIT | COGL_BGR_BIT),
-  COGL_PIXEL_FORMAT_ARGB_8888     = (3 | COGL_A_BIT | COGL_AFIRST_BIT),
-  COGL_PIXEL_FORMAT_ABGR_8888     = (3 | COGL_A_BIT | COGL_BGR_BIT | COGL_AFIRST_BIT),
-
-  COGL_PIXEL_FORMAT_RGBA_1010102  = (13 | COGL_A_BIT),
-  COGL_PIXEL_FORMAT_BGRA_1010102  = (13 | COGL_A_BIT | COGL_BGR_BIT),
-  COGL_PIXEL_FORMAT_ARGB_2101010  = (13 | COGL_A_BIT | COGL_AFIRST_BIT),
-  COGL_PIXEL_FORMAT_ABGR_2101010  = (13 | COGL_A_BIT | COGL_BGR_BIT | COGL_AFIRST_BIT),
-
-  COGL_PIXEL_FORMAT_RGBA_8888_PRE = (3 | COGL_A_BIT | COGL_PREMULT_BIT),
-  COGL_PIXEL_FORMAT_BGRA_8888_PRE = (3 | COGL_A_BIT | COGL_PREMULT_BIT | COGL_BGR_BIT),
-  COGL_PIXEL_FORMAT_ARGB_8888_PRE = (3 | COGL_A_BIT | COGL_PREMULT_BIT | COGL_AFIRST_BIT),
-  COGL_PIXEL_FORMAT_ABGR_8888_PRE = (3 | COGL_A_BIT | COGL_PREMULT_BIT | COGL_BGR_BIT | COGL_AFIRST_BIT),
-  COGL_PIXEL_FORMAT_RGBA_4444_PRE = (COGL_PIXEL_FORMAT_RGBA_4444 | COGL_A_BIT | COGL_PREMULT_BIT),
-  COGL_PIXEL_FORMAT_RGBA_5551_PRE = (COGL_PIXEL_FORMAT_RGBA_5551 | COGL_A_BIT | COGL_PREMULT_BIT),
-
-  COGL_PIXEL_FORMAT_RGBA_1010102_PRE = (COGL_PIXEL_FORMAT_RGBA_1010102 | COGL_PREMULT_BIT),
-  COGL_PIXEL_FORMAT_BGRA_1010102_PRE = (COGL_PIXEL_FORMAT_BGRA_1010102 | COGL_PREMULT_BIT),
-  COGL_PIXEL_FORMAT_ARGB_2101010_PRE = (COGL_PIXEL_FORMAT_ARGB_2101010 | COGL_PREMULT_BIT),
-  COGL_PIXEL_FORMAT_ABGR_2101010_PRE = (COGL_PIXEL_FORMAT_ABGR_2101010 | COGL_PREMULT_BIT),
-
-  COGL_PIXEL_FORMAT_DEPTH_16  = (9 | COGL_DEPTH_BIT),
-  COGL_PIXEL_FORMAT_DEPTH_32  = (3 | COGL_DEPTH_BIT),
-
-  COGL_PIXEL_FORMAT_DEPTH_24_STENCIL_8 = (3 | COGL_DEPTH_BIT | COGL_STENCIL_BIT)
-} CoglPixelFormat;
-
-/*
- * _cogl_pixel_format_get_bytes_per_pixel:
- * @format: a #CoglPixelFormat
- *
- * Queries how many bytes a pixel of the given @format takes.
- *
- * Return value: The number of bytes taken for a pixel of the given
- *               @format.
- */
-int
-_cogl_pixel_format_get_bytes_per_pixel (CoglPixelFormat format);
-
-/*
- * _cogl_pixel_format_has_aligned_components:
- * @format: a #CoglPixelFormat
- *
- * Queries whether the ordering of the components for the given
- * @format depend on the endianness of the host CPU or if the
- * components can be accessed using bit shifting and bitmasking by
- * loading a whole pixel into a word.
- *
- * XXX: If we ever consider making something like this public we
- * should really try to think of a better name and come up with
- * much clearer documentation since it really depends on what
- * point of view you consider this from whether a format like
- * COGL_PIXEL_FORMAT_RGBA_8888 is endian dependent. E.g. If you
- * read an RGBA_8888 pixel into a uint32
- * it's endian dependent how you mask out the different channels.
- * But If you already have separate color components and you want
- * to write them to an RGBA_8888 pixel then the bytes can be
- * written sequentially regardless of the endianness.
- *
- * Return value: %TRUE if you need to consider the host CPU
- *               endianness when dealing with the given @format
- *               else %FALSE.
- */
-gboolean
-_cogl_pixel_format_is_endian_dependant (CoglPixelFormat format);
-
-/*
- * COGL_PIXEL_FORMAT_CAN_HAVE_PREMULT(format):
- * @format: a #CoglPixelFormat
- *
- * Returns TRUE if the pixel format can take a premult bit. This is
- * currently true for all formats that have an alpha channel except
- * COGL_PIXEL_FORMAT_A_8 (because that doesn't have any other
- * components to multiply by the alpha).
- */
-#define COGL_PIXEL_FORMAT_CAN_HAVE_PREMULT(format) \
-  (((format) & COGL_A_BIT) && (format) != COGL_PIXEL_FORMAT_A_8)
-
-/**
- * cogl_pixel_format_to_string:
- * @format: a #CoglPixelFormat
- *
- * Returns a string representation of @format, useful for debugging purposes.
- *
- * Returns: (transfer none): A string representation of @format.
- */
-const char *
-cogl_pixel_format_to_string (CoglPixelFormat format);
-
-#ifdef COGL_HAS_LIBDRM
-
-/* added in libdrm 2.4.95 */
-#ifndef DRM_FORMAT_INVALID
-#define DRM_FORMAT_INVALID 0
-#endif
-
-/**
- * cogl_pixel_format_from_drm_format:
- * @drm_format: The DRM 4CC code (as specified in drm_fourcc.h)
- * @out_format: (optional): The corresponding #CoglPixelFormat (if successful)
- * @out_components: (optional): The corresponding #CoglTextureComponents (if
- *    sucessful)
- *
- * Does an internal lookup to find a #CoglPixelFormat that matches the given
- * DRM 4CC code. If no such format could be found, this function will return
- * %FALSE and the output parameters will stay untouched.
- *
- * Returns: %TRUE if a #CoglPixelFormat corresponding to the 4CC code exists,
- * %FALSE otherwise.
- */
-gboolean
-cogl_pixel_format_from_drm_format (uint32_t               drm_format,
-                                   CoglPixelFormat       *out_format,
-                                   CoglTextureComponents *out_components);
-
-#endif
-
-G_END_DECLS
-
-#endif /* __COGL_PIXEL_FORMAT_H__ */

cogl/cogl/cogl-primitive-texture.h

@@ -42,13 +42,14 @@ G_BEGIN_DECLS
 /**
  * SECTION:cogl-primitive-texture
  * @short_description: Interface for low-level textures like
- *                     #CoglTexture2D.
+ *                     #CoglTexture2D and #CoglTexture3D.
  *
  * A #CoglPrimitiveTexture is a texture that is directly represented
- * 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.
+ * 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.
  *
  * 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 are associated with layers of the given
- * @pipeline.
+ * a GPU such as #CoglTexture2D, #CoglTextureRectangle or #CoglTexture3D
+ * are associated with layers of the given @pipeline.
  *
  * Stability: unstable
  * Since: 1.16

cogl/cogl/cogl-primitives.c

@@ -187,6 +187,8 @@ 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
  */
@@ -425,9 +427,11 @@ 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}: always.
+ * - CoglTexture{1D,2D,3D}: 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-private.h

@@ -116,6 +116,57 @@ _cogl_get_enable_legacy_state (void);
 #define _cogl_has_private_feature(ctx, feature) \
   COGL_FLAGS_GET ((ctx)->private_features, (feature))
 
+/*
+ * _cogl_pixel_format_get_bytes_per_pixel:
+ * @format: a #CoglPixelFormat
+ *
+ * Queries how many bytes a pixel of the given @format takes.
+ *
+ * Return value: The number of bytes taken for a pixel of the given
+ *               @format.
+ */
+int
+_cogl_pixel_format_get_bytes_per_pixel (CoglPixelFormat format);
+
+/*
+ * _cogl_pixel_format_has_aligned_components:
+ * @format: a #CoglPixelFormat
+ *
+ * Queries whether the ordering of the components for the given
+ * @format depend on the endianness of the host CPU or if the
+ * components can be accessed using bit shifting and bitmasking by
+ * loading a whole pixel into a word.
+ *
+ * XXX: If we ever consider making something like this public we
+ * should really try to think of a better name and come up with
+ * much clearer documentation since it really depends on what
+ * point of view you consider this from whether a format like
+ * COGL_PIXEL_FORMAT_RGBA_8888 is endian dependent. E.g. If you
+ * read an RGBA_8888 pixel into a uint32
+ * it's endian dependent how you mask out the different channels.
+ * But If you already have separate color components and you want
+ * to write them to an RGBA_8888 pixel then the bytes can be
+ * written sequentially regardless of the endianness.
+ *
+ * Return value: %TRUE if you need to consider the host CPU
+ *               endianness when dealing with the given @format
+ *               else %FALSE.
+ */
+gboolean
+_cogl_pixel_format_is_endian_dependant (CoglPixelFormat format);
+
+/*
+ * COGL_PIXEL_FORMAT_CAN_HAVE_PREMULT(format):
+ * @format: a #CoglPixelFormat
+ *
+ * Returns TRUE if the pixel format can take a premult bit. This is
+ * currently true for all formats that have an alpha channel except
+ * COGL_PIXEL_FORMAT_A_8 (because that doesn't have any other
+ * components to multiply by the alpha).
+ */
+#define COGL_PIXEL_FORMAT_CAN_HAVE_PREMULT(format) \
+  (((format) & COGL_A_BIT) && (format) != COGL_PIXEL_FORMAT_A_8)
+
 G_END_DECLS
 
 #endif /* __COGL_PRIVATE_H__ */

cogl/cogl/cogl-renderer.c

@@ -194,8 +194,10 @@ _cogl_renderer_free (CoglRenderer *renderer)
   if (renderer->libgl_module)
     g_module_close (renderer->libgl_module);
 
-  g_slist_free_full (renderer->event_filters,
-                     (GDestroyNotify) native_filter_closure_free);
+  g_slist_foreach (renderer->event_filters,
+                   (GFunc) native_filter_closure_free,
+                   NULL);
+  g_slist_free (renderer->event_filters);
 
   g_array_free (renderer->poll_fds, TRUE);
 
@@ -782,7 +784,8 @@ cogl_renderer_get_n_fragment_texture_units (CoglRenderer *renderer)
   _COGL_GET_CONTEXT (ctx, 0);
 
 #if defined (HAVE_COGL_GL) || defined (HAVE_COGL_GLES2)
-  GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_IMAGE_UNITS, &n));
+  if (cogl_has_feature (ctx, COGL_FEATURE_ID_GLSL))
+    GE (ctx, glGetIntegerv (GL_MAX_TEXTURE_IMAGE_UNITS, &n));
 #endif
 
   return n;

cogl/cogl/cogl-sub-texture.c

@@ -40,6 +40,7 @@
 #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"
@@ -59,13 +60,30 @@ _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);
 
-  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;
+  /* 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;
+    }
 }
 
 static void
@@ -73,13 +91,31 @@ _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);
 
-  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;
+  /* 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;
+    }
 }
 
 typedef struct _CoglSubTextureForeachData
@@ -129,7 +165,8 @@ _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))
+  if (cogl_is_texture_2d (full_texture) ||
+      cogl_is_texture_rectangle (full_texture))
     {
       callback (sub_tex->full_texture,
                 mapped_coords,
@@ -415,6 +452,14 @@ _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 =
   {
@@ -436,6 +481,7 @@ 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,6 +585,65 @@ _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,
@@ -641,9 +700,18 @@ setup_spans (CoglContext *ctx,
   int   (*slices_for_size) (int, int, int, GArray*);
 
   /* Initialize size of largest slice according to supported features */
-  max_width = width;
-  max_height = height;
-  slices_for_size = _cogl_rect_slices_for_size;
+  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;
+    }
 
   /* Negative number means no slicing forced by the user */
   if (max_waste <= -1)
@@ -931,7 +999,9 @@ _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. */
+  /* 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 */
   _COGL_RETURN_VAL_IF_FAIL (gl_target == GL_TEXTURE_2D, NULL);
 
   /* Assert it is a valid GL texture object */
@@ -1442,6 +1512,12 @@ _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 =
   {
@@ -1463,6 +1539,7 @@ 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,7 +505,14 @@ _cogl_texture_2d_is_sliced (CoglTexture *tex)
 static gboolean
 _cogl_texture_2d_can_hardware_repeat (CoglTexture *tex)
 {
-  return TRUE;
+  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;
 }
 
 static void
@@ -667,6 +674,12 @@ _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 =
   {
@@ -688,6 +701,7 @@ 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,6 +55,11 @@ 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;
@@ -100,6 +105,11 @@ 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
@@ -128,6 +138,11 @@ 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.
  *
@@ -164,6 +179,11 @@ 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)
@@ -198,6 +218,11 @@ 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

@@ -0,0 +1,66 @@
+/*
+ * 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

@@ -0,0 +1,758 @@
+/*
+ * 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

@@ -0,0 +1,202 @@
+/*
+ * 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,6 +103,26 @@ 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.
@@ -142,6 +162,15 @@ 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,6 +146,8 @@ 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 */
@@ -352,6 +354,18 @@ _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

@@ -0,0 +1,66 @@
+/*
+ * 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

@@ -0,0 +1,776 @@
+/*
+ * 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

@@ -0,0 +1,216 @@
+/*
+ * 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,6 +47,8 @@
 #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"
@@ -243,6 +245,12 @@ _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);
 }
 
@@ -255,9 +263,17 @@ _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 = 0;
+  int current_depth;
   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...
@@ -327,6 +343,12 @@ 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

@@ -53,7 +53,6 @@ typedef struct _CoglTexture CoglTexture;
 #include <cogl/cogl-macros.h>
 #include <cogl/cogl-defines.h>
 #include <cogl/cogl-pixel-buffer.h>
-#include <cogl/cogl-pixel-format.h>
 #include <cogl/cogl-bitmap.h>
 
 #include <glib-object.h>
@@ -108,6 +107,25 @@ 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

@@ -147,10 +147,182 @@ typedef struct _CoglTextureVertex       CoglTextureVertex;
 #define COGL_DEPTH_BIT          (1 << 8)
 #define COGL_STENCIL_BIT        (1 << 9)
 
+/* XXX: Notes to those adding new formats here...
+ *
+ * First this diagram outlines how we allocate the 32bits of a
+ * CoglPixelFormat currently...
+ *
+ *                            6 bits for flags
+ *                          |-----|
+ *  enum        unused             4 bits for the bytes-per-pixel
+ *                                 and component alignment info
+ *  |------| |-------------|       |--|
+ *  00000000 xxxxxxxx xxxxxxSD PFBA0000
+ *                          ^ stencil
+ *                           ^ depth
+ *                             ^ premult
+ *                              ^ alpha first
+ *                               ^ bgr order
+ *                                ^ has alpha
+ *
+ * The most awkward part about the formats is how we use the last 4
+ * bits to encode the bytes per pixel and component alignment
+ * information. Ideally we should have had 3 bits for the bpp and a
+ * flag for alignment but we didn't plan for that in advance so we
+ * instead use a small lookup table to query the bpp and whether the
+ * components are byte aligned or not.
+ *
+ * The mapping is the following (see discussion on bug #660188):
+ *
+ * 0     = undefined
+ * 1, 8  = 1 bpp (e.g. A_8, G_8)
+ * 2     = 3 bpp, aligned (e.g. 888)
+ * 3     = 4 bpp, aligned (e.g. 8888)
+ * 4-6   = 2 bpp, not aligned (e.g. 565, 4444, 5551)
+ * 7     = YUV: undefined bpp, undefined alignment
+ * 9     = 2 bpp, aligned
+ * 10    = depth, aligned (8, 16, 24, 32, 32f)
+ * 11    = undefined
+ * 12    = 3 bpp, not aligned
+ * 13    = 4 bpp, not aligned (e.g. 2101010)
+ * 14-15 = undefined
+ *
+ * Note: the gap at 10-11 is just because we wanted to maintain that
+ * all non-aligned formats have the third bit set in case that's
+ * useful later.
+ *
+ * Since we don't want to waste bits adding more and more flags, we'd
+ * like to see most new pixel formats that can't be represented
+ * uniquely with the existing flags in the least significant byte
+ * simply be enumerated with sequential values in the most significant
+ * enum byte.
+ *
+ * Note: Cogl avoids exposing any padded XRGB or RGBX formats and
+ * instead we leave it up to applications to decided whether they
+ * consider the A component as padding or valid data. We shouldn't
+ * change this policy without good reasoning.
+ *
+ * So to add a new format:
+ * 1) Use the mapping table above to figure out what to but in
+ *    the lowest nibble.
+ * 2) OR in the COGL_PREMULT_BIT, COGL_AFIRST_BIT, COGL_A_BIT and
+ *    COGL_BGR_BIT flags as appropriate.
+ * 3) If the result is not yet unique then also combine with an
+ *    increment of the last sequence number in the most significant
+ *    byte.
+ *
+ * The last sequence number used was 0 (i.e. no formats currently need
+ *                                      a sequence number)
+ * Update this note whenever a new sequence number is used.
+ */
+/**
+ * CoglPixelFormat:
+ * @COGL_PIXEL_FORMAT_ANY: Any format
+ * @COGL_PIXEL_FORMAT_A_8: 8 bits alpha mask
+ * @COGL_PIXEL_FORMAT_RG_88: RG, 16 bits. Note that red-green textures
+ *   are only available if %COGL_FEATURE_ID_TEXTURE_RG is advertised.
+ *   See cogl_texture_set_components() for details.
+ * @COGL_PIXEL_FORMAT_RGB_565: RGB, 16 bits
+ * @COGL_PIXEL_FORMAT_RGBA_4444: RGBA, 16 bits
+ * @COGL_PIXEL_FORMAT_RGBA_5551: RGBA, 16 bits
+ * @COGL_PIXEL_FORMAT_YUV: Not currently supported
+ * @COGL_PIXEL_FORMAT_G_8: Single luminance component
+ * @COGL_PIXEL_FORMAT_RGB_888: RGB, 24 bits
+ * @COGL_PIXEL_FORMAT_BGR_888: BGR, 24 bits
+ * @COGL_PIXEL_FORMAT_RGBA_8888: RGBA, 32 bits
+ * @COGL_PIXEL_FORMAT_BGRA_8888: BGRA, 32 bits
+ * @COGL_PIXEL_FORMAT_ARGB_8888: ARGB, 32 bits
+ * @COGL_PIXEL_FORMAT_ABGR_8888: ABGR, 32 bits
+ * @COGL_PIXEL_FORMAT_RGBA_1010102 : RGBA, 32 bits, 10 bpc
+ * @COGL_PIXEL_FORMAT_BGRA_1010102 : BGRA, 32 bits, 10 bpc
+ * @COGL_PIXEL_FORMAT_ARGB_2101010 : ARGB, 32 bits, 10 bpc
+ * @COGL_PIXEL_FORMAT_ABGR_2101010 : ABGR, 32 bits, 10 bpc
+ * @COGL_PIXEL_FORMAT_RGBA_8888_PRE: Premultiplied RGBA, 32 bits
+ * @COGL_PIXEL_FORMAT_BGRA_8888_PRE: Premultiplied BGRA, 32 bits
+ * @COGL_PIXEL_FORMAT_ARGB_8888_PRE: Premultiplied ARGB, 32 bits
+ * @COGL_PIXEL_FORMAT_ABGR_8888_PRE: Premultiplied ABGR, 32 bits
+ * @COGL_PIXEL_FORMAT_RGBA_4444_PRE: Premultiplied RGBA, 16 bits
+ * @COGL_PIXEL_FORMAT_RGBA_5551_PRE: Premultiplied RGBA, 16 bits
+ * @COGL_PIXEL_FORMAT_RGBA_1010102_PRE: Premultiplied RGBA, 32 bits, 10 bpc
+ * @COGL_PIXEL_FORMAT_BGRA_1010102_PRE: Premultiplied BGRA, 32 bits, 10 bpc
+ * @COGL_PIXEL_FORMAT_ARGB_2101010_PRE: Premultiplied ARGB, 32 bits, 10 bpc
+ * @COGL_PIXEL_FORMAT_ABGR_2101010_PRE: Premultiplied ABGR, 32 bits, 10 bpc
+ *
+ * Pixel formats used by Cogl. For the formats with a byte per
+ * component, the order of the components specify the order in
+ * increasing memory addresses. So for example
+ * %COGL_PIXEL_FORMAT_RGB_888 would have the red component in the
+ * lowest address, green in the next address and blue after that
+ * regardless of the endianness of the system.
+ *
+ * For the formats with non byte aligned components the component
+ * order specifies the order within a 16-bit or 32-bit number from
+ * most significant bit to least significant. So for
+ * %COGL_PIXEL_FORMAT_RGB_565, the red component would be in bits
+ * 11-15, the green component would be in 6-11 and the blue component
+ * would be in 1-5. Therefore the order in memory depends on the
+ * endianness of the system.
+ *
+ * When uploading a texture %COGL_PIXEL_FORMAT_ANY can be used as the
+ * internal format. Cogl will try to pick the best format to use
+ * internally and convert the texture data if necessary.
+ *
+ * Since: 0.8
+ */
+typedef enum /*< prefix=COGL_PIXEL_FORMAT >*/
+{
+  COGL_PIXEL_FORMAT_ANY           = 0,
+  COGL_PIXEL_FORMAT_A_8           = 1 | COGL_A_BIT,
+
+  COGL_PIXEL_FORMAT_RGB_565       = 4,
+  COGL_PIXEL_FORMAT_RGBA_4444     = 5 | COGL_A_BIT,
+  COGL_PIXEL_FORMAT_RGBA_5551     = 6 | COGL_A_BIT,
+  COGL_PIXEL_FORMAT_YUV           = 7,
+  COGL_PIXEL_FORMAT_G_8           = 8,
+
+  COGL_PIXEL_FORMAT_RG_88         = 9,
+
+  COGL_PIXEL_FORMAT_RGB_888       = 2,
+  COGL_PIXEL_FORMAT_BGR_888       = (2 | COGL_BGR_BIT),
+
+  COGL_PIXEL_FORMAT_RGBA_8888     = (3 | COGL_A_BIT),
+  COGL_PIXEL_FORMAT_BGRA_8888     = (3 | COGL_A_BIT | COGL_BGR_BIT),
+  COGL_PIXEL_FORMAT_ARGB_8888     = (3 | COGL_A_BIT | COGL_AFIRST_BIT),
+  COGL_PIXEL_FORMAT_ABGR_8888     = (3 | COGL_A_BIT | COGL_BGR_BIT | COGL_AFIRST_BIT),
+
+  COGL_PIXEL_FORMAT_RGBA_1010102  = (13 | COGL_A_BIT),
+  COGL_PIXEL_FORMAT_BGRA_1010102  = (13 | COGL_A_BIT | COGL_BGR_BIT),
+  COGL_PIXEL_FORMAT_ARGB_2101010  = (13 | COGL_A_BIT | COGL_AFIRST_BIT),
+  COGL_PIXEL_FORMAT_ABGR_2101010  = (13 | COGL_A_BIT | COGL_BGR_BIT | COGL_AFIRST_BIT),
+
+  COGL_PIXEL_FORMAT_RGBA_8888_PRE = (3 | COGL_A_BIT | COGL_PREMULT_BIT),
+  COGL_PIXEL_FORMAT_BGRA_8888_PRE = (3 | COGL_A_BIT | COGL_PREMULT_BIT | COGL_BGR_BIT),
+  COGL_PIXEL_FORMAT_ARGB_8888_PRE = (3 | COGL_A_BIT | COGL_PREMULT_BIT | COGL_AFIRST_BIT),
+  COGL_PIXEL_FORMAT_ABGR_8888_PRE = (3 | COGL_A_BIT | COGL_PREMULT_BIT | COGL_BGR_BIT | COGL_AFIRST_BIT),
+  COGL_PIXEL_FORMAT_RGBA_4444_PRE = (COGL_PIXEL_FORMAT_RGBA_4444 | COGL_A_BIT | COGL_PREMULT_BIT),
+  COGL_PIXEL_FORMAT_RGBA_5551_PRE = (COGL_PIXEL_FORMAT_RGBA_5551 | COGL_A_BIT | COGL_PREMULT_BIT),
+
+  COGL_PIXEL_FORMAT_RGBA_1010102_PRE = (COGL_PIXEL_FORMAT_RGBA_1010102 | COGL_PREMULT_BIT),
+  COGL_PIXEL_FORMAT_BGRA_1010102_PRE = (COGL_PIXEL_FORMAT_BGRA_1010102 | COGL_PREMULT_BIT),
+  COGL_PIXEL_FORMAT_ARGB_2101010_PRE = (COGL_PIXEL_FORMAT_ARGB_2101010 | COGL_PREMULT_BIT),
+  COGL_PIXEL_FORMAT_ABGR_2101010_PRE = (COGL_PIXEL_FORMAT_ABGR_2101010 | COGL_PREMULT_BIT),
+
+  COGL_PIXEL_FORMAT_DEPTH_16  = (9 | COGL_DEPTH_BIT),
+  COGL_PIXEL_FORMAT_DEPTH_32  = (3 | COGL_DEPTH_BIT),
+
+  COGL_PIXEL_FORMAT_DEPTH_24_STENCIL_8 = (3 | COGL_DEPTH_BIT | COGL_STENCIL_BIT)
+} CoglPixelFormat;
+
 /**
  * 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
@@ -162,8 +334,20 @@ typedef struct _CoglTextureVertex       CoglTextureVertex;
  *     %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
@@ -177,8 +361,11 @@ typedef struct _CoglTextureVertex       CoglTextureVertex;
  */
 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),
@@ -188,7 +375,11 @@ 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),
@@ -368,7 +559,9 @@ cogl_blend_string_error_quark (void);
  *
  * <itemizedlist>
  *  <listitem><para>You've tried to use a feature that is not
- *   advertised by cogl_has_feature().</para></listitem>
+ *   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>
  *  <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>
@@ -580,6 +773,32 @@ 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-util.h

@@ -35,7 +35,6 @@
 #include <math.h>
 
 #include <cogl/cogl-defines.h>
-#include <cogl/cogl-pixel-format.h>
 #include "cogl-types.h"
 
 #include <stdio.h>

cogl/cogl/cogl-xlib-renderer.c

@@ -54,27 +54,41 @@ static char *_cogl_x11_display_name = NULL;
 static GList *_cogl_xlib_renderers = NULL;
 
 static void
-_xlib_renderer_data_free (CoglXlibRenderer *data)
+destroy_xlib_renderer_data (void *user_data)
 {
+  CoglXlibRenderer *data = user_data;
+
   if (data->xvisinfo)
     XFree (data->xvisinfo);
 
-  g_slice_free (CoglXlibRenderer, data);
+  g_slice_free (CoglXlibRenderer, user_data);
 }
 
 CoglXlibRenderer *
 _cogl_xlib_renderer_get_data (CoglRenderer *renderer)
 {
+  static CoglUserDataKey key;
+  CoglXlibRenderer *data;
+
   /* Constructs a CoglXlibRenderer struct on demand and attaches it to
      the object using user data. It's done this way instead of using a
      subclassing hierarchy in the winsys data because all EGL winsys's
      need the EGL winsys data but only one of them wants the Xlib
      data. */
 
-  if (!renderer->custom_winsys_user_data)
-    renderer->custom_winsys_user_data = g_slice_new0 (CoglXlibRenderer);
+  data = cogl_object_get_user_data (COGL_OBJECT (renderer), &key);
 
-  return renderer->custom_winsys_user_data;
+  if (data == NULL)
+    {
+      data = g_slice_new0 (CoglXlibRenderer);
+
+      cogl_object_set_user_data (COGL_OBJECT (renderer),
+                                 &key,
+                                 data,
+                                 destroy_xlib_renderer_data);
+    }
+
+  return data;
 }
 
 static void
@@ -556,8 +570,6 @@ _cogl_xlib_renderer_disconnect (CoglRenderer *renderer)
   if (!renderer->foreign_xdpy && xlib_renderer->xdpy)
     XCloseDisplay (xlib_renderer->xdpy);
 
-  g_clear_pointer (&renderer->custom_winsys_user_data, _xlib_renderer_data_free);
-
   unregister_xlib_renderer (renderer);
 }
 

cogl/cogl/cogl.c

@@ -764,3 +764,55 @@ _cogl_init (void)
       initialized = TRUE;
     }
 }
+
+/*
+ * Returns the number of bytes-per-pixel of a given format. The bpp
+ * can be extracted from the least significant nibble of the pixel
+ * format (see CoglPixelFormat).
+ *
+ * The mapping is the following (see discussion on bug #660188):
+ *
+ * 0     = undefined
+ * 1, 8  = 1 bpp (e.g. A_8, G_8)
+ * 2     = 3 bpp, aligned (e.g. 888)
+ * 3     = 4 bpp, aligned (e.g. 8888)
+ * 4-6   = 2 bpp, not aligned (e.g. 565, 4444, 5551)
+ * 7     = undefined yuv
+ * 9     = 2 bpp, aligned
+ * 10     = undefined
+ * 11     = undefined
+ * 12    = 3 bpp, not aligned
+ * 13    = 4 bpp, not aligned (e.g. 2101010)
+ * 14-15 = undefined
+ */
+int
+_cogl_pixel_format_get_bytes_per_pixel (CoglPixelFormat format)
+{
+  int bpp_lut[] = { 0, 1, 3, 4,
+                    2, 2, 2, 0,
+                    1, 2, 0, 0,
+                    3, 4, 0, 0 };
+
+  return bpp_lut [format & 0xf];
+}
+
+/* Note: this also refers to the mapping defined above for
+ * _cogl_pixel_format_get_bytes_per_pixel() */
+gboolean
+_cogl_pixel_format_is_endian_dependant (CoglPixelFormat format)
+{
+  int aligned_lut[] = { -1, 1,  1,  1,
+                         0, 0,  0, -1,
+                         1, 1, -1, -1,
+                         0, 0, -1, -1};
+  int aligned = aligned_lut[format & 0xf];
+
+  _COGL_RETURN_VAL_IF_FAIL (aligned != -1, FALSE);
+
+  /* NB: currently checking whether the format components are aligned
+   * or not determines whether the format is endian dependent or not.
+   * In the future though we might consider adding formats with
+   * aligned components that are also endian independant. */
+
+  return aligned;
+}

cogl/cogl/cogl.h

@@ -64,7 +64,6 @@
 #include <cogl/cogl-matrix.h>
 #include <cogl/cogl-matrix-stack.h>
 #include <cogl/cogl-offscreen.h>
-#include <cogl/cogl-pixel-format.h>
 #include <cogl/cogl-primitives.h>
 #include <cogl/cogl-texture.h>
 #include <cogl/cogl-types.h>
@@ -106,6 +105,8 @@
 #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,6 +132,7 @@ 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
@@ -253,6 +254,7 @@ 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
@@ -295,6 +297,7 @@ 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
@@ -410,6 +413,7 @@ 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
@@ -616,6 +620,7 @@ 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
@@ -645,6 +650,7 @@ 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
@@ -908,6 +914,7 @@ 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
@@ -952,6 +959,12 @@ 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,6 +48,7 @@
 #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"
 
@@ -81,18 +82,25 @@ cogl_texture_new_with_size (unsigned int width,
 
   _COGL_GET_CONTEXT (ctx, NULL);
 
-  /* 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))
+  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)))
     {
-      cogl_error_free (skip_error);
-      skip_error = NULL;
-      cogl_object_unref (tex);
-      tex = NULL;
+      /* 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;
+        }
     }
+  else
+    tex = NULL;
 
   if (!tex)
     {
@@ -202,6 +210,7 @@ _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;
 
@@ -225,18 +234,26 @@ _cogl_texture_new_from_bitmap (CoglBitmap *bitmap,
     }
 
   /* If that doesn't work try a fast path 2D texture */
-  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))
+  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)))
     {
-      cogl_error_free (internal_error);
-      internal_error = NULL;
-      cogl_object_unref (tex);
-      tex = NULL;
+      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;
+        }
     }
+  else
+    tex = NULL;
 
   if (!tex)
     {
@@ -313,6 +330,82 @@ 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,6 +125,44 @@ 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,6 +756,10 @@ 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-program.c

@@ -59,8 +59,10 @@ _cogl_program_free (CoglProgram *program)
 
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  /* Unref all of the attached shaders and destroy the list */
-  g_slist_free_full (program->attached_shaders, cogl_handle_unref);
+  /* Unref all of the attached shaders */
+  g_slist_foreach (program->attached_shaders, (GFunc) cogl_handle_unref, NULL);
+  /* Destroy the list */
+  g_slist_free (program->attached_shaders);
 
   for (i = 0; i < program->custom_uniforms->len; i++)
     {