Add CoglDepthState API

Instead of simply extending the cogl_pipeline_ namespace to add api for
controlling the depth testing state we now break the api out. This adds
a CoglDepthState type that can be stack allocated. The members of the
structure are private but we have the following API to setup the state:

    cogl_depth_state_init
    cogl_depth_state_set_test_enabled
    cogl_depth_state_get_test_enabled
    cogl_depth_state_set_test_function
    cogl_depth_state_get_test_function
    cogl_depth_state_set_writing_enabled
    cogl_depth_state_get_writing_enabled
    cogl_depth_state_set_range
    cogl_depth_state_get_range

This removes the following experimental API which is now superseded:

    cogl_material_set_depth_test_enabled
    cogl_material_get_depth_test_enabled
    cogl_material_set_depth_test_function
    cogl_material_get_depth_test_function
    cogl_material_set_depth_writing_enabled
    cogl_material_get_depth_writing_enabled
    cogl_material_set_depth_range
    cogl_material_get_depth_range

Once a CoglDepthState structure is setup it can be set on a pipeline
using cogl_pipeline_set_depth_state().

16 files changed, 541 insertions, 551 deletions

diff --git a/cogl/Makefile.am b/cogl/Makefile.am
index de07dcd7..000bbf1a 100644
--- a/cogl/Makefile.am
+++ b/cogl/Makefile.am
@@ -61,6 +61,7 @@ cogl_public_h = \
 	$(srcdir)/cogl-buffer.h 		\
 	$(srcdir)/cogl-color.h 			\
 	$(srcdir)/cogl-fixed.h 			\
+	$(srcdir)/cogl-depth-state.h 		\
 	$(srcdir)/cogl-material-compat.h 	\
 	$(srcdir)/cogl-pipeline.h 		\
 	$(srcdir)/cogl-vector.h 		\
@@ -236,6 +237,8 @@ cogl_sources_c = \
 	$(srcdir)/cogl-matrix-private.h			\
 	$(srcdir)/cogl-matrix-stack.c			\
 	$(srcdir)/cogl-matrix-stack.h			\
+	$(srcdir)/cogl-depth-state.c			\
+	$(srcdir)/cogl-depth-state-private.h		\
 	$(srcdir)/cogl-pipeline.c			\
 	$(srcdir)/cogl-pipeline-private.h		\
 	$(srcdir)/cogl-pipeline-opengl.c		\
