/usr/include/cogl/cogl/cogl-depth-state.h is in libcogl-dev 1.10.0-0ubuntu2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 | /*
* 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]
*
* 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_ID_DEPTH_RANGE feature with
* cogl_has_feature() 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:
* @state: A #CoglDepthState 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__ */
|