From a5c4a959609a8987786450447c33a1a6c9e6aead Mon Sep 17 00:00:00 2001 From: David PIROTTE Date: Fri, 10 Oct 2014 16:52:12 -0300 Subject: [PATCH 11/12] CoglPixelFormat must become visible from guile-clutter Note: this is a 'special' patch, motivated by the necessity to wrap clutter_image_set_data, itself requesting that CoglPixelFormat becomes known and visible from guile-clutter. Until now, there has been no such needs and therefore, no guile-cogl binding [yet], which would be nice but would also represent quite some work. No guile-cogl, no wrapper template, no git branch and no directory infrastructure. So, some cogl type 'polution' is inevitable in our clutter branch and/or files. Among the various possible solutions to this small problem, I believe I took the simplest and fastest to implement, as well as the the easiest to maintain. Here is what I did: (1) I copied the cogl 1.12 types definition file in our clutter wrapper structure, here: clutter/gnome/gw/cogl-support.h; (2) I modified the generation of defs files step [Makefile.am] so that it also generates a cogl-types.defs; (3) I modified the procedures generation step [Makefile.am] so that it includes the cogl-types.defs file. And since from these types, not so many actually, we only use CoglPixelFormat, since CoglPixelFormat definition probably won't change in decades, the solution I proposed and implemented is acceptable, I think. * clutter/gnome/defs/Makefile.am: modified as explained above, see points (2) and (3). * clutter/gnome/gw/cogl-support.h: added as explained above, see point (1). * clutter/gnome/defs/cogl-types.defs: automatically generated, this is the cogl type definitions for cogl version 1.12. --- clutter/gnome/defs/Makefile.am | 8 +- clutter/gnome/defs/cogl-types.defs | 236 ++++++++++ clutter/gnome/gw/cogl-support.h | 871 +++++++++++++++++++++++++++++++++++++ 3 files changed, 1112 insertions(+), 3 deletions(-) create mode 100644 clutter/gnome/defs/cogl-types.defs create mode 100644 clutter/gnome/gw/cogl-support.h diff --git a/clutter/gnome/defs/Makefile.am b/clutter/gnome/defs/Makefile.am index bb26946..11c7d1b 100644 --- a/clutter/gnome/defs/Makefile.am +++ b/clutter/gnome/defs/Makefile.am @@ -8,7 +8,8 @@ defs_DATA = \ clutter-x11.defs \ clutter-x11-types.defs \ clutter-glx.defs \ - clutter-glx-types.defs + clutter-glx-types.defs \ + cogl-types.defs EXTRA_DIST = $(defs_DATA) @@ -19,12 +20,13 @@ CLUTTER_INC_DIR=$(CLUTTER_PREFIX)/include/clutter-$(CLUTTER_MAJORMINOR)/clutter # functions that we deprecated in the current stable release. When the # next stable release comes out, there will be new compile warnings, and # those warnings should be added to the clutter.defs file in ../overrides/. -# + clutter: + ../../../h2def.py --types ../gw/cogl-support.h > cogl-types.defs ../../../h2def.py --types \ $(CLUTTER_INC_DIR)/*.h $(CLUTTER_INC_DIR)/deprecated/*.h > clutter-types.defs ../../../h2def.py --procs \ - --with-header='(include type-ignores) (include "clutter-types.defs") (include overrides)' \ + --with-header='(include type-ignores) (include "cogl-types.defs") (include "clutter-types.defs") (include overrides)' \ $(CLUTTER_INC_DIR)/*.h $(CLUTTER_INC_DIR)/deprecated/*.h > clutter.defs clutter-x11: diff --git a/clutter/gnome/defs/cogl-types.defs b/clutter/gnome/defs/cogl-types.defs new file mode 100644 index 0000000..9b6e8a5 --- /dev/null +++ b/clutter/gnome/defs/cogl-types.defs @@ -0,0 +1,236 @@ +;; -*- scheme -*- +;; Enumerations and flags ... + +(define-enum PixelFormat + (in-module "Cogl") + (c-name "CoglPixelFormat") + (gtype-id "COGL_TYPE_PIXEL_FORMAT") + (values + '("any" "COGL_PIXEL_FORMAT_ANY") + '("a-8" "COGL_PIXEL_FORMAT_A_8") + '("rgb-565" "COGL_PIXEL_FORMAT_RGB_565") + '("rgba-4444" "COGL_PIXEL_FORMAT_RGBA_4444") + '("rgba-5551" "COGL_PIXEL_FORMAT_RGBA_5551") + '("yuv" "COGL_PIXEL_FORMAT_YUV") + '("g-8" "COGL_PIXEL_FORMAT_G_8") + '("rgb-888" "COGL_PIXEL_FORMAT_RGB_888") + '("bgr-888" "COGL_PIXEL_FORMAT_BGR_888") + '("rgba-8888" "COGL_PIXEL_FORMAT_RGBA_8888") + '("bgra-8888" "COGL_PIXEL_FORMAT_BGRA_8888") + '("argb-8888" "COGL_PIXEL_FORMAT_ARGB_8888") + '("abgr-8888" "COGL_PIXEL_FORMAT_ABGR_8888") + '("rgba-1010102" "COGL_PIXEL_FORMAT_RGBA_1010102") + '("bgra-1010102" "COGL_PIXEL_FORMAT_BGRA_1010102") + '("argb-2101010" "COGL_PIXEL_FORMAT_ARGB_2101010") + '("abgr-2101010" "COGL_PIXEL_FORMAT_ABGR_2101010") + '("rgba-8888-pre" "COGL_PIXEL_FORMAT_RGBA_8888_PRE") + '("bgra-8888-pre" "COGL_PIXEL_FORMAT_BGRA_8888_PRE") + '("argb-8888-pre" "COGL_PIXEL_FORMAT_ARGB_8888_PRE") + '("abgr-8888-pre" "COGL_PIXEL_FORMAT_ABGR_8888_PRE") + '("rgba-4444-pre" "COGL_PIXEL_FORMAT_RGBA_4444_PRE") + '("rgba-5551-pre" "COGL_PIXEL_FORMAT_RGBA_5551_PRE") + '("rgba-1010102-pre" "COGL_PIXEL_FORMAT_RGBA_1010102_PRE") + '("bgra-1010102-pre" "COGL_PIXEL_FORMAT_BGRA_1010102_PRE") + '("argb-2101010-pre" "COGL_PIXEL_FORMAT_ARGB_2101010_PRE") + '("abgr-2101010-pre" "COGL_PIXEL_FORMAT_ABGR_2101010_PRE") + ) +) + +(define-flags FeatureFlags + (in-module "Cogl") + (c-name "CoglFeatureFlags") + (gtype-id "COGL_TYPE_FEATURE_FLAGS") + (values + '("texture-rectangle" "COGL_FEATURE_TEXTURE_RECTANGLE") + '("texture-npot" "COGL_FEATURE_TEXTURE_NPOT") + '("texture-yuv" "COGL_FEATURE_TEXTURE_YUV") + '("texture-read-pixels" "COGL_FEATURE_TEXTURE_READ_PIXELS") + '("shaders-glsl" "COGL_FEATURE_SHADERS_GLSL") + '("offscreen" "COGL_FEATURE_OFFSCREEN") + '("offscreen-multisample" "COGL_FEATURE_OFFSCREEN_MULTISAMPLE") + '("offscreen-blit" "COGL_FEATURE_OFFSCREEN_BLIT") + '("four-clip-planes" "COGL_FEATURE_FOUR_CLIP_PLANES") + '("stencil-buffer" "COGL_FEATURE_STENCIL_BUFFER") + '("vbos" "COGL_FEATURE_VBOS") + '("pbos" "COGL_FEATURE_PBOS") + '("unsigned-int-indices" "COGL_FEATURE_UNSIGNED_INT_INDICES") + '("depth-range" "COGL_FEATURE_DEPTH_RANGE") + '("texture-npot-basic" "COGL_FEATURE_TEXTURE_NPOT_BASIC") + '("texture-npot-mipmap" "COGL_FEATURE_TEXTURE_NPOT_MIPMAP") + '("texture-npot-repeat" "COGL_FEATURE_TEXTURE_NPOT_REPEAT") + '("point-sprite" "COGL_FEATURE_POINT_SPRITE") + '("texture-3d" "COGL_FEATURE_TEXTURE_3D") + '("shaders-arbfp" "COGL_FEATURE_SHADERS_ARBFP") + '("map-buffer-for-read" "COGL_FEATURE_MAP_BUFFER_FOR_READ") + '("map-buffer-for-write" "COGL_FEATURE_MAP_BUFFER_FOR_WRITE") + '("onscreen-multiple" "COGL_FEATURE_ONSCREEN_MULTIPLE") + ) +) + +(define-flags BufferTarget + (in-module "Cogl") + (c-name "CoglBufferTarget") + (gtype-id "COGL_TYPE_BUFFER_TARGET") + (values + '("window-buffer" "COGL_WINDOW_BUFFER") + '("offscreen-buffer" "COGL_OFFSCREEN_BUFFER") + ) +) + +(define-flags TextureFlags + (in-module "Cogl") + (c-name "CoglTextureFlags") + (gtype-id "COGL_TYPE_TEXTURE_FLAGS") + (values + '("ne" "COGL_TEXTURE_NONE") + '("-auto-mipmap" "COGL_TEXTURE_NO_AUTO_MIPMAP") + '("-slicing" "COGL_TEXTURE_NO_SLICING") + '("-atlas" "COGL_TEXTURE_NO_ATLAS") + ) +) + +(define-enum FogMode + (in-module "Cogl") + (c-name "CoglFogMode") + (gtype-id "COGL_TYPE_FOG_MODE") + (values + '("linear" "COGL_FOG_MODE_LINEAR") + '("exponential" "COGL_FOG_MODE_EXPONENTIAL") + '("exponential-squared" "COGL_FOG_MODE_EXPONENTIAL_SQUARED") + ) +) + +(define-enum BlendStringError + (in-module "Cogl") + (c-name "CoglBlendStringError") + (gtype-id "COGL_TYPE_BLEND_STRING_ERROR") + (values + '("parse-error" "COGL_BLEND_STRING_ERROR_PARSE_ERROR") + '("argument-parse-error" "COGL_BLEND_STRING_ERROR_ARGUMENT_PARSE_ERROR") + '("invalid-error" "COGL_BLEND_STRING_ERROR_INVALID_ERROR") + '("gpu-unsupported-error" "COGL_BLEND_STRING_ERROR_GPU_UNSUPPORTED_ERROR") + ) +) + +(define-enum Error + (in-module "Cogl") + (c-name "CoglError") + (gtype-id "COGL_TYPE_ERROR") + (values + '("unsupported" "COGL_ERROR_UNSUPPORTED") + '("no-memory" "COGL_ERROR_NO_MEMORY") + ) +) + +(define-enum AttributeType + (in-module "Cogl") + (c-name "CoglAttributeType") + (gtype-id "COGL_TYPE_ATTRIBUTE_TYPE") + (values + '("byte" "COGL_ATTRIBUTE_TYPE_BYTE") + '("unsigned-byte" "COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE") + '("short" "COGL_ATTRIBUTE_TYPE_SHORT") + '("unsigned-short" "COGL_ATTRIBUTE_TYPE_UNSIGNED_SHORT") + '("float" "COGL_ATTRIBUTE_TYPE_FLOAT") + ) +) + +(define-enum IndicesType + (in-module "Cogl") + (c-name "CoglIndicesType") + (gtype-id "COGL_TYPE_INDICES_TYPE") + (values + '("byte" "COGL_INDICES_TYPE_UNSIGNED_BYTE") + '("short" "COGL_INDICES_TYPE_UNSIGNED_SHORT") + '("int" "COGL_INDICES_TYPE_UNSIGNED_INT") + ) +) + +(define-enum VerticesMode + (in-module "Cogl") + (c-name "CoglVerticesMode") + (gtype-id "COGL_TYPE_VERTICES_MODE") + (values + '("points" "COGL_VERTICES_MODE_POINTS") + '("lines" "COGL_VERTICES_MODE_LINES") + '("line-loop" "COGL_VERTICES_MODE_LINE_LOOP") + '("line-strip" "COGL_VERTICES_MODE_LINE_STRIP") + '("triangles" "COGL_VERTICES_MODE_TRIANGLES") + '("triangle-strip" "COGL_VERTICES_MODE_TRIANGLE_STRIP") + '("triangle-fan" "COGL_VERTICES_MODE_TRIANGLE_FAN") + ) +) + +(define-enum DepthTestFunction + (in-module "Cogl") + (c-name "CoglDepthTestFunction") + (gtype-id "COGL_TYPE_DEPTH_TEST_FUNCTION") + (values + '("never" "COGL_DEPTH_TEST_FUNCTION_NEVER") + '("less" "COGL_DEPTH_TEST_FUNCTION_LESS") + '("equal" "COGL_DEPTH_TEST_FUNCTION_EQUAL") + '("lequal" "COGL_DEPTH_TEST_FUNCTION_LEQUAL") + '("greater" "COGL_DEPTH_TEST_FUNCTION_GREATER") + '("notequal" "COGL_DEPTH_TEST_FUNCTION_NOTEQUAL") + '("gequal" "COGL_DEPTH_TEST_FUNCTION_GEQUAL") + '("always" "COGL_DEPTH_TEST_FUNCTION_ALWAYS") + ) +) + +(define-enum RendererError + (in-module "Cogl") + (c-name "CoglRendererError") + (gtype-id "COGL_TYPE_RENDERER_ERROR") + (values + '("not-found" "COGL_RENDERER_ERROR_NOT_FOUND") + '("xlib-display-open" "COGL_RENDERER_ERROR_XLIB_DISPLAY_OPEN") + '("bad-constraint" "COGL_RENDERER_ERROR_BAD_CONSTRAINT") + ) +) + +(define-flags ColorMask + (in-module "Cogl") + (c-name "CoglColorMask") + (gtype-id "COGL_TYPE_COLOR_MASK") + (values + '("none" "COGL_COLOR_MASK_NONE") + '("red" "COGL_COLOR_MASK_RED") + '("green" "COGL_COLOR_MASK_GREEN") + '("blue" "COGL_COLOR_MASK_BLUE") + '("alpha" "COGL_COLOR_MASK_ALPHA") + '("all" "COGL_COLOR_MASK_ALL") + ) +) + +(define-enum Winding + (in-module "Cogl") + (c-name "CoglWinding") + (gtype-id "COGL_TYPE_WINDING") + (values + '("lockwise" "COGL_WINDING_CLOCKWISE") + '("ounter-clockwise" "COGL_WINDING_COUNTER_CLOCKWISE") + ) +) + +(define-flags BufferBit + (in-module "Cogl") + (c-name "CoglBufferBit") + (gtype-id "COGL_TYPE_BUFFER_BIT") + (values + '("color" "COGL_BUFFER_BIT_COLOR") + '("depth" "COGL_BUFFER_BIT_DEPTH") + '("stencil" "COGL_BUFFER_BIT_STENCIL") + ) +) + +(define-flags ReadPixelsFlags + (in-module "Cogl") + (c-name "CoglReadPixelsFlags") + (gtype-id "COGL_TYPE_READ_PIXELS_FLAGS") + (values + '("r" "COGL_READ_PIXELS_COLOR_BUFFER") + ) +) + +;; -*- scheme -*- +; object definitions ... diff --git a/clutter/gnome/gw/cogl-support.h b/clutter/gnome/gw/cogl-support.h new file mode 100644 index 0000000..933cac0 --- /dev/null +++ b/clutter/gnome/gw/cogl-support.h @@ -0,0 +1,871 @@ +/* + * Cogl + * + * An object oriented GL/GLES Abstraction/Utility Layer + * + * Copyright (C) 2008,2009 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 . + * + * + */ + +#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION) +#error "Only can be included directly." +#endif + +#ifndef __COGL_TYPES_H__ +#define __COGL_TYPES_H__ + +#include +#include + +#include + +G_BEGIN_DECLS + +/** + * CoglBool: + * + * A boolean data type used throughout the Cogl C api. This should be + * used in conjunction with the %TRUE and %FALSE macro defines for + * setting and testing boolean values. + * + * Since: 2.0 + * Stability: stable + */ +typedef int CoglBool; + +/** + * TRUE: + * + * A constant to be used with #CoglBool types to indicate a boolean in + * the "true" state. + * + * Since: 2.0 + * Stability: stable + */ +#ifndef TRUE +#define TRUE 1 +#endif + +/** + * TRUE: + * + * A constant to be used with #CoglBool types to indicate a boolean in + * the "false" state. + * + * Since: 2.0 + * Stability: stable + */ +#ifndef FALSE +#define FALSE 0 +#endif + +/* Some structures are meant to be opaque but they have public + definitions because we want the size to be public so they can be + allocated on the stack. This macro is used to ensure that users + don't accidentally access private members */ +#ifdef COGL_COMPILATION +#define COGL_PRIVATE(x) x +#else +#define COGL_PRIVATE(x) private_member_ ## x +#endif + +/* To help catch accidental changes to public structs that should + * be stack allocated we use this macro to compile time assert that + * a struct size is as expected. + */ +#define COGL_STRUCT_SIZE_ASSERT(TYPE, SIZE) \ +typedef struct { \ + char compile_time_assert_ ## TYPE ## _size[ \ + (sizeof (TYPE) == (SIZE)) ? 1 : -1]; \ + } _ ## TYPE ## SizeCheck + +/** + * CoglHandle: + * + * Type used for storing references to cogl objects, the CoglHandle is + * a fully opaque type without any public data members. + */ +typedef void * CoglHandle; + +/** + * COGL_INVALID_HANDLE: + * + * A COGL handle that is not valid, used for unitialized handles as well as + * error conditions. + */ +#define COGL_INVALID_HANDLE NULL + +#define COGL_TYPE_HANDLE (cogl_handle_get_type ()) +GType +cogl_handle_get_type (void) G_GNUC_CONST; + +/** + * cogl_handle_ref: + * @handle: a #CoglHandle + * + * Increases the reference count of @handle by 1 + * + * Return value: (transfer none): the handle, with its reference count increased + */ +CoglHandle +cogl_handle_ref (CoglHandle handle); + +/** + * cogl_handle_unref: + * @handle: a #CoglHandle + * + * Drecreases the reference count of @handle by 1; if the reference + * count reaches 0, the resources allocated by @handle will be freed + */ +void +cogl_handle_unref (CoglHandle handle); + +/** + * cogl_object_ref: (skip) + * @object: a #CoglObject + * + * Increases the reference count of @object by 1 + * + * Returns: the @object, with its reference count increased + */ +void * +cogl_object_ref (void *object); + +/** + * cogl_object_unref: (skip) + * @object: a #CoglObject + * + * Drecreases the reference count of @object by 1; if the reference + * count reaches 0, the resources allocated by @object will be freed + */ +void +cogl_object_unref (void *object); + +/** + * CoglFuncPtr: + * + * The type used by cogl for function pointers, note that this type + * is used as a generic catch-all cast for function pointers and the + * actual arguments and return type may be different. + */ +typedef void (* CoglFuncPtr) (void); + +/* We forward declare this in cogl-types to avoid circular dependencies + * between cogl-matrix.h, cogl-euler.h and cogl-quaterion.h */ +typedef struct _CoglMatrix CoglMatrix; + +/* Same as above we forward declared CoglQuaternion to avoid + * circular dependencies. */ +typedef struct _CoglQuaternion CoglQuaternion; + +/* Same as above we forward declared CoglEuler to avoid + * circular dependencies. */ +typedef struct _CoglEuler CoglEuler; + +/** + * CoglFixed: + * + * Fixed point number using a (16.16) notation. + */ +typedef int32_t CoglFixed; + +#define COGL_TYPE_FIXED (cogl_fixed_get_type ()) +GType +cogl_fixed_get_type (void) G_GNUC_CONST; + +/** + * CoglAngle: + * + * Integer representation of an angle such that 1024 corresponds to + * full circle (i.e., 2 * pi). + * + * Since: 1.0 + */ +typedef int32_t CoglAngle; + +typedef struct _CoglColor CoglColor; +typedef struct _CoglTextureVertex CoglTextureVertex; + +/* Enum declarations */ + +#define COGL_A_BIT (1 << 4) +#define COGL_BGR_BIT (1 << 5) +#define COGL_AFIRST_BIT (1 << 6) +#define COGL_PREMULT_BIT (1 << 7) + +/* XXX: Notes to those adding new formats here... + * + * First this diagram outlines how we allocate the 32bits of a + * CoglPixelFormat currently... + * + * 4 bits for flags + * |--| + * enum unused 4 bits for the bytes-per-pixel + * and component alignment info + * |------| |---------------| |--| + * 00000000 xxxxxxxx xxxxxxxx PFBA0000 + * ^ 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 = undefined + * 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_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_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) +} 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_SHADERS_ARBFP: ARBFP support + * @COGL_FEATURE_OFFSCREEN: FBO support + * @COGL_FEATURE_OFFSCREEN_MULTISAMPLE: Multisample support on FBOs + * @COGL_FEATURE_OFFSCREEN_BLIT: Blit support on FBOs + * @COGL_FEATURE_FOUR_CLIP_PLANES: At least 4 clip planes available + * @COGL_FEATURE_STENCIL_BUFFER: Stencil buffer support + * @COGL_FEATURE_VBOS: VBO support + * @COGL_FEATURE_PBOS: PBO support + * @COGL_FEATURE_UNSIGNED_INT_INDICES: Set if + * %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 + * supported with CoglBufferAccess including write support. + * + * Flags for the supported features. + * + * Since: 0.8 + */ +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), + COGL_FEATURE_FOUR_CLIP_PLANES = (1 << 9), + COGL_FEATURE_STENCIL_BUFFER = (1 << 10), + COGL_FEATURE_VBOS = (1 << 11), + 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_SHADERS_ARBFP = (1 << 20), + COGL_FEATURE_MAP_BUFFER_FOR_READ = (1 << 21), + COGL_FEATURE_MAP_BUFFER_FOR_WRITE = (1 << 22), + COGL_FEATURE_ONSCREEN_MULTIPLE = (1 << 23) +} CoglFeatureFlags; + +/** + * CoglBufferTarget: + * @COGL_WINDOW_BUFFER: FIXME + * @COGL_OFFSCREEN_BUFFER: FIXME + * + * Target flags for FBOs. + * + * Since: 0.8 + */ +typedef enum +{ + COGL_WINDOW_BUFFER = (1 << 1), + COGL_OFFSCREEN_BUFFER = (1 << 2) +} CoglBufferTarget; + +/** + * CoglColor: + * + * A structure for holding a color definition. The contents of + * the CoglColor structure are private and should never by accessed + * directly. + * + * Since: 1.0 + */ +struct _CoglColor +{ + /*< private >*/ + uint8_t COGL_PRIVATE (red); + uint8_t COGL_PRIVATE (green); + uint8_t COGL_PRIVATE (blue); + + uint8_t COGL_PRIVATE (alpha); + + /* padding in case we want to change to floats at + * some point */ + uint32_t COGL_PRIVATE (padding0); + uint32_t COGL_PRIVATE (padding1); + uint32_t COGL_PRIVATE (padding2); +}; +COGL_STRUCT_SIZE_ASSERT (CoglColor, 16); + +/** + * CoglTextureVertex: + * @x: Model x-coordinate + * @y: Model y-coordinate + * @z: Model z-coordinate + * @tx: Texture x-coordinate + * @ty: Texture y-coordinate + * @color: The color to use at this vertex. This is ignored if + * use_color is %FALSE when calling cogl_polygon() + * + * Used to specify vertex information when calling cogl_polygon() + */ +struct _CoglTextureVertex +{ + float x, y, z; + float tx, ty; + + CoglColor color; +}; +COGL_STRUCT_SIZE_ASSERT (CoglTextureVertex, 36); + +/** + * CoglTextureFlags: + * @COGL_TEXTURE_NONE: No flags specified + * @COGL_TEXTURE_NO_AUTO_MIPMAP: Disables the automatic generation of + * the mipmap pyramid from the base level image whenever it is + * updated. The mipmaps are only generated when the texture is + * rendered with a mipmap filter so it should be free to leave out + * this flag when using other filtering modes + * @COGL_TEXTURE_NO_SLICING: Disables the slicing of the texture + * @COGL_TEXTURE_NO_ATLAS: Disables the insertion of the texture inside + * the texture atlas used by Cogl + * + * Flags to pass to the cogl_texture_new_* family of functions. + * + * Since: 1.0 + */ +typedef enum { + COGL_TEXTURE_NONE = 0, + COGL_TEXTURE_NO_AUTO_MIPMAP = 1 << 0, + COGL_TEXTURE_NO_SLICING = 1 << 1, + COGL_TEXTURE_NO_ATLAS = 1 << 2 +} CoglTextureFlags; + +/** + * CoglFogMode: + * @COGL_FOG_MODE_LINEAR: Calculates the fog blend factor as: + * |[ + * f = end - eye_distance / end - start + * ]| + * @COGL_FOG_MODE_EXPONENTIAL: Calculates the fog blend factor as: + * |[ + * f = e ^ -(density * eye_distance) + * ]| + * @COGL_FOG_MODE_EXPONENTIAL_SQUARED: Calculates the fog blend factor as: + * |[ + * f = e ^ -(density * eye_distance)^2 + * ]| + * + * The fog mode determines the equation used to calculate the fogging blend + * factor while fogging is enabled. The simplest %COGL_FOG_MODE_LINEAR mode + * determines f as: + * + * |[ + * f = end - eye_distance / end - start + * ]| + * + * Where eye_distance is the distance of the current fragment in eye + * coordinates from the origin. + * + * Since: 1.0 + */ +typedef enum { + COGL_FOG_MODE_LINEAR, + COGL_FOG_MODE_EXPONENTIAL, + COGL_FOG_MODE_EXPONENTIAL_SQUARED +} CoglFogMode; + +/** + * COGL_BLEND_STRING_ERROR: + * + * #GError domain for blend string parser errors + * + * Since: 1.0 + */ +#define COGL_BLEND_STRING_ERROR (cogl_blend_string_error_quark ()) + +/** + * CoglBlendStringError: + * @COGL_BLEND_STRING_ERROR_PARSE_ERROR: Generic parse error + * @COGL_BLEND_STRING_ERROR_ARGUMENT_PARSE_ERROR: Argument parse error + * @COGL_BLEND_STRING_ERROR_INVALID_ERROR: Internal parser error + * @COGL_BLEND_STRING_ERROR_GPU_UNSUPPORTED_ERROR: Blend string not + * supported by the GPU + * + * Error enumeration for the blend strings parser + * + * Since: 1.0 + */ +typedef enum { /*< prefix=COGL_BLEND_STRING_ERROR >*/ + COGL_BLEND_STRING_ERROR_PARSE_ERROR, + COGL_BLEND_STRING_ERROR_ARGUMENT_PARSE_ERROR, + COGL_BLEND_STRING_ERROR_INVALID_ERROR, + COGL_BLEND_STRING_ERROR_GPU_UNSUPPORTED_ERROR +} CoglBlendStringError; + +GQuark +cogl_blend_string_error_quark (void); + +#define COGL_ERROR (_cogl_error_quark ()) + +/** + * CoglError: + * @COGL_ERROR_UNSUPPORTED: You tried to use a feature or + * configuration not currently available. + * @COGL_ERROR_NO_MEMORY: You tried to allocate a resource + * such as a texture and there wasn't enough memory. + * + * Error enumeration for Cogl + * + * The @COGL_ERROR_UNSUPPORTED error can be thrown for a variety of + * reasons. For example: + * + * + * You've tried to use a feature that is not + * advertised by cogl_get_features(). This could happen if you create + * a 2d texture with a non-power-of-two size when + * %COGL_FEATURE_TEXTURE_NPOT is not advertised. + * 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 + * The driver does not support some + * configuration. + * + * + * Currently this is only used by Cogl API marked as experimental so + * this enum should also be considered experimental. + * + * Since: 1.4 + * Stability: unstable + */ +typedef enum { /*< prefix=COGL_ERROR >*/ + COGL_ERROR_UNSUPPORTED, + COGL_ERROR_NO_MEMORY +} CoglError; + +GQuark +_cogl_error_quark (void); + +/** + * CoglAttributeType: + * @COGL_ATTRIBUTE_TYPE_BYTE: Data is the same size of a byte + * @COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE: Data is the same size of an + * unsigned byte + * @COGL_ATTRIBUTE_TYPE_SHORT: Data is the same size of a short integer + * @COGL_ATTRIBUTE_TYPE_UNSIGNED_SHORT: Data is the same size of + * an unsigned short integer + * @COGL_ATTRIBUTE_TYPE_FLOAT: Data is the same size of a float + * + * Data types for the components of a vertex attribute. + * + * Since: 1.0 + */ +typedef enum { + COGL_ATTRIBUTE_TYPE_BYTE = 0x1400, + COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE = 0x1401, + COGL_ATTRIBUTE_TYPE_SHORT = 0x1402, + COGL_ATTRIBUTE_TYPE_UNSIGNED_SHORT = 0x1403, + COGL_ATTRIBUTE_TYPE_FLOAT = 0x1406 +} CoglAttributeType; + +/** + * CoglIndicesType: + * @COGL_INDICES_TYPE_UNSIGNED_BYTE: Your indices are unsigned bytes + * @COGL_INDICES_TYPE_UNSIGNED_SHORT: Your indices are unsigned shorts + * @COGL_INDICES_TYPE_UNSIGNED_INT: Your indices are unsigned ints + * + * You should aim to use the smallest data type that gives you enough + * range, since it reduces the size of your index array and can help + * reduce the demand on memory bandwidth. + * + * Note that %COGL_INDICES_TYPE_UNSIGNED_INT is only supported if the + * %COGL_FEATURE_UNSIGNED_INT_INDICES feature is available. This + * should always be available on OpenGL but on OpenGL ES it will only + * be available if the GL_OES_element_index_uint extension is + * advertized. + */ +typedef enum { + COGL_INDICES_TYPE_UNSIGNED_BYTE, + COGL_INDICES_TYPE_UNSIGNED_SHORT, + COGL_INDICES_TYPE_UNSIGNED_INT +} CoglIndicesType; + +/** + * CoglVerticesMode: + * @COGL_VERTICES_MODE_POINTS: FIXME, equivalent to %GL_POINTS + * @COGL_VERTICES_MODE_LINES: FIXME, equivalent to %GL_LINES + * @COGL_VERTICES_MODE_LINE_LOOP: FIXME, equivalent to %GL_LINE_LOOP + * @COGL_VERTICES_MODE_LINE_STRIP: FIXME, equivalent to %GL_LINE_STRIP + * @COGL_VERTICES_MODE_TRIANGLES: FIXME, equivalent to %GL_TRIANGLES + * @COGL_VERTICES_MODE_TRIANGLE_STRIP: FIXME, equivalent to %GL_TRIANGLE_STRIP + * @COGL_VERTICES_MODE_TRIANGLE_FAN: FIXME, equivalent to %GL_TRIANGLE_FAN + * + * Different ways of interpreting vertices when drawing. + * + * Since: 1.0 + */ +typedef enum { + COGL_VERTICES_MODE_POINTS = 0x0000, + COGL_VERTICES_MODE_LINES = 0x0001, + COGL_VERTICES_MODE_LINE_LOOP = 0x0002, + COGL_VERTICES_MODE_LINE_STRIP = 0x0003, + COGL_VERTICES_MODE_TRIANGLES = 0x0004, + COGL_VERTICES_MODE_TRIANGLE_STRIP = 0x0005, + COGL_VERTICES_MODE_TRIANGLE_FAN = 0x0006 +} CoglVerticesMode; + +/* NB: The above definitions are taken from gl.h equivalents */ + + +/* XXX: should this be CoglMaterialDepthTestFunction? + * It makes it very verbose but would be consistent with + * CoglMaterialWrapMode */ + +/** + * CoglDepthTestFunction: + * @COGL_DEPTH_TEST_FUNCTION_NEVER: Never passes. + * @COGL_DEPTH_TEST_FUNCTION_LESS: Passes if the fragment's depth + * value is less than the value currently in the depth buffer. + * @COGL_DEPTH_TEST_FUNCTION_EQUAL: Passes if the fragment's depth + * value is equal to the value currently in the depth buffer. + * @COGL_DEPTH_TEST_FUNCTION_LEQUAL: Passes if the fragment's depth + * value is less or equal to the value currently in the depth buffer. + * @COGL_DEPTH_TEST_FUNCTION_GREATER: Passes if the fragment's depth + * value is greater than the value currently in the depth buffer. + * @COGL_DEPTH_TEST_FUNCTION_NOTEQUAL: Passes if the fragment's depth + * value is not equal to the value currently in the depth buffer. + * @COGL_DEPTH_TEST_FUNCTION_GEQUAL: Passes if the fragment's depth + * value greater than or equal to the value currently in the depth buffer. + * @COGL_DEPTH_TEST_FUNCTION_ALWAYS: Always passes. + * + * When using depth testing one of these functions is used to compare + * the depth of an incoming fragment against the depth value currently + * stored in the depth buffer. The function is changed using + * cogl_material_set_depth_test_function(). + * + * The test is only done when depth testing is explicitly enabled. (See + * cogl_material_set_depth_test_enabled()) + */ +typedef enum +{ + COGL_DEPTH_TEST_FUNCTION_NEVER = 0x0200, + COGL_DEPTH_TEST_FUNCTION_LESS = 0x0201, + COGL_DEPTH_TEST_FUNCTION_EQUAL = 0x0202, + COGL_DEPTH_TEST_FUNCTION_LEQUAL = 0x0203, + COGL_DEPTH_TEST_FUNCTION_GREATER = 0x0204, + COGL_DEPTH_TEST_FUNCTION_NOTEQUAL = 0x0205, + COGL_DEPTH_TEST_FUNCTION_GEQUAL = 0x0206, + COGL_DEPTH_TEST_FUNCTION_ALWAYS = 0x0207 +} CoglDepthTestFunction; +/* NB: The above definitions are taken from gl.h equivalents */ + +typedef enum { /*< prefix=COGL_RENDERER_ERROR >*/ + COGL_RENDERER_ERROR_NOT_FOUND, + COGL_RENDERER_ERROR_XLIB_DISPLAY_OPEN, + COGL_RENDERER_ERROR_BAD_CONSTRAINT +} CoglRendererError; + +/* + * CoglFilterReturn: + * @COGL_FILTER_CONTINUE: The event was not handled, continues the + * processing + * @COGL_FILTER_REMOVE: Remove the event, stops the processing + * + * Return values for the #CoglFilterFunc function. + * + * Stability: Unstable + */ +typedef enum _CoglFilterReturn { /*< prefix=COGL_FILTER >*/ + COGL_FILTER_CONTINUE, + COGL_FILTER_REMOVE +} CoglFilterReturn; + +typedef enum _CoglWinsysFeature +{ + /* Available if the window system can support multiple onscreen + * framebuffers at the same time. */ + COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN, + + /* Available if onscreen framebuffer swaps can be automatically + * throttled to the vblank frequency. */ + COGL_WINSYS_FEATURE_SWAP_THROTTLE, + + /* Available if its possible to query a counter that + * increments at each vblank. */ + COGL_WINSYS_FEATURE_VBLANK_COUNTER, + + /* Available if its possible to wait until the next vertical + * blank period */ + COGL_WINSYS_FEATURE_VBLANK_WAIT, + + /* Available if the window system supports mapping native + * pixmaps to textures. */ + COGL_WINSYS_FEATURE_TEXTURE_FROM_PIXMAP, + + /* Available if the window system supports reporting an event + * for swap buffer completions. */ + COGL_WINSYS_FEATURE_SWAP_BUFFERS_EVENT, + + /* Available if it's possible to swap a list of sub rectangles + * from the back buffer to the front buffer */ + COGL_WINSYS_FEATURE_SWAP_REGION, + + /* Available if swap_region requests can be automatically throttled + * to the vblank frequency. */ + COGL_WINSYS_FEATURE_SWAP_REGION_THROTTLE, + + /* Available if the swap region implementation won't tear and thus + * only needs to be throttled to the framerate */ + COGL_WINSYS_FEATURE_SWAP_REGION_SYNCHRONIZED, + + 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_WINDING_COUNTER_CLOCKWISE: Vertices are in a counter-clockwise order + * + * Enum used to represent the two directions of rotation. This can be + * used to set the front face for culling by calling + * cogl_pipeline_set_front_face_winding(). + */ +typedef enum +{ + COGL_WINDING_CLOCKWISE, + COGL_WINDING_COUNTER_CLOCKWISE +} CoglWinding; + +/** + * CoglBufferBit: + * @COGL_BUFFER_BIT_COLOR: Selects the primary color buffer + * @COGL_BUFFER_BIT_DEPTH: Selects the depth buffer + * @COGL_BUFFER_BIT_STENCIL: Selects the stencil buffer + * + * Types of auxiliary buffers + * + * Since: 1.0 + */ +typedef enum { + COGL_BUFFER_BIT_COLOR = 1L<<0, + COGL_BUFFER_BIT_DEPTH = 1L<<1, + COGL_BUFFER_BIT_STENCIL = 1L<<2 +} CoglBufferBit; + +/** + * CoglReadPixelsFlags: + * @COGL_READ_PIXELS_COLOR_BUFFER: Read from the color buffer + * + * Flags for cogl_read_pixels() + * + * Since: 1.0 + */ +typedef enum { /*< prefix=COGL_READ_PIXELS >*/ + COGL_READ_PIXELS_COLOR_BUFFER = 1L << 0 +} CoglReadPixelsFlags; + +G_END_DECLS + +#endif /* __COGL_TYPES_H__ */ -- 2.1.1