diff --git a/cogl/cogl-depth-state.c b/cogl/cogl-depth-state.c
new file mode 100644
index 00000000..076d1b2e
--- /dev/null
+++ b/cogl/cogl-depth-state.c
@@ -0,0 +1,108 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2011 Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Robert Bragg <robert@linux.intel.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <cogl/cogl.h>
+#include "cogl-depth-state-private.h"
+
+void
+cogl_depth_state_init (CoglDepthState *state)
+{
+  state->magic = COGL_DEPTH_STATE_MAGIC;
+
+  state->test_enabled = FALSE;
+  state->write_enabled = TRUE;
+  state->test_function = COGL_DEPTH_TEST_FUNCTION_LESS;
+  state->range_near = 0;
+  state->range_far = 1;
+}
+
+void
+cogl_depth_state_set_test_enabled (CoglDepthState *state,
+                                   gboolean enabled)
+{
+  g_return_if_fail (state->magic == COGL_DEPTH_STATE_MAGIC);
+  state->test_enabled = enabled;
+}
+
+gboolean
+cogl_depth_state_get_test_enabled (CoglDepthState *state)
+{
+  g_return_val_if_fail (state->magic == COGL_DEPTH_STATE_MAGIC, FALSE);
+  return state->test_enabled;
+}
+
+void
+cogl_depth_state_set_write_enabled (CoglDepthState *state,
+                                    gboolean enabled)
+{
+  g_return_if_fail (state->magic == COGL_DEPTH_STATE_MAGIC);
+  state->write_enabled = enabled;
+}
+
+gboolean
+cogl_depth_state_get_write_enabled (CoglDepthState *state)
+{
+  g_return_val_if_fail (state->magic == COGL_DEPTH_STATE_MAGIC, FALSE);
+  return state->write_enabled;
+}
+
+void
+cogl_depth_state_set_test_function (CoglDepthState *state,
+                                    CoglDepthTestFunction function)
+{
+  g_return_if_fail (state->magic == COGL_DEPTH_STATE_MAGIC);
+  state->test_function = function;
+}
+
+CoglDepthTestFunction
+cogl_depth_state_get_test_function (CoglDepthState *state)
+{
+  g_return_val_if_fail (state->magic == COGL_DEPTH_STATE_MAGIC, FALSE);
+  return state->test_function;
+}
+
+void
+cogl_depth_state_set_range (CoglDepthState *state,
+                            float near,
+                            float far)
+{
+  g_return_if_fail (state->magic == COGL_DEPTH_STATE_MAGIC);
+  state->range_near = near;
+  state->range_far = far;
+}
+
+void
+cogl_depth_state_get_range (CoglDepthState *state,
+                            float *near_out,
+                            float *far_out)
+{
+  g_return_if_fail (state->magic == COGL_DEPTH_STATE_MAGIC);
+  *near_out = state->range_near;
+  *far_out = state->range_far;
+}
diff --git a/cogl/cogl-depth-state.h b/cogl/cogl-depth-state.h
new file mode 100644
index 00000000..832172ba
--- /dev/null
+++ b/cogl/cogl-depth-state.h
@@ -0,0 +1,261 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2011 Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *  Robert Bragg <robert@linux.intel.com>
+ *
+ */
+
+#if !defined(__COGL_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#ifndef __COGL_DEPTH_STATE_H__
+#define __COGL_DEPTH_STATE_H__
+
+G_BEGIN_DECLS
+
+/**
+ * SECTION:cogl-depth-state
+ * @short_description: Functions for describing the depth testing
+ *                     state of your GPU.
+ */
+
+typedef struct
+{
+  guint32 COGL_PRIVATE (magic);
+
+  gboolean COGL_PRIVATE (test_enabled);
+  CoglDepthTestFunction COGL_PRIVATE (test_function);
+  gboolean COGL_PRIVATE (write_enabled);
+  float COGL_PRIVATE (range_near);
+  float COGL_PRIVATE (range_far);
+
+  guint32 COGL_PRIVATE (padding0);
+  guint32 COGL_PRIVATE (padding1);
+  guint32 COGL_PRIVATE (padding2);
+  guint32 COGL_PRIVATE (padding3);
+  guint32 COGL_PRIVATE (padding4);
+  guint32 COGL_PRIVATE (padding5);
+  guint32 COGL_PRIVATE (padding6);
+  guint32 COGL_PRIVATE (padding7);
+  guint32 COGL_PRIVATE (padding8);
+  guint32 COGL_PRIVATE (padding9);
+
+} CoglDepthState;
+
+/**
+ * cogl_depth_state_init:
+ * @state: A #CoglDepthState struct
+ *
+ * Initializes the members of @state to their default values.
+ *
+ * You should never pass an un initialized #CoglDepthState structure
+ * to cogl_pipeline_set_depth_state().
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+void
+cogl_depth_state_init (CoglDepthState *state);
+
+/**
+ * cogl_depth_state_set_test_enabled:
+ * @state: A #CoglDepthState struct
+ * @enable: The enable state you want
+ *
+ * Enables or disables depth testing according to the value of
+ * @enable.
+ *
+ * If depth testing is enable then the #CoglDepthTestFunction set
+ * using cogl_pipeline_set_depth_test_function() us used to evaluate
+ * the depth value of incoming fragments against the corresponding
+ * value stored in the current depth buffer, and if the test passes
+ * then the fragments depth value is used to update the depth buffer.
+ * (unless you have disabled depth writing via
+ * cogl_pipeline_set_depth_writing_enabled ())
+ *
+ * By default depth testing is disabled.
+ *
+ * NB: this won't directly affect the state of the GPU. You have
+ * to then set the state on a #CoglPipeline using
+ * cogl_pipeline_set_depth_state()
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+void
+cogl_depth_state_set_test_enabled (CoglDepthState *state,
+                                   gboolean enable);
+
+/**
+ * cogl_depth_state_get_test_enabled:
+ * @state: A #CoglDepthState struct
+ *
+ * Gets the current depth test enabled state as previously set by
+ * cogl_depth_state_set_test_enabled().
+ *
+ * Returns: The pipeline's current depth test enabled state.
+ * Since: 2.0
+ * Stability: Unstable
+ */
+gboolean
+cogl_depth_state_get_test_enabled (CoglDepthState *state);
+
+/**
+ * cogl_depth_state_set_write_enabled:
+ * @state: A #CoglDepthState struct
+ * @enable: The enable state you want
+ *
+ * Enables or disables depth buffer writing according to the value of
+ * @enable. Normally when depth testing is enabled and the comparison
+ * between a fragment's depth value and the corresponding depth buffer
+ * value passes then the fragment's depth is written to the depth
+ * buffer unless writing is disabled here.
+ *
+ * By default depth writing is enabled
+ *
+ * NB: this won't directly affect the state of the GPU. You have
+ * to then set the state on a #CoglPipeline using
+ * cogl_pipeline_set_depth_state()
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+void
+cogl_depth_state_set_write_enabled (CoglDepthState *state,
+                                    gboolean enable);
+
+/**
+ * cogl_depth_state_get_write_enabled:
+ * @state: A #CoglDepthState struct
+ *
+ * Gets the depth writing enable state as set by the corresponding
+ * cogl_pipeline_set_depth_writing_enabled.
+ *
+ * Returns: The current depth writing enable state
+ * Since: 2.0
+ * Stability: Unstable
+ */
+gboolean
+cogl_depth_state_get_write_enabled (CoglDepthState *state);
+
+/**
+ * cogl_depth_state_set_test_function:
+ * @state: A #CoglDepthState struct
+ * @function: The #CoglDepthTestFunction to set
+ *
+ * Sets the #CoglDepthTestFunction used to compare the depth value of
+ * an incoming fragment against the corresponding value in the current
+ * depth buffer.
+ *
+ * By default the depth test function is %COGL_DEPTH_TEST_FUNCTION_LESS
+ *
+ * NB: this won't directly affect the state of the GPU. You have
+ * to then set the state on a #CoglPipeline using
+ * cogl_pipeline_set_depth_state()
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+void
+cogl_depth_state_set_test_function (CoglDepthState *state,
+                                    CoglDepthTestFunction function);
+
+/**
+ * cogl_depth_state_get_test_function:
+ * @state: A #CoglDepthState struct
+ *
+ * Gets the current depth test enable state as previously set via
+ * cogl_pipeline_set_depth_test_enabled().
+ *
+ * Returns: The current depth test enable state.
+ * Since: 2.0
+ * Stability: Unstable
+ */
+CoglDepthTestFunction
+cogl_depth_state_get_test_function (CoglDepthState *state);
+
+/**
+ * cogl_depth_state_set_range:
+ * @state: A #CoglDepthState object
+ * @near_val: The near component of the desired depth range which will be
+ * clamped to the range [0, 1]
+ * @far_val: The far component of the desired depth range which will be
+ * clamped to the range [0, 1]
+ * @error: location to store an error of type #CoglError
+ *
+ * Sets the range to map depth values in normalized device coordinates
+ * to before writing out to a depth buffer.
+ *
+ * After your geometry has be transformed, clipped and had perspective
+ * division applied placing it in normalized device
+ * coordinates all depth values between the near and far z clipping
+ * planes are in the range -1 to 1. Before writing any depth value to
+ * the depth buffer though the value is mapped into the range [0, 1].
+ *
+ * With this function you can change the range which depth values are
+ * mapped too although the range must still lye within the range [0,
+ * 1].
+ *
+ * If your driver does not support this feature (for example you are
+ * using GLES 1 drivers) then if you don't use the default range
+ * values you will get an error reported when calling
+ * cogl_pipeline_set_depth_state (). You can check ahead of time for
+ * the %COGL_FEATURE_DEPTH_RANGE feature with
+ * cogl_features_available() to know if this function will succeed.
+ *
+ * By default normalized device coordinate depth values are mapped to
+ * the full range of depth buffer values, [0, 1].
+ *
+ * NB: this won't directly affect the state of the GPU. You have
+ * to then set the state on a #CoglPipeline using
+ * cogl_pipeline_set_depth_state().
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+void
+cogl_depth_state_set_range (CoglDepthState *state,
+                            float near_val,
+                            float far_val);
+
+/**
+ * cogl_depth_state_get_range:
+ * @pipeline: A #CoglPipeline object
+ * @near_val: A pointer to store the near component of the depth range
+ * @far_val: A pointer to store the far component of the depth range
+ *
+ * Gets the current range to which normalized depth values are mapped
+ * before writing to the depth buffer. This corresponds to the range
+ * set with cogl_pipeline_set_depth_range().
+ *
+ * Since: 2.0
+ * Stability: Unstable
+ */
+void
+cogl_depth_state_get_range (CoglDepthState *state,
+                            float *near_val,
+                            float *far_val);
+
+G_END_DECLS
+
+#endif /* __COGL_DEPTH_STATE_H__ */
diff --git a/cogl/cogl-material-compat.c b/cogl/cogl-material-compat.c
index 72349fe4..5df55bab 100644
--- a/cogl/cogl-material-compat.c
+++ b/cogl/cogl-material-compat.c
@@ -428,68 +428,27 @@ cogl_material_layer_get_wrap_mode_p (CoglMaterialLayer *layer)
 }
 
 void
-cogl_material_set_depth_test_enabled (CoglMaterial *material,
-                                      gboolean enable)
-{
-  cogl_pipeline_set_depth_test_enabled (COGL_PIPELINE (material), enable);
-}
-
-gboolean
-cogl_material_get_depth_test_enabled (CoglMaterial *material)
-{
-  return cogl_pipeline_get_depth_test_enabled (COGL_PIPELINE (material));
-}
-
-void
-cogl_material_set_depth_writing_enabled (CoglMaterial *material,
-                                         gboolean enable)
-{
-  cogl_pipeline_set_depth_writing_enabled (COGL_PIPELINE (material), enable);
-}
-
-gboolean
-cogl_material_get_depth_writing_enabled (CoglMaterial *material)
-{
-  return cogl_pipeline_get_depth_writing_enabled (COGL_PIPELINE (material));
-}
-
-void
-cogl_material_set_depth_test_function (CoglMaterial *material,
-                                       CoglDepthTestFunction function)
-{
-  cogl_pipeline_set_depth_test_function (COGL_PIPELINE (material), function);
-}
-
-CoglDepthTestFunction
-cogl_material_get_depth_test_function (CoglMaterial *material)
+cogl_material_foreach_layer (CoglMaterial *material,
+                             CoglMaterialLayerCallback callback,
+                             void *user_data)
 {
-  return cogl_pipeline_get_depth_test_function (COGL_PIPELINE (material));
+  cogl_pipeline_foreach_layer (COGL_PIPELINE (material),
+                               (CoglPipelineLayerCallback)callback, user_data);
 }
 
 gboolean
-cogl_material_set_depth_range (CoglMaterial *material,
-                               float near_val,
-                               float far_val,
+cogl_material_set_depth_state (CoglMaterial *material,
+                               const CoglDepthState *state,
                                GError **error)
 {
-  return cogl_pipeline_set_depth_range (COGL_PIPELINE (material),
-                                        near_val, far_val, error);
-}
-
-void
-cogl_material_get_depth_range (CoglMaterial *material,
-                               float *near_val,
-                               float *far_val)
-{
-  cogl_pipeline_get_depth_range (COGL_PIPELINE (material), near_val, far_val);
+  return cogl_pipeline_set_depth_state (COGL_PIPELINE (material),
+                                        state, error);
 }
 
 void
-cogl_material_foreach_layer (CoglMaterial *material,
-                             CoglMaterialLayerCallback callback,
-                             void *user_data)
+cogl_material_get_depth_state (CoglMaterial *material,
+                               CoglDepthState *state_out)
 {
-  cogl_pipeline_foreach_layer (COGL_PIPELINE (material),
-                               (CoglPipelineLayerCallback)callback, user_data);
+  cogl_pipeline_get_depth_state (COGL_PIPELINE (material), state_out);
 }
 
diff --git a/cogl/cogl-material-compat.h b/cogl/cogl-material-compat.h
index 34c6d290..495c9413 100644
--- a/cogl/cogl-material-compat.h
+++ b/cogl/cogl-material-compat.h
@@ -32,6 +32,7 @@ G_BEGIN_DECLS
 
 #include <cogl/cogl-types.h>
 #include <cogl/cogl-matrix.h>
+#include <cogl/cogl-depth-state.h>
 
 /**
  * SECTION:cogl-material
@@ -1195,167 +1196,44 @@ cogl_material_layer_get_wrap_mode_p (CoglMaterialLayer *layer);
 #ifdef COGL_ENABLE_EXPERIMENTAL_API
 
 /**
- * cogl_material_set_depth_test_enabled:
+ * cogl_material_set_depth_state:
  * @material: A #CoglMaterial object
- * @enable: The enable state you want
+ * @state: A #CoglDepthState struct
+ * @error: A #GError to report failures to setup the given @state.
  *
- * Enables or disables depth testing according to the value of
- * @enable.
+ * This commits all the depth state configured in @state struct to the
+ * given @material. The configuration values are copied into the
+ * material so there is no requirement to keep the #CoglDepthState
+ * struct around if you don't need it any more.
  *
- * If depth testing is enable then the #CoglDepthTestFunction set
- * using cogl_material_set_depth_test_function() us used to evaluate
- * the depth value of incoming fragments against the corresponding
- * value stored in the current depth buffer, and if the test passes
- * then the fragments depth value is used to update the depth buffer.
- * (unless you have disabled depth writing via
- * cogl_material_set_depth_writing_enabled ())
+ * Note: Since some platforms do not support the depth range feature
+ * it is possible for this function to fail and report an @error.
  *
- * By default depth testing is disabled.
+ * Returns: TRUE if the GPU supports all the given @state else %FALSE
+ *          and returns an @error.
  *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_material_set_depth_test_enabled (CoglMaterial *material,
-                                      gboolean enable);
-
-/**
- * cogl_material_get_depth_test_enabled:
- * @material: A #CoglMaterial object
- *
- * Gets the current depth test enabled state as previously set by
- * cogl_material_set_depth_test_enabled().
- *
- * Returns: The material's current depth test enabled state.
- * Since: 1.4
+ * Since: 1.8
  * Stability: Unstable
  */
 gboolean
-cogl_material_get_depth_test_enabled (CoglMaterial *material);
-
-/**
- * cogl_material_set_depth_writing_enabled:
- * @material: A #CoglMaterial object
- * @enable: The enable state you want
- *
- * Enables or disables depth buffer writing according to the value of
- * @enable. Normally when depth testing is enabled and the comparison
- * between a fragment's depth value and the corresponding depth buffer
- * value passes then the fragment's depth is written to the depth
- * buffer unless writing is disabled here.
- *
- * By default depth writing is enabled
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_material_set_depth_writing_enabled (CoglMaterial *material,
-                                         gboolean enable);
-
-/**
- * cogl_material_get_depth_writing_enabled:
- * @material: A #CoglMaterial object
- *
- * Gets the depth writing enable state as set by the corresponding
- * cogl_material_set_depth_writing_enabled.
- *
- * Returns: The current depth writing enable state
- * Since: 1.4
- * Stability: Unstable
- */
-gboolean
-cogl_material_get_depth_writing_enabled (CoglMaterial *material);
-
-/**
- * cogl_material_set_depth_test_function:
- * @material: A #CoglMaterial object
- * @function: The #CoglDepthTestFunction to set
- *
- * Sets the #CoglDepthTestFunction used to compare the depth value of
- * an incoming fragment against the corresponding value in the current
- * depth buffer.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_material_set_depth_test_function (CoglMaterial *material,
-                                       CoglDepthTestFunction function);
-
-/**
- * cogl_material_get_depth_test_function:
- * @material: A #CoglMaterial object
- *
- * Gets the current depth test enable state as previously set via
- * cogl_material_set_depth_test_enabled().
- *
- * Returns: The current depth test enable state.
- * Since: 1.4
- * Stability: Unstable
- */
-CoglDepthTestFunction
-cogl_material_get_depth_test_function (CoglMaterial *material);
-
-/**
- * cogl_material_set_depth_range:
- * @material: A #CoglMaterial object
- * @near_val: The near component of the desired depth range which will be
- * clamped to the range [0, 1]
- * @far_val: The far component of the desired depth range which will be
- * clamped to the range [0, 1]
- * @error: location to store an error of type #CoglError
- *
- * Sets the range to map depth values in normalized device coordinates
- * to before writing out to a depth buffer.
- *
- * After your geometry has be transformed, clipped and had perspective
- * division applied placing it in normalized device
- * coordinates all depth values between the near and far z clipping
- * planes are in the range -1 to 1. Before writing any depth value to
- * the depth buffer though the value is mapped into the range [0, 1].
- *
- * With this function you can change the range which depth values are
- * mapped too although the range must still lye within the range [0,
- * 1].
- *
- * If your driver does not support this feature (for example you are
- * using GLES 1 drivers) then this will return %FALSE and set an error
- * if @error isn't NULL. You can check ahead of time for the
- * %COGL_FEATURE_DEPTH_RANGE feature with cogl_features_available() to
- * know if this function will succeed.
- *
- * By default normalized device coordinate depth values are mapped to
- * the full range of depth buffer values, [0, 1].
- *
- * Returns: %TRUE if driver support is available else %FALSE.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-gboolean
-cogl_material_set_depth_range (CoglMaterial *material,
-                               float near_val,
-                               float far_val,
+cogl_material_set_depth_state (CoglMaterial *material,
+                               const CoglDepthState *state,
                                GError **error);
 
 /**
- * cogl_material_get_depth_range_mapping:
+ * cogl_material_get_depth_state
  * @material: A #CoglMaterial object
- * @near_val: A pointer to store the near component of the depth range
- * @far_val: A pointer to store the far component of the depth range
+ * @state: A destination #CoglDepthState struct
  *
- * Gets the current range to which normalized depth values are mapped
- * before writing to the depth buffer. This corresponds to the range
- * set with cogl_material_set_depth_range().
+ * Retrieves the current depth state configuration for the given
+ * @pipeline as previously set using cogl_pipeline_set_depth_state().
  *
- * Since: 1.4
+ * Since: 2.0
  * Stability: Unstable
  */
 void
-cogl_material_get_depth_range (CoglMaterial *material,
-                               float *near_val,
-                               float *far_val);
+cogl_material_get_depth_state (CoglMaterial *material,
+                               CoglDepthState *state_out);
 
 /**
  * CoglMaterialLayerCallback:
diff --git a/cogl/cogl-pipeline-opengl.c b/cogl/cogl-pipeline-opengl.c
index 1bf9f4db..50191252 100644
--- a/cogl/cogl-pipeline-opengl.c
+++ b/cogl/cogl-pipeline-opengl.c
@@ -445,36 +445,36 @@ blend_factor_uses_constant (GLenum blend_factor)
 #endif
 
 static void
-flush_depth_state (CoglPipelineDepthState *depth_state)
+flush_depth_state (CoglDepthState *depth_state)
 {
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
-  if (ctx->depth_test_function_cache != depth_state->depth_test_function)
+  if (ctx->depth_test_function_cache != depth_state->test_function)
     {
-      GE (glDepthFunc (depth_state->depth_test_function));
-      ctx->depth_test_function_cache = depth_state->depth_test_function;
+      GE (glDepthFunc (depth_state->test_function));
+      ctx->depth_test_function_cache = depth_state->test_function;
     }
 
-  if (ctx->depth_writing_enabled_cache != depth_state->depth_writing_enabled)
+  if (ctx->depth_writing_enabled_cache != depth_state->write_enabled)
     {
-      GE (glDepthMask (depth_state->depth_writing_enabled ?
+      GE (glDepthMask (depth_state->write_enabled ?
                        GL_TRUE : GL_FALSE));
-      ctx->depth_writing_enabled_cache = depth_state->depth_writing_enabled;
+      ctx->depth_writing_enabled_cache = depth_state->write_enabled;
     }
 
 #ifndef COGL_HAS_GLES
-  if (ctx->depth_range_near_cache != depth_state->depth_range_near ||
-      ctx->depth_range_far_cache != depth_state->depth_range_far)
+  if (ctx->depth_range_near_cache != depth_state->range_near ||
+      ctx->depth_range_far_cache != depth_state->range_far)
     {
 #ifdef COGL_HAS_GLES2
-      GE (glDepthRangef (depth_state->depth_range_near,
-                         depth_state->depth_range_far));
+      GE (glDepthRangef (depth_state->range_near,
+                         depth_state->range_far));
 #else
-      GE (glDepthRange (depth_state->depth_range_near,
-                        depth_state->depth_range_far));
+      GE (glDepthRange (depth_state->range_near,
+                        depth_state->range_far));
 #endif
-      ctx->depth_range_near_cache = depth_state->depth_range_near;
-      ctx->depth_range_far_cache = depth_state->depth_range_far;
+      ctx->depth_range_near_cache = depth_state->range_near;
+      ctx->depth_range_far_cache = depth_state->range_far;
     }
 #endif /* COGL_HAS_GLES */
 }
@@ -609,21 +609,21 @@ _cogl_pipeline_flush_color_blend_alpha_depth_state (
     {
       CoglPipeline *authority =
         _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_DEPTH);
-      CoglPipelineDepthState *depth_state = &authority->big_state->depth_state;
+      CoglDepthState *depth_state = &authority->big_state->depth_state;
 
-      if (depth_state->depth_test_enabled)
+      if (depth_state->test_enabled)
         {
           if (ctx->depth_test_enabled_cache != TRUE)
             {
               GE (glEnable (GL_DEPTH_TEST));
-              ctx->depth_test_enabled_cache = depth_state->depth_test_enabled;
+              ctx->depth_test_enabled_cache = depth_state->test_enabled;
             }
           flush_depth_state (depth_state);
         }
       else if (ctx->depth_test_enabled_cache != FALSE)
         {
           GE (glDisable (GL_DEPTH_TEST));
-          ctx->depth_test_enabled_cache = depth_state->depth_test_enabled;
+          ctx->depth_test_enabled_cache = depth_state->test_enabled;
         }
     }
 
diff --git a/cogl/cogl-pipeline-private.h b/cogl/cogl-pipeline-private.h
index 47007fb3..675ed40b 100644
--- a/cogl/cogl-pipeline-private.h
+++ b/cogl/cogl-pipeline-private.h
@@ -564,15 +564,6 @@ typedef struct
 
 typedef struct
 {
-  gboolean              depth_test_enabled;
-  CoglDepthTestFunction depth_test_function;
-  gboolean              depth_writing_enabled;
-  float                 depth_range_near;
-  float                 depth_range_far;
-} CoglPipelineDepthState;
-
-typedef struct
-{
   gboolean        enabled;
   CoglColor       color;
   CoglFogMode     mode;
@@ -587,7 +578,7 @@ typedef struct
   CoglPipelineAlphaFuncState alpha_state;
   CoglPipelineBlendState blend_state;
   CoglHandle user_program;
-  CoglPipelineDepthState depth_state;
+  CoglDepthState depth_state;
   CoglPipelineFogState fog_state;
   float point_size;
 } CoglPipelineBigState;
diff --git a/cogl/cogl-pipeline.c b/cogl/cogl-pipeline.c
index 6dec6a01..96dc5467 100644
--- a/cogl/cogl-pipeline.c
+++ b/cogl/cogl-pipeline.c
@@ -43,6 +43,7 @@
 #include "cogl-color-private.h"
 #include "cogl-util.h"
 #include "cogl-profile.h"
+#include "cogl-depth-state-private.h"
 
 #include <glib.h>
 #include <glib/gprintf.h>
@@ -210,7 +211,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;
-  CoglPipelineDepthState *depth_state = &big_state->depth_state;
+  CoglDepthState *depth_state = &big_state->depth_state;
 
   _COGL_GET_CONTEXT (ctx, NO_RETVAL);
 
@@ -308,11 +309,11 @@ _cogl_pipeline_init_default_pipeline (void)
   big_state->user_program = COGL_INVALID_HANDLE;
 
   /* The same as the GL defaults */
-  depth_state->depth_test_enabled = FALSE;
-  depth_state->depth_test_function = COGL_DEPTH_TEST_FUNCTION_LESS;
-  depth_state->depth_writing_enabled = TRUE;
-  depth_state->depth_range_near = 0;
-  depth_state->depth_range_far = 1;
+  depth_state->test_enabled = FALSE;
+  depth_state->test_function = COGL_DEPTH_TEST_FUNCTION_LESS;
+  depth_state->write_enabled = TRUE;
+  depth_state->range_near = 0;
+  depth_state->range_far = 1;
 
   big_state->point_size = 1.0f;
 
@@ -1074,7 +1075,7 @@ _cogl_pipeline_copy_differences (CoglPipeline *dest,
     {
       memcpy (&big_state->depth_state,
               &src->big_state->depth_state,
-              sizeof (CoglPipelineDepthState));
+              sizeof (CoglDepthState));
     }
 
   if (differences & COGL_PIPELINE_STATE_FOG)
@@ -1147,7 +1148,7 @@ _cogl_pipeline_init_multi_property_sparse_state (CoglPipeline *pipeline,
       {
         memcpy (&pipeline->big_state->depth_state,
                 &authority->big_state->depth_state,
-                sizeof (CoglPipelineDepthState));
+                sizeof (CoglDepthState));
         break;
       }
     case COGL_PIPELINE_STATE_FOG:
@@ -3479,13 +3480,19 @@ static gboolean
 _cogl_pipeline_depth_state_equal (CoglPipeline *authority0,
                                   CoglPipeline *authority1)
 {
-  if (authority0->big_state->depth_state.depth_test_enabled == FALSE &&
-      authority1->big_state->depth_state.depth_test_enabled == FALSE)
+  if (authority0->big_state->depth_state.test_enabled == FALSE &&
+      authority1->big_state->depth_state.test_enabled == FALSE)
     return TRUE;
   else
-    return memcmp (&authority0->big_state->depth_state,
-                   &authority1->big_state->depth_state,
-                   sizeof (CoglPipelineDepthState)) == 0;
+    {
+      CoglDepthState *s0 = &authority0->big_state->depth_state;
+      CoglDepthState *s1 = &authority1->big_state->depth_state;
+      return s0->test_enabled == s1->test_enabled &&
+             s0->test_function == s1->test_function &&
+             s0->write_enabled == s1->write_enabled &&
+             s0->range_near == s1->range_near &&
+             s0->range_far == s1->range_far;
+    }
 }
 
 static gboolean
@@ -4703,154 +4710,40 @@ cogl_pipeline_set_user_program (CoglPipeline *pipeline,
   handle_automatic_blend_enable (pipeline, state);
 }
 
-void
-cogl_pipeline_set_depth_test_enabled (CoglPipeline *pipeline,
-                                      gboolean enable)
-{
-  CoglPipelineState state = COGL_PIPELINE_STATE_DEPTH;
-  CoglPipeline *authority;
-  CoglPipelineDepthState *depth_state;
-
-  g_return_if_fail (cogl_is_pipeline (pipeline));
-
-  authority = _cogl_pipeline_get_authority (pipeline, state);
-
-  depth_state = &authority->big_state->depth_state;
-  if (depth_state->depth_test_enabled == enable)
-    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);
-
-  pipeline->big_state->depth_state.depth_test_enabled = enable;
-
-  _cogl_pipeline_update_authority (pipeline, authority, state,
-                                   _cogl_pipeline_depth_state_equal);
-}
-
-gboolean
-cogl_pipeline_get_depth_test_enabled (CoglPipeline *pipeline)
-{
-  CoglPipeline *authority;
-
-  g_return_val_if_fail (cogl_is_pipeline (pipeline), FALSE);
-
-  authority =
-    _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_DEPTH);
-
-  return authority->big_state->depth_state.depth_test_enabled;
-}
-
-void
-cogl_pipeline_set_depth_writing_enabled (CoglPipeline *pipeline,
-                                         gboolean enable)
-{
-  CoglPipelineState state = COGL_PIPELINE_STATE_DEPTH;
-  CoglPipeline *authority;
-  CoglPipelineDepthState *depth_state;
-
-  g_return_if_fail (cogl_is_pipeline (pipeline));
-
-  authority = _cogl_pipeline_get_authority (pipeline, state);
-
-  depth_state = &authority->big_state->depth_state;
-  if (depth_state->depth_writing_enabled == enable)
-    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);
-
-  pipeline->big_state->depth_state.depth_writing_enabled = enable;
-
-  _cogl_pipeline_update_authority (pipeline, authority, state,
-                                   _cogl_pipeline_depth_state_equal);
-}
-
 gboolean
-cogl_pipeline_get_depth_writing_enabled (CoglPipeline *pipeline)
-{
-  CoglPipeline *authority;
-
-  g_return_val_if_fail (cogl_is_pipeline (pipeline), TRUE);
-
-  authority =
-    _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_DEPTH);
-
-  return authority->big_state->depth_state.depth_writing_enabled;
-}
-
-void
-cogl_pipeline_set_depth_test_function (CoglPipeline *pipeline,
-                                       CoglDepthTestFunction function)
-{
-  CoglPipelineState state = COGL_PIPELINE_STATE_DEPTH;
-  CoglPipeline *authority;
-  CoglPipelineDepthState *depth_state;
-
-  g_return_if_fail (cogl_is_pipeline (pipeline));
-
-  authority = _cogl_pipeline_get_authority (pipeline, state);
-
-  depth_state = &authority->big_state->depth_state;
-  if (depth_state->depth_test_function == function)
-    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);
-
-  pipeline->big_state->depth_state.depth_test_function = function;
-
-  _cogl_pipeline_update_authority (pipeline, authority, state,
-                                   _cogl_pipeline_depth_state_equal);
-}
-
-CoglDepthTestFunction
-cogl_pipeline_get_depth_test_function (CoglPipeline *pipeline)
-{
-  CoglPipeline *authority;
-
-  g_return_val_if_fail (cogl_is_pipeline (pipeline),
-                        COGL_DEPTH_TEST_FUNCTION_LESS);
-
-  authority =
-    _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_DEPTH);
-
-  return authority->big_state->depth_state.depth_test_function;
-}
-
-
-gboolean
-cogl_pipeline_set_depth_range (CoglPipeline *pipeline,
-                               float near_val,
-                               float far_val,
+cogl_pipeline_set_depth_state (CoglPipeline *pipeline,
+                               const CoglDepthState *depth_state,
                                GError **error)
 {
-#ifndef COGL_HAS_GLES
   CoglPipelineState state = COGL_PIPELINE_STATE_DEPTH;
   CoglPipeline *authority;
-  CoglPipelineDepthState *depth_state;
+  CoglDepthState *orig_state;
 
-  g_return_val_if_fail (cogl_is_pipeline (pipeline), FALSE);
+  g_return_val_if_fail (cogl_is_pipeline (pipeline), TRUE);
+  g_return_if_fail (depth_state->magic == COGL_DEPTH_STATE_MAGIC);
 
   authority = _cogl_pipeline_get_authority (pipeline, state);
 
-  depth_state = &authority->big_state->depth_state;
-  if (depth_state->depth_range_near == near_val &&
-      depth_state->depth_range_far == far_val)
+  orig_state = &authority->big_state->depth_state;
+  if (orig_state->test_enabled == depth_state->test_enabled &&
+      orig_state->write_enabled == depth_state->write_enabled &&
+      orig_state->test_function == depth_state->test_function &&
+      orig_state->range_near == depth_state->range_near &&
+      orig_state->range_far == depth_state->range_far)
     return TRUE;
 
+#ifdef COGL_HAS_GLES
+  if (depth_state->range_near != 0 ||
+      depth_state->range_far != 1)
+    {
+      g_set_error (error,
+                   COGL_ERROR,
+                   COGL_ERROR_UNSUPPORTED,
+                   "glDepthRange not available on GLES 1");
+      return FALSE;
+    }
+#endif
+
   /* - 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
@@ -4858,25 +4751,17 @@ cogl_pipeline_set_depth_range (CoglPipeline *pipeline,
    */
   _cogl_pipeline_pre_change_notify (pipeline, state, NULL, FALSE);
 
-  pipeline->big_state->depth_state.depth_range_near = near_val;
-  pipeline->big_state->depth_state.depth_range_far = far_val;
+  pipeline->big_state->depth_state = *depth_state;
 
   _cogl_pipeline_update_authority (pipeline, authority, state,
                                    _cogl_pipeline_depth_state_equal);
+
   return TRUE;
-#else
-  g_set_error (error,
-               COGL_ERROR,
-               COGL_ERROR_UNSUPPORTED,
-               "glDepthRange not available on GLES 1");
-  return FALSE;
-#endif
 }
 
 void
-cogl_pipeline_get_depth_range (CoglPipeline *pipeline,
-                               float *near_val,
-                               float *far_val)
+cogl_pipeline_get_depth_state (CoglPipeline *pipeline,
+                               CoglDepthState *state)
 {
   CoglPipeline *authority;
 
@@ -4884,9 +4769,7 @@ cogl_pipeline_get_depth_range (CoglPipeline *pipeline,
 
   authority =
     _cogl_pipeline_get_authority (pipeline, COGL_PIPELINE_STATE_DEPTH);
-
-  *near_val = authority->big_state->depth_state.depth_range_near;
-  *far_val = authority->big_state->depth_state.depth_range_far;
+  *state = authority->big_state->depth_state;
 }
 
 static void
@@ -5880,7 +5763,12 @@ _cogl_pipeline_apply_legacy_state (CoglPipeline *pipeline)
     cogl_pipeline_set_user_program (pipeline, ctx->current_program);
 
   if (ctx->legacy_depth_test_enabled)
-    cogl_pipeline_set_depth_test_enabled (pipeline, TRUE);
+    {
+      CoglDepthState depth_state;
+      cogl_depth_state_init (&depth_state);
+      cogl_depth_state_set_test_enabled (&depth_state, TRUE);
+      cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL);
+    }
 
   if (ctx->legacy_fog_state.enabled)
     _cogl_pipeline_set_fog_state (pipeline, &ctx->legacy_fog_state);
@@ -6277,22 +6165,22 @@ static void
 _cogl_pipeline_hash_depth_state (CoglPipeline *authority,
                                  HashState *state)
 {
-  CoglPipelineDepthState *depth_state = &authority->big_state->depth_state;
+  CoglDepthState *depth_state = &authority->big_state->depth_state;
   unsigned int hash = state->hash;
 
-  if (depth_state->depth_test_enabled)
+  if (depth_state->test_enabled)
     {
-      guint8 enabled = depth_state->depth_test_enabled;
-      CoglDepthTestFunction function = depth_state->depth_test_function;
+      guint8 enabled = depth_state->test_enabled;
+      CoglDepthTestFunction function = depth_state->test_function;
       hash = _cogl_util_one_at_a_time_hash (hash, &enabled, sizeof (enabled));
       hash = _cogl_util_one_at_a_time_hash (hash, &function, sizeof (function));
     }
 
-  if (depth_state->depth_writing_enabled)
+  if (depth_state->write_enabled)
     {
-      guint8 enabled = depth_state->depth_writing_enabled;
-      float near_val = depth_state->depth_range_near;
-      float far_val = depth_state->depth_range_far;
+      guint8 enabled = depth_state->write_enabled;
+      float near_val = depth_state->range_near;
+      float far_val = depth_state->range_far;
       hash = _cogl_util_one_at_a_time_hash (hash, &enabled, sizeof (enabled));
       hash = _cogl_util_one_at_a_time_hash (hash, &near_val, sizeof (near_val));
       hash = _cogl_util_one_at_a_time_hash (hash, &far_val, sizeof (far_val));
diff --git a/cogl/cogl-pipeline.h b/cogl/cogl-pipeline.h
index 52c323db..28d756a8 100644
--- a/cogl/cogl-pipeline.h
+++ b/cogl/cogl-pipeline.h
@@ -1054,167 +1054,44 @@ cogl_pipeline_set_layer_wrap_mode (CoglPipeline        *pipeline,
 #ifdef COGL_ENABLE_EXPERIMENTAL_API
 
 /**
- * cogl_pipeline_set_depth_test_enabled:
+ * cogl_pipeline_set_depth_state:
  * @pipeline: A #CoglPipeline object
- * @enable: The enable state you want
+ * @state: A #CoglDepthState struct
+ * @error: A #GError to report failures to setup the given @state.
  *
- * Enables or disables depth testing according to the value of
- * @enable.
+ * This commits all the depth state configured in @state struct to the
+ * given @pipeline. The configuration values are copied into the
+ * pipeline so there is no requirement to keep the #CoglDepthState
+ * struct around if you don't need it any more.
  *
- * If depth testing is enable then the #CoglDepthTestFunction set
- * using cogl_pipeline_set_depth_test_function() us used to evaluate
- * the depth value of incoming fragments against the corresponding
- * value stored in the current depth buffer, and if the test passes
- * then the fragments depth value is used to update the depth buffer.
- * (unless you have disabled depth writing via
- * cogl_pipeline_set_depth_writing_enabled ())
+ * Note: Since some platforms do not support the depth range feature
+ * it is possible for this function to fail and report an @error.
  *
- * By default depth testing is disabled.
- *
- * Since: 2.0
- * Stability: Unstable
- */
-void
-cogl_pipeline_set_depth_test_enabled (CoglPipeline *pipeline,
-                                      gboolean enable);
-
-/**
- * cogl_pipeline_get_depth_test_enabled:
- * @pipeline: A #CoglPipeline object
- *
- * Gets the current depth test enabled state as previously set by
- * cogl_pipeline_set_depth_test_enabled().
- *
- * Returns: The pipeline's current depth test enabled state.
- * Since: 2.0
- * Stability: Unstable
- */
-gboolean
-cogl_pipeline_get_depth_test_enabled (CoglPipeline *pipeline);
-
-/**
- * cogl_pipeline_set_depth_writing_enabled:
- * @pipeline: A #CoglPipeline object
- * @enable: The enable state you want
- *
- * Enables or disables depth buffer writing according to the value of
- * @enable. Normally when depth testing is enabled and the comparison
- * between a fragment's depth value and the corresponding depth buffer
- * value passes then the fragment's depth is written to the depth
- * buffer unless writing is disabled here.
- *
- * By default depth writing is enabled
- *
- * Since: 2.0
- * Stability: Unstable
- */
-void
-cogl_pipeline_set_depth_writing_enabled (CoglPipeline *pipeline,
-                                         gboolean enable);
-
-/**
- * cogl_pipeline_get_depth_writing_enabled:
- * @pipeline: A #CoglPipeline object
- *
- * Gets the depth writing enable state as set by the corresponding
- * cogl_pipeline_set_depth_writing_enabled.
- *
- * Returns: The current depth writing enable state
- * Since: 2.0
- * Stability: Unstable
- */
-gboolean
-cogl_pipeline_get_depth_writing_enabled (CoglPipeline *pipeline);
-
-/**
- * cogl_pipeline_set_depth_test_function:
- * @pipeline: A #CoglPipeline object
- * @function: The #CoglDepthTestFunction to set
- *
- * Sets the #CoglDepthTestFunction used to compare the depth value of
- * an incoming fragment against the corresponding value in the current
- * depth buffer.
- *
- * Since: 2.0
- * Stability: Unstable
- */
-void
-cogl_pipeline_set_depth_test_function (CoglPipeline *pipeline,
-                                       CoglDepthTestFunction function);
-
-/**
- * cogl_pipeline_get_depth_test_function:
- * @pipeline: A #CoglPipeline object
- *
- * Gets the current depth test enable state as previously set via
- * cogl_pipeline_set_depth_test_enabled().
- *
- * Returns: The current depth test enable state.
- * Since: 2.0
- * Stability: Unstable
- */
-CoglDepthTestFunction
-cogl_pipeline_get_depth_test_function (CoglPipeline *pipeline);
-
-/**
- * cogl_pipeline_set_depth_range:
- * @pipeline: A #CoglPipeline object
- * @near_val: The near component of the desired depth range which will be
- * clamped to the range [0, 1]
- * @far_val: The far component of the desired depth range which will be
- * clamped to the range [0, 1]
- * @error: location to store an error of type #CoglError
- *
- * Sets the range to map depth values in normalized device coordinates
- * to before writing out to a depth buffer.
- *
- * After your geometry has be transformed, clipped and had perspective
- * division applied placing it in normalized device
- * coordinates all depth values between the near and far z clipping
- * planes are in the range -1 to 1. Before writing any depth value to
- * the depth buffer though the value is mapped into the range [0, 1].
- *
- * With this function you can change the range which depth values are
- * mapped too although the range must still lye within the range [0,
- * 1].
- *
- * If your driver does not support this feature (for example you are
- * using GLES 1 drivers) then this will return %FALSE and set an error
- * if @error isn't NULL. You can check ahead of time for the
- * %COGL_FEATURE_DEPTH_RANGE feature with cogl_features_available() to
- * know if this function will succeed.
- *
- * By default normalized device coordinate depth values are mapped to
- * the full range of depth buffer values, [0, 1].
- *
- * Returns: %TRUE if driver support is available else %FALSE.
+ * Returns: TRUE if the GPU supports all the given @state else %FALSE
+ *          and returns an @error.
  *
  * Since: 2.0
  * Stability: Unstable
  */
 gboolean
-cogl_pipeline_set_depth_range (CoglPipeline *pipeline,
-                               float near_val,
-                               float far_val,
+cogl_pipeline_set_depth_state (CoglPipeline *pipeline,
+                               const CoglDepthState *state,
                                GError **error);
 
 /**
- * cogl_pipeline_get_depth_range_mapping:
+ * cogl_pipeline_get_depth_state
  * @pipeline: A #CoglPipeline object
- * @near_val: A pointer to store the near component of the depth range
- * @far_val: A pointer to store the far component of the depth range
+ * @state: A destination #CoglDepthState struct
  *
- * Gets the current range to which normalized depth values are mapped
- * before writing to the depth buffer. This corresponds to the range
- * set with cogl_pipeline_set_depth_range().
+ * Retrieves the current depth state configuration for the given
+ * @pipeline as previously set using cogl_pipeline_set_depth_state().
  *
  * Since: 2.0
  * Stability: Unstable
  */
 void
-cogl_pipeline_get_depth_range (CoglPipeline *pipeline,
-                               float *near_val,
-                               float *far_val);
+cogl_pipeline_get_depth_state (CoglPipeline *pipeline,
+                               CoglDepthState *state_out);
 
 /**
  * CoglPipelineLayerCallback:
diff --git a/cogl/cogl.h b/cogl/cogl.h
index 74de6f03..d7dfc071 100644
--- a/cogl/cogl.h
+++ b/cogl/cogl.h
@@ -85,6 +85,7 @@ typedef struct _CoglFramebuffer CoglFramebuffer;
 #include <cogl/cogl-indices.h>
 #include <cogl/cogl-attribute.h>
 #include <cogl/cogl-primitive.h>
+#include <cogl/cogl-depth-state.h>
 #include <cogl/cogl-pipeline.h>
 #include <cogl/cogl-framebuffer.h>
 #ifdef COGL_HAS_XLIB
diff --git a/cogl/driver/gl/cogl-gl.c b/cogl/driver/gl/cogl-gl.c
index 22392de7..c738806a 100644
--- a/cogl/driver/gl/cogl-gl.c
+++ b/cogl/driver/gl/cogl-gl.c
@@ -190,7 +190,8 @@ _cogl_gl_update_features (CoglContext *context)
   _cogl_get_gl_version (&gl_major, &gl_minor);
 
   flags = (COGL_FEATURE_TEXTURE_READ_PIXELS
-           | COGL_FEATURE_UNSIGNED_INT_INDICES);
+           | COGL_FEATURE_UNSIGNED_INT_INDICES
+           | COGL_FEATURE_DEPTH_RANGE);
 
   gl_extensions = (const char *)glGetString (GL_EXTENSIONS);
 
diff --git a/cogl/driver/gles/cogl-gles.c b/cogl/driver/gles/cogl-gles.c
index f137925b..09d03828 100644
--- a/cogl/driver/gles/cogl-gles.c
+++ b/cogl/driver/gles/cogl-gles.c
@@ -129,6 +129,7 @@ _cogl_gl_update_features (CoglContext *context)
   /* Note GLES 2 core doesn't support mipmaps for npot textures or
    * repeat modes other than CLAMP_TO_EDGE. */
   flags |= COGL_FEATURE_TEXTURE_NPOT_BASIC;
+  flags |= COGL_FEATURE_DEPTH_RANGE;
 #endif
 
   flags |= COGL_FEATURE_VBOS;
diff --git a/doc/reference/cogl-2.0/Makefile.am b/doc/reference/cogl-2.0/Makefile.am
index 0c835fef..9e61c2f7 100644
--- a/doc/reference/cogl-2.0/Makefile.am
+++ b/doc/reference/cogl-2.0/Makefile.am
@@ -68,6 +68,7 @@ IGNORE_HFILES=\
 	cogl-object-private.h			\
 	cogl-path.h				\
 	cogl-path-private.h			\
+	cogl-depth-state-private.h		\
 	cogl-pipeline-fragend-arbfp-private.h	\
 	cogl-pipeline-fragend-fixed-private.h	\
 	cogl-pipeline-fragend-glsl-private.h	\
diff --git a/doc/reference/cogl-2.0/cogl-sections.txt b/doc/reference/cogl-2.0/cogl-sections.txt
index 3a0d0d2e..b31a061f 100644
--- a/doc/reference/cogl-2.0/cogl-sections.txt
+++ b/doc/reference/cogl-2.0/cogl-sections.txt
@@ -456,6 +456,20 @@ cogl_blend_string_error_quark
 </SECTION>
 
 <SECTION>
+<FILE>cogl-depth-state</FILE>
+CoglDepthState
+cogl_depth_state_init
+cogl_depth_state_set_test_enabled
+cogl_depth_state_get_test_enabled
+cogl_depth_state_set_test_function
+cogl_depth_state_get_test_function
+cogl_depth_state_set_writing_enabled
+cogl_depth_state_get_writing_enabled
+cogl_depth_state_set_range
+cogl_depth_state_get_range
+</SECTION>
+
+<SECTION>
 <FILE>cogl-buffer</FILE>
 <TITLE>CoglBuffer: The Base Buffer Type</TITLE>
 cogl_is_buffer
diff --git a/doc/reference/cogl/Makefile.am b/doc/reference/cogl/Makefile.am
index 284740be..614494fc 100644
--- a/doc/reference/cogl/Makefile.am
+++ b/doc/reference/cogl/Makefile.am
@@ -66,6 +66,7 @@ IGNORE_HFILES=\
 	cogl-matrix-private.h			\
 	cogl-object-private.h			\
 	cogl-path-private.h			\
+	cogl-depth-state-private.h		\
 	cogl-pipeline-fragend-arbfp-private.h	\
 	cogl-pipeline-fragend-fixed-private.h	\
 	cogl-pipeline-fragend-glsl-private.h	\
diff --git a/doc/reference/cogl/cogl-sections.txt b/doc/reference/cogl/cogl-sections.txt
index 4e521a51..34df2ec1 100644
--- a/doc/reference/cogl/cogl-sections.txt
+++ b/doc/reference/cogl/cogl-sections.txt
@@ -519,14 +519,6 @@ cogl_material_get_layer_wrap_mode_p
 cogl_material_wrap_mode_get_type
 cogl_material_set_user_program
 cogl_material_get_user_program
-cogl_material_set_depth_range
-cogl_material_get_depth_range
-cogl_material_set_depth_test_enabled
-cogl_material_get_depth_test_enabled
-cogl_material_set_depth_test_function
-cogl_material_get_depth_test_function
-cogl_material_set_depth_writing_enabled
-cogl_material_get_depth_writing_enabled
 cogl_material_foreach_layer
 
 <SUBSECTION Private>
@@ -535,6 +527,20 @@ cogl_blend_string_error_quark
 </SECTION>
 
 <SECTION>
+<FILE>cogl-depth-state</FILE>
+CoglDepthState
+cogl_depth_state_init
+cogl_depth_state_set_test_enabled
+cogl_depth_state_get_test_enabled
+cogl_depth_state_set_test_function
+cogl_depth_state_get_test_function
+cogl_depth_state_set_writing_enabled
+cogl_depth_state_get_writing_enabled
+cogl_depth_state_set_range
+cogl_depth_state_get_range
+</SECTION>
+
+<SECTION>
 <FILE>cogl-buffer</FILE>
 <TITLE>Buffers</TITLE>
 cogl_is_buffer