From 90d634feeb61e9ce5c8e0e556d2a2ca22e44bbcf Mon Sep 17 00:00:00 2001 From: Matthew Allum Date: Fri, 27 Apr 2007 21:13:06 +0000 Subject: [PATCH] 2007-04-27 Matthew Allum * clutter/Makefile.am: * clutter/clutter-actor.c: * clutter/clutter-clone-texture.c: * clutter/clutter-rectangle.c: * clutter/clutter-stage.c: * clutter/clutter-texture.c: * clutter/cogl/cogl.h: * clutter/cogl/gl/Makefile.am: * clutter/cogl/gl/cogl-defines.h: * clutter/cogl/gl/cogl.c: * clutter/cogl/gles/Makefile.am: * clutter/cogl/gles/cogl-defines.h: * clutter/cogl/gles/cogl.c: * clutter/glx/Makefile.am: * clutter/glx/clutter-stage-glx.c: * clutter/pango/Makefile.am: * clutter/pango/pangoclutter-render.c: * configure.ac: Add initial 'cogl' implementation. 'cogl' is a simple abstration layer over GL and GL/ES used by clutter internally. It should eventually allow clutter applications to be run on both GL and GL/ES with just a recompile as well as provide more debugging and potentially profiling information for GL and GL/ES usage. This commit contains the initial GL implementation. --- cogl.h | 133 +++++++-- gl/Makefile.am | 8 +- gl/cogl-defines.h | 677 ++++++++++++++++++++++++++++++++++++++++++++ gl/cogl.c | 437 +++++++++++++++++++++++++++- gles/Makefile.am | 3 +- gles/cogl-defines.h | 440 ++++++++++++++++++++++++++++ gles/cogl.c | 68 ++++- 7 files changed, 1725 insertions(+), 41 deletions(-) create mode 100644 gl/cogl-defines.h create mode 100644 gles/cogl-defines.h diff --git a/cogl.h b/cogl.h index fce18144a..f787835aa 100644 --- a/cogl.h +++ b/cogl.h @@ -23,14 +23,37 @@ * Boston, MA 02111-1307, USA. */ +/* + * COGL + * ==== + * + * 'cogl' is a very simple abstraction layer which wraps GL and GLES. + * + * + * !!!! DO NOT USE THIS API YET OUTSIDE OF CLUTTER CORE !!!! + * THE API WILL FLUCTUATE WILDLY + * + * TODO: + * - Use ClutterReal for fixed/float params. + * - Add Perspective/viewport setup + * - Add Features.. + */ + #ifndef __COGL_H__ #define __COGL_H__ #include #include +#include "cogl-defines.h" + G_BEGIN_DECLS +#define CGL_ENABLE_BLEND (1<<1) +#define CGL_ENABLE_TEXTURE_2D (1<<2) +#define CGL_ENABLE_ALPHA_TEST (1<<3) +#define CGL_ENABLE_TEXTURE_RECT (1<<4) + typedef void (*CoglFuncPtr) (void); CoglFuncPtr @@ -39,6 +62,20 @@ cogl_get_proc_address (const gchar* name); gboolean cogl_check_extension (const gchar *name, const gchar *ext); +void +cogl_perspective (ClutterAngle fovy, + ClutterFixed aspect, + ClutterFixed zNear, + ClutterFixed zFar); + +void +cogl_setup_viewport (guint width, + guint height, + ClutterAngle fovy, + ClutterFixed aspect, + ClutterFixed z_near, + ClutterFixed z_far); + void cogl_paint_init (ClutterColor *color); @@ -49,7 +86,7 @@ void cogl_pop_matrix (void); void -cogl_scaled (ClutterFixed x, ClutterFixed z); +cogl_scale (ClutterFixed x, ClutterFixed z); void cogl_translatex (ClutterFixed x, ClutterFixed y, ClutterFixed z); @@ -66,29 +103,81 @@ cogl_rotate (gint angle, gint x, gint y, gint z); void cogl_color (ClutterColor *color); -#if 0 +void +cogl_enable (gulong flags); -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glColor3f' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glColor4ub' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glGetTexLevelParameteriv' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glSelectBuffer' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glScaled' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glPushName' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glRecti' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glBegin' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glInitNames' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glVertex2i' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glGetTexImage' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glTexCoord2f' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glRenderMode' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glTranslated' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glRotated' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glLoadName' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glTexEnvi' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glVertex2d' -../clutter/.libs/libclutter-egl-0.3.so: undefined reference to `glEnd' +gboolean +cogl_texture_can_size (COGLenum pixel_format, + COGLenum pixel_type, + int width, + int height); +void +cogl_texture_quad (gint x1, + gint x2, + gint y1, + gint y2, + ClutterFixed tx1, + ClutterFixed ty1, + ClutterFixed tx2, + ClutterFixed ty2); + +void +cogl_textures_create (guint num, guint *textures); + +void +cogl_textures_destroy (guint num, const guint *textures); + +void +cogl_texture_bind (COGLenum target, guint texture); + +void +cogl_texture_set_alignment (COGLenum target, + guint alignment, + guint row_length); + +void +cogl_texture_set_filters (COGLenum target, + COGLenum min_filter, + COGLenum max_filter); + +void +cogl_texture_set_wrap (COGLenum target, + COGLenum wrap_s, + COGLenum wrap_t); + +void +cogl_texture_image_2d (COGLenum target, + COGLint internal_format, + gint width, + gint height, + COGLenum format, + COGLenum type, + const guchar* pixels); + +void +cogl_texture_sub_image_2d (COGLenum target, + gint xoff, + gint yoff, + gint width, + gint height, + COGLenum format, + COGLenum type, + const guchar* pixels); + +void +cogl_rectangle (gint x, gint y, guint width, guint height); + +void +cogl_trapezoid (gint y1, + gint x11, + gint x21, + gint y2, + gint x12, + gint x22); +void +cogl_alpha_func (COGLenum func, + ClutterFixed ref); -#endif G_END_DECLS diff --git a/gl/Makefile.am b/gl/Makefile.am index 2873fcacb..98949b261 100644 --- a/gl/Makefile.am +++ b/gl/Makefile.am @@ -1,5 +1,6 @@ libclutterincludedir = $(includedir)/clutter-@CLUTTER_API_VERSION@/clutter -libclutterinclude_HEADERS = $(top_srcdir)/clutter/cogl/cogl.h +libclutterinclude_HEADERS = $(top_srcdir)/clutter/cogl/cogl.h \ + $(top_srcdir)/clutter/cogl/gl/cogl-defines.h INCLUDES = \ -I$(top_srcdir) \ @@ -12,6 +13,7 @@ LDADD = $(CLUTTER_LIBS) noinst_LTLIBRARIES = libclutter-cogl.la -libclutter_cogl_la_SOURCES = \ - $(top_srcdir)/clutter/cogl/cogl.h \ +libclutter_cogl_la_SOURCES = \ + $(top_srcdir)/clutter/cogl/cogl.h \ + $(top_srcdir)/clutter/cogl/gl/cogl-defines.h \ cogl.c diff --git a/gl/cogl-defines.h b/gl/cogl-defines.h new file mode 100644 index 000000000..bee7ecc89 --- /dev/null +++ b/gl/cogl-defines.h @@ -0,0 +1,677 @@ +/* + * Clutter COGL + * + * A basic GL/GLES Abstraction/Utility Layer + * + * Authored By Matthew Allum + * + * Copyright (C) 2007 OpenedHand + * + * 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, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __COGL_DEFINES_H__ +#define __COGL_DEFINES_H__ + +#include + +G_BEGIN_DECLS + +typedef GLenum COGLenum; +typedef GLint COGLint; + +/* FIXME + DOCUMENT */ + +#define COPENSTEP OPENSTEP +#define CGLAPI GLAPI +#define CGLAPI GLAPI +#define CGLAPI GLAPI +#define CGLAPIENTRY GLAPIENTRY +#define CGLAPI GLAPI +#define CGLAPIENTRY GLAPIENTRY +#define CGLAPI GLAPI +#define CGLAPIENTRY GLAPIENTRY +#define CPRAGMA_EXPORT_SUPPORTED PRAGMA_EXPORT_SUPPORTED +#define CGLAPI GLAPI +#define CGLAPIENTRY GLAPIENTRY +#define CAPIENTRY APIENTRY +#define CAPIENTRYP APIENTRYP +#define CGLAPIENTRYP GLAPIENTRYP +#define CGL_FALSE GL_FALSE +#define CGL_TRUE GL_TRUE +#define CGL_BYTE GL_BYTE +#define CGL_UNSIGNED_BYTE GL_UNSIGNED_BYTE +#define CGL_SHORT GL_SHORT +#define CGL_UNSIGNED_SHORT GL_UNSIGNED_SHORT +#define CGL_INT GL_INT +#define CGL_UNSIGNED_INT GL_UNSIGNED_INT +#define CGL_FLOAT GL_FLOAT +#define CGL_DOUBLE GL_DOUBLE +#define CGL_POINTS GL_POINTS +#define CGL_LINES GL_LINES +#define CGL_LINE_LOOP GL_LINE_LOOP +#define CGL_LINE_STRIP GL_LINE_STRIP +#define CGL_TRIANGLES GL_TRIANGLES +#define CGL_TRIANGLE_STRIP GL_TRIANGLE_STRIP +#define CGL_TRIANGLE_FAN GL_TRIANGLE_FAN +#define CGL_QUADS GL_QUADS +#define CGL_QUAD_STRIP GL_QUAD_STRIP +#define CGL_POLYGON GL_POLYGON +#define CGL_VERTEX_ARRAY GL_VERTEX_ARRAY +#define CGL_NORMAL_ARRAY GL_NORMAL_ARRAY +#define CGL_COLOR_ARRAY GL_COLOR_ARRAY +#define CGL_INDEX_ARRAY GL_INDEX_ARRAY +#define CGL_TEXTURE_COORD_ARRAY GL_TEXTURE_COORD_ARRAY +#define CGL_EDGE_FLAG_ARRAY GL_EDGE_FLAG_ARRAY +#define CGL_VERTEX_ARRAY_SIZE GL_VERTEX_ARRAY_SIZE +#define CGL_VERTEX_ARRAY_TYPE GL_VERTEX_ARRAY_TYPE +#define CGL_VERTEX_ARRAY_STRIDE GL_VERTEX_ARRAY_STRIDE +#define CGL_NORMAL_ARRAY_TYPE GL_NORMAL_ARRAY_TYPE +#define CGL_NORMAL_ARRAY_STRIDE GL_NORMAL_ARRAY_STRIDE +#define CGL_COLOR_ARRAY_SIZE GL_COLOR_ARRAY_SIZE +#define CGL_COLOR_ARRAY_TYPE GL_COLOR_ARRAY_TYPE +#define CGL_COLOR_ARRAY_STRIDE GL_COLOR_ARRAY_STRIDE +#define CGL_INDEX_ARRAY_TYPE GL_INDEX_ARRAY_TYPE +#define CGL_INDEX_ARRAY_STRIDE GL_INDEX_ARRAY_STRIDE +#define CGL_TEXTURE_COORD_ARRAY_SIZE GL_TEXTURE_COORD_ARRAY_SIZE +#define CGL_TEXTURE_COORD_ARRAY_TYPE GL_TEXTURE_COORD_ARRAY_TYPE +#define CGL_TEXTURE_COORD_ARRAY_STRIDE GL_TEXTURE_COORD_ARRAY_STRIDE +#define CGL_EDGE_FLAG_ARRAY_STRIDE GL_EDGE_FLAG_ARRAY_STRIDE +#define CGL_VERTEX_ARRAY_POINTER GL_VERTEX_ARRAY_POINTER +#define CGL_NORMAL_ARRAY_POINTER GL_NORMAL_ARRAY_POINTER +#define CGL_COLOR_ARRAY_POINTER GL_COLOR_ARRAY_POINTER +#define CGL_INDEX_ARRAY_POINTER GL_INDEX_ARRAY_POINTER +#define CGL_TEXTURE_COORD_ARRAY_POINTER GL_TEXTURE_COORD_ARRAY_POINTER +#define CGL_EDGE_FLAG_ARRAY_POINTER GL_EDGE_FLAG_ARRAY_POINTER +#define CGL_MATRIX_MODE GL_MATRIX_MODE +#define CGL_MODELVIEW GL_MODELVIEW +#define CGL_PROJECTION GL_PROJECTION +#define CGL_TEXTURE GL_TEXTURE +#define CGL_POINT_SMOOTH GL_POINT_SMOOTH +#define CGL_POINT_SIZE GL_POINT_SIZE +#define CGL_POINT_SIZE_GRANULARITY GL_POINT_SIZE_GRANULARITY +#define CGL_POINT_SIZE_RANGE GL_POINT_SIZE_RANGE +#define CGL_LINE_SMOOTH GL_LINE_SMOOTH +#define CGL_LINE_STIPPLE GL_LINE_STIPPLE +#define CGL_LINE_STIPPLE_PATTERN GL_LINE_STIPPLE_PATTERN +#define CGL_LINE_STIPPLE_REPEAT GL_LINE_STIPPLE_REPEAT +#define CGL_LINE_WIDTH GL_LINE_WIDTH +#define CGL_LINE_WIDTH_GRANULARITY GL_LINE_WIDTH_GRANULARITY +#define CGL_LINE_WIDTH_RANGE GL_LINE_WIDTH_RANGE +#define CGL_POINT GL_POINT +#define CGL_LINE GL_LINE +#define CGL_FILL GL_FILL +#define CGL_CW GL_CW +#define CGL_CCW GL_CCW +#define CGL_FRONT GL_FRONT +#define CGL_BACK GL_BACK +#define CGL_POLYGON_MODE GL_POLYGON_MODE +#define CGL_POLYGON_SMOOTH GL_POLYGON_SMOOTH +#define CGL_POLYGON_STIPPLE GL_POLYGON_STIPPLE +#define CGL_EDGE_FLAG GL_EDGE_FLAG +#define CGL_CULL_FACE GL_CULL_FACE +#define CGL_CULL_FACE_MODE GL_CULL_FACE_MODE +#define CGL_FRONT_FACE GL_FRONT_FACE +#define CGL_POLYGON_OFFSET_FACTOR GL_POLYGON_OFFSET_FACTOR +#define CGL_POLYGON_OFFSET_UNITS GL_POLYGON_OFFSET_UNITS +#define CGL_POLYGON_OFFSET_POINT GL_POLYGON_OFFSET_POINT +#define CGL_POLYGON_OFFSET_LINE GL_POLYGON_OFFSET_LINE +#define CGL_POLYGON_OFFSET_FILL GL_POLYGON_OFFSET_FILL +#define CGL_COMPILE GL_COMPILE +#define CGL_COMPILE_AND_EXECUTE GL_COMPILE_AND_EXECUTE +#define CGL_LIST_BASE GL_LIST_BASE +#define CGL_LIST_INDEX GL_LIST_INDEX +#define CGL_LIST_MODE GL_LIST_MODE +#define CGL_NEVER GL_NEVER +#define CGL_LESS GL_LESS +#define CGL_EQUAL GL_EQUAL +#define CGL_LEQUAL GL_LEQUAL +#define CGL_GREATER GL_GREATER +#define CGL_NOTEQUAL GL_NOTEQUAL +#define CGL_GEQUAL GL_GEQUAL +#define CGL_ALWAYS GL_ALWAYS +#define CGL_DEPTH_TEST GL_DEPTH_TEST +#define CGL_DEPTH_BITS GL_DEPTH_BITS +#define CGL_DEPTH_CLEAR_VALUE GL_DEPTH_CLEAR_VALUE +#define CGL_DEPTH_FUNC GL_DEPTH_FUNC +#define CGL_DEPTH_RANGE GL_DEPTH_RANGE +#define CGL_DEPTH_WRITEMASK GL_DEPTH_WRITEMASK +#define CGL_DEPTH_COMPONENT GL_DEPTH_COMPONENT +#define CGL_LIGHTING GL_LIGHTING +#define CGL_SPOT_EXPONENT GL_SPOT_EXPONENT +#define CGL_SPOT_CUTOFF GL_SPOT_CUTOFF +#define CGL_CONSTANT_ATTENUATION GL_CONSTANT_ATTENUATION +#define CGL_LINEAR_ATTENUATION GL_LINEAR_ATTENUATION +#define CGL_QUADRATIC_ATTENUATION GL_QUADRATIC_ATTENUATION +#define CGL_AMBIENT GL_AMBIENT +#define CGL_DIFFUSE GL_DIFFUSE +#define CGL_SPECULAR GL_SPECULAR +#define CGL_SHININESS GL_SHININESS +#define CGL_EMISSION GL_EMISSION +#define CGL_POSITION GL_POSITION +#define CGL_SPOT_DIRECTION GL_SPOT_DIRECTION +#define CGL_AMBIENT_AND_DIFFUSE GL_AMBIENT_AND_DIFFUSE +#define CGL_COLOR_INDEXES GL_COLOR_INDEXES +#define CGL_LIGHT_MODEL_TWO_SIDE GL_LIGHT_MODEL_TWO_SIDE +#define CGL_LIGHT_MODEL_LOCAL_VIEWER GL_LIGHT_MODEL_LOCAL_VIEWER +#define CGL_LIGHT_MODEL_AMBIENT GL_LIGHT_MODEL_AMBIENT +#define CGL_FRONT_AND_BACK GL_FRONT_AND_BACK +#define CGL_SHADE_MODEL GL_SHADE_MODEL +#define CGL_FLAT GL_FLAT +#define CGL_SMOOTH GL_SMOOTH +#define CGL_COLOR_MATERIAL GL_COLOR_MATERIAL +#define CGL_COLOR_MATERIAL_FACE GL_COLOR_MATERIAL_FACE +#define CGL_COLOR_MATERIAL_PARAMETER GL_COLOR_MATERIAL_PARAMETER +#define CGL_NORMALIZE GL_NORMALIZE +#define CGL_ACCUM_RED_BITS GL_ACCUM_RED_BITS +#define CGL_ACCUM_GREEN_BITS GL_ACCUM_GREEN_BITS +#define CGL_ACCUM_BLUE_BITS GL_ACCUM_BLUE_BITS +#define CGL_ACCUM_ALPHA_BITS GL_ACCUM_ALPHA_BITS +#define CGL_ACCUM_CLEAR_VALUE GL_ACCUM_CLEAR_VALUE +#define CGL_ACCUM GL_ACCUM +#define CGL_ADD GL_ADD +#define CGL_LOAD GL_LOAD +#define CGL_MULT GL_MULT +#define CGL_RETURN GL_RETURN +#define CGL_ALPHA_TEST GL_ALPHA_TEST +#define CGL_ALPHA_TEST_REF GL_ALPHA_TEST_REF +#define CGL_ALPHA_TEST_FUNC GL_ALPHA_TEST_FUNC +#define CGL_BLEND GL_BLEND +#define CGL_BLEND_SRC GL_BLEND_SRC +#define CGL_BLEND_DST GL_BLEND_DST +#define CGL_ZERO GL_ZERO +#define CGL_ONE GL_ONE +#define CGL_SRC_COLOR GL_SRC_COLOR +#define CGL_ONE_MINUS_SRC_COLOR GL_ONE_MINUS_SRC_COLOR +#define CGL_SRC_ALPHA GL_SRC_ALPHA +#define CGL_ONE_MINUS_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA +#define CGL_DST_ALPHA GL_DST_ALPHA +#define CGL_ONE_MINUS_DST_ALPHA GL_ONE_MINUS_DST_ALPHA +#define CGL_DST_COLOR GL_DST_COLOR +#define CGL_ONE_MINUS_DST_COLOR GL_ONE_MINUS_DST_COLOR +#define CGL_SRC_ALPHA_SATURATE GL_SRC_ALPHA_SATURATE +#define CGL_FEEDBACK GL_FEEDBACK +#define CGL_RENDER GL_RENDER +#define CGL_SELECT GL_SELECT +#define CGL_POINT_TOKEN GL_POINT_TOKEN +#define CGL_LINE_TOKEN GL_LINE_TOKEN +#define CGL_LINE_RESET_TOKEN GL_LINE_RESET_TOKEN +#define CGL_POLYGON_TOKEN GL_POLYGON_TOKEN +#define CGL_BITMAP_TOKEN GL_BITMAP_TOKEN +#define CGL_DRAW_PIXEL_TOKEN GL_DRAW_PIXEL_TOKEN +#define CGL_COPY_PIXEL_TOKEN GL_COPY_PIXEL_TOKEN +#define CGL_PASS_THROUGH_TOKEN GL_PASS_THROUGH_TOKEN +#define CGL_FEEDBACK_BUFFER_POINTER GL_FEEDBACK_BUFFER_POINTER +#define CGL_FEEDBACK_BUFFER_SIZE GL_FEEDBACK_BUFFER_SIZE +#define CGL_FEEDBACK_BUFFER_TYPE GL_FEEDBACK_BUFFER_TYPE +#define CGL_SELECTION_BUFFER_POINTER GL_SELECTION_BUFFER_POINTER +#define CGL_SELECTION_BUFFER_SIZE GL_SELECTION_BUFFER_SIZE +#define CGL_FOG GL_FOG +#define CGL_FOG_MODE GL_FOG_MODE +#define CGL_FOG_DENSITY GL_FOG_DENSITY +#define CGL_FOG_COLOR GL_FOG_COLOR +#define CGL_FOG_INDEX GL_FOG_INDEX +#define CGL_FOG_START GL_FOG_START +#define CGL_FOG_END GL_FOG_END +#define CGL_LINEAR GL_LINEAR +#define CGL_EXP GL_EXP +#define CGL_LOGIC_OP GL_LOGIC_OP +#define CGL_INDEX_LOGIC_OP GL_INDEX_LOGIC_OP +#define CGL_COLOR_LOGIC_OP GL_COLOR_LOGIC_OP +#define CGL_LOGIC_OP_MODE GL_LOGIC_OP_MODE +#define CGL_CLEAR GL_CLEAR +#define CGL_SET GL_SET +#define CGL_COPY GL_COPY +#define CGL_COPY_INVERTED GL_COPY_INVERTED +#define CGL_NOOP GL_NOOP +#define CGL_INVERT GL_INVERT +#define CGL_AND GL_AND +#define CGL_NAND GL_NAND +#define CGL_OR GL_OR +#define CGL_NOR GL_NOR +#define CGL_XOR GL_XOR +#define CGL_EQUIV GL_EQUIV +#define CGL_AND_REVERSE GL_AND_REVERSE +#define CGL_AND_INVERTED GL_AND_INVERTED +#define CGL_OR_REVERSE GL_OR_REVERSE +#define CGL_OR_INVERTED GL_OR_INVERTED +#define CGL_STENCIL_BITS GL_STENCIL_BITS +#define CGL_STENCIL_TEST GL_STENCIL_TEST +#define CGL_STENCIL_CLEAR_VALUE GL_STENCIL_CLEAR_VALUE +#define CGL_STENCIL_FUNC GL_STENCIL_FUNC +#define CGL_STENCIL_VALUE_MASK GL_STENCIL_VALUE_MASK +#define CGL_STENCIL_FAIL GL_STENCIL_FAIL +#define CGL_STENCIL_PASS_DEPTH_FAIL GL_STENCIL_PASS_DEPTH_FAIL +#define CGL_STENCIL_PASS_DEPTH_PASS GL_STENCIL_PASS_DEPTH_PASS +#define CGL_STENCIL_REF GL_STENCIL_REF +#define CGL_STENCIL_WRITEMASK GL_STENCIL_WRITEMASK +#define CGL_STENCIL_INDEX GL_STENCIL_INDEX +#define CGL_KEEP GL_KEEP +#define CGL_REPLACE GL_REPLACE +#define CGL_INCR GL_INCR +#define CGL_DECR GL_DECR +#define CGL_NONE GL_NONE +#define CGL_LEFT GL_LEFT +#define CGL_RIGHT GL_RIGHT +#define CGL_FRONT_LEFT GL_FRONT_LEFT +#define CGL_FRONT_RIGHT GL_FRONT_RIGHT +#define CGL_BACK_LEFT GL_BACK_LEFT +#define CGL_BACK_RIGHT GL_BACK_RIGHT +#define CGL_COLOR_INDEX GL_COLOR_INDEX +#define CGL_RED GL_RED +#define CGL_GREEN GL_GREEN +#define CGL_BLUE GL_BLUE +#define CGL_ALPHA GL_ALPHA +#define CGL_LUMINANCE GL_LUMINANCE +#define CGL_LUMINANCE_ALPHA GL_LUMINANCE_ALPHA +#define CGL_ALPHA_BITS GL_ALPHA_BITS +#define CGL_RED_BITS GL_RED_BITS +#define CGL_GREEN_BITS GL_GREEN_BITS +#define CGL_BLUE_BITS GL_BLUE_BITS +#define CGL_INDEX_BITS GL_INDEX_BITS +#define CGL_SUBPIXEL_BITS GL_SUBPIXEL_BITS +#define CGL_AUX_BUFFERS GL_AUX_BUFFERS +#define CGL_READ_BUFFER GL_READ_BUFFER +#define CGL_DRAW_BUFFER GL_DRAW_BUFFER +#define CGL_DOUBLEBUFFER GL_DOUBLEBUFFER +#define CGL_STEREO GL_STEREO +#define CGL_BITMAP GL_BITMAP +#define CGL_COLOR GL_COLOR +#define CGL_DEPTH GL_DEPTH +#define CGL_STENCIL GL_STENCIL +#define CGL_DITHER GL_DITHER +#define CGL_RGB GL_RGB +#define CGL_RGBA GL_RGBA +#define CGL_MAX_LIST_NESTING GL_MAX_LIST_NESTING +#define CGL_MAX_EVAL_ORDER GL_MAX_EVAL_ORDER +#define CGL_MAX_LIGHTS GL_MAX_LIGHTS +#define CGL_MAX_CLIP_PLANES GL_MAX_CLIP_PLANES +#define CGL_MAX_TEXTURE_SIZE GL_MAX_TEXTURE_SIZE +#define CGL_MAX_PIXEL_MAP_TABLE GL_MAX_PIXEL_MAP_TABLE +#define CGL_MAX_ATTRIB_STACK_DEPTH GL_MAX_ATTRIB_STACK_DEPTH +#define CGL_MAX_MODELVIEW_STACK_DEPTH GL_MAX_MODELVIEW_STACK_DEPTH +#define CGL_MAX_NAME_STACK_DEPTH GL_MAX_NAME_STACK_DEPTH +#define CGL_MAX_PROJECTION_STACK_DEPTH GL_MAX_PROJECTION_STACK_DEPTH +#define CGL_MAX_TEXTURE_STACK_DEPTH GL_MAX_TEXTURE_STACK_DEPTH +#define CGL_MAX_VIEWPORT_DIMS GL_MAX_VIEWPORT_DIMS +#define CGL_MAX_CLIENT_ATTRIB_STACK_DEPTH GL_MAX_CLIENT_ATTRIB_STACK_DEPTH +#define CGL_ATTRIB_STACK_DEPTH GL_ATTRIB_STACK_DEPTH +#define CGL_CLIENT_ATTRIB_STACK_DEPTH GL_CLIENT_ATTRIB_STACK_DEPTH +#define CGL_COLOR_CLEAR_VALUE GL_COLOR_CLEAR_VALUE +#define CGL_COLOR_WRITEMASK GL_COLOR_WRITEMASK +#define CGL_CURRENT_INDEX GL_CURRENT_INDEX +#define CGL_CURRENT_COLOR GL_CURRENT_COLOR +#define CGL_CURRENT_NORMAL GL_CURRENT_NORMAL +#define CGL_CURRENT_RASTER_COLOR GL_CURRENT_RASTER_COLOR +#define CGL_CURRENT_RASTER_DISTANCE GL_CURRENT_RASTER_DISTANCE +#define CGL_CURRENT_RASTER_INDEX GL_CURRENT_RASTER_INDEX +#define CGL_CURRENT_RASTER_POSITION GL_CURRENT_RASTER_POSITION +#define CGL_CURRENT_RASTER_TEXTURE_COORDS GL_CURRENT_RASTER_TEXTURE_COORDS +#define CGL_CURRENT_RASTER_POSITION_VALID GL_CURRENT_RASTER_POSITION_VALID +#define CGL_CURRENT_TEXTURE_COORDS GL_CURRENT_TEXTURE_COORDS +#define CGL_INDEX_CLEAR_VALUE GL_INDEX_CLEAR_VALUE +#define CGL_INDEX_MODE GL_INDEX_MODE +#define CGL_INDEX_WRITEMASK GL_INDEX_WRITEMASK +#define CGL_MODELVIEW_MATRIX GL_MODELVIEW_MATRIX +#define CGL_MODELVIEW_STACK_DEPTH GL_MODELVIEW_STACK_DEPTH +#define CGL_NAME_STACK_DEPTH GL_NAME_STACK_DEPTH +#define CGL_PROJECTION_MATRIX GL_PROJECTION_MATRIX +#define CGL_PROJECTION_STACK_DEPTH GL_PROJECTION_STACK_DEPTH +#define CGL_RENDER_MODE GL_RENDER_MODE +#define CGL_RGBA_MODE GL_RGBA_MODE +#define CGL_TEXTURE_MATRIX GL_TEXTURE_MATRIX +#define CGL_TEXTURE_STACK_DEPTH GL_TEXTURE_STACK_DEPTH +#define CGL_VIEWPORT GL_VIEWPORT +#define CGL_AUTO_NORMAL GL_AUTO_NORMAL +#define CGL_COEFF GL_COEFF +#define CGL_ORDER GL_ORDER +#define CGL_DOMAIN GL_DOMAIN +#define CGL_PERSPECTIVE_CORRECTION_HINT GL_PERSPECTIVE_CORRECTION_HINT +#define CGL_POINT_SMOOTH_HINT GL_POINT_SMOOTH_HINT +#define CGL_LINE_SMOOTH_HINT GL_LINE_SMOOTH_HINT +#define CGL_POLYGON_SMOOTH_HINT GL_POLYGON_SMOOTH_HINT +#define CGL_FOG_HINT GL_FOG_HINT +#define CGL_DONT_CARE GL_DONT_CARE +#define CGL_FASTEST GL_FASTEST +#define CGL_NICEST GL_NICEST +#define CGL_SCISSOR_BOX GL_SCISSOR_BOX +#define CGL_SCISSOR_TEST GL_SCISSOR_TEST +#define CGL_MAP_COLOR GL_MAP_COLOR +#define CGL_MAP_STENCIL GL_MAP_STENCIL +#define CGL_INDEX_SHIFT GL_INDEX_SHIFT +#define CGL_INDEX_OFFSET GL_INDEX_OFFSET +#define CGL_RED_SCALE GL_RED_SCALE +#define CGL_RED_BIAS GL_RED_BIAS +#define CGL_GREEN_SCALE GL_GREEN_SCALE +#define CGL_GREEN_BIAS GL_GREEN_BIAS +#define CGL_BLUE_SCALE GL_BLUE_SCALE +#define CGL_BLUE_BIAS GL_BLUE_BIAS +#define CGL_ALPHA_SCALE GL_ALPHA_SCALE +#define CGL_ALPHA_BIAS GL_ALPHA_BIAS +#define CGL_DEPTH_SCALE GL_DEPTH_SCALE +#define CGL_DEPTH_BIAS GL_DEPTH_BIAS +#define CGL_PIXEL_MAP_S_TO_S_SIZE GL_PIXEL_MAP_S_TO_S_SIZE +#define CGL_PIXEL_MAP_I_TO_I_SIZE GL_PIXEL_MAP_I_TO_I_SIZE +#define CGL_PIXEL_MAP_I_TO_R_SIZE GL_PIXEL_MAP_I_TO_R_SIZE +#define CGL_PIXEL_MAP_I_TO_G_SIZE GL_PIXEL_MAP_I_TO_G_SIZE +#define CGL_PIXEL_MAP_I_TO_B_SIZE GL_PIXEL_MAP_I_TO_B_SIZE +#define CGL_PIXEL_MAP_I_TO_A_SIZE GL_PIXEL_MAP_I_TO_A_SIZE +#define CGL_PIXEL_MAP_R_TO_R_SIZE GL_PIXEL_MAP_R_TO_R_SIZE +#define CGL_PIXEL_MAP_G_TO_G_SIZE GL_PIXEL_MAP_G_TO_G_SIZE +#define CGL_PIXEL_MAP_B_TO_B_SIZE GL_PIXEL_MAP_B_TO_B_SIZE +#define CGL_PIXEL_MAP_A_TO_A_SIZE GL_PIXEL_MAP_A_TO_A_SIZE +#define CGL_PIXEL_MAP_S_TO_S GL_PIXEL_MAP_S_TO_S +#define CGL_PIXEL_MAP_I_TO_I GL_PIXEL_MAP_I_TO_I +#define CGL_PIXEL_MAP_I_TO_R GL_PIXEL_MAP_I_TO_R +#define CGL_PIXEL_MAP_I_TO_G GL_PIXEL_MAP_I_TO_G +#define CGL_PIXEL_MAP_I_TO_B GL_PIXEL_MAP_I_TO_B +#define CGL_PIXEL_MAP_I_TO_A GL_PIXEL_MAP_I_TO_A +#define CGL_PIXEL_MAP_R_TO_R GL_PIXEL_MAP_R_TO_R +#define CGL_PIXEL_MAP_G_TO_G GL_PIXEL_MAP_G_TO_G +#define CGL_PIXEL_MAP_B_TO_B GL_PIXEL_MAP_B_TO_B +#define CGL_PIXEL_MAP_A_TO_A GL_PIXEL_MAP_A_TO_A +#define CGL_PACK_ALIGNMENT GL_PACK_ALIGNMENT +#define CGL_PACK_LSB_FIRST GL_PACK_LSB_FIRST +#define CGL_PACK_ROW_LENGTH GL_PACK_ROW_LENGTH +#define CGL_PACK_SKIP_PIXELS GL_PACK_SKIP_PIXELS +#define CGL_PACK_SKIP_ROWS GL_PACK_SKIP_ROWS +#define CGL_PACK_SWAP_BYTES GL_PACK_SWAP_BYTES +#define CGL_UNPACK_ALIGNMENT GL_UNPACK_ALIGNMENT +#define CGL_UNPACK_LSB_FIRST GL_UNPACK_LSB_FIRST +#define CGL_UNPACK_ROW_LENGTH GL_UNPACK_ROW_LENGTH +#define CGL_UNPACK_SKIP_PIXELS GL_UNPACK_SKIP_PIXELS +#define CGL_UNPACK_SKIP_ROWS GL_UNPACK_SKIP_ROWS +#define CGL_UNPACK_SWAP_BYTES GL_UNPACK_SWAP_BYTES +#define CGL_ZOOM_X GL_ZOOM_X +#define CGL_ZOOM_Y GL_ZOOM_Y +#define CGL_TEXTURE_ENV GL_TEXTURE_ENV +#define CGL_TEXTURE_ENV_MODE GL_TEXTURE_ENV_MODE +#define CGL_TEXTURE_WRAP_S GL_TEXTURE_WRAP_S +#define CGL_TEXTURE_WRAP_T GL_TEXTURE_WRAP_T +#define CGL_TEXTURE_MAG_FILTER GL_TEXTURE_MAG_FILTER +#define CGL_TEXTURE_MIN_FILTER GL_TEXTURE_MIN_FILTER +#define CGL_TEXTURE_ENV_COLOR GL_TEXTURE_ENV_COLOR +#define CGL_TEXTURE_GEN_S GL_TEXTURE_GEN_S +#define CGL_TEXTURE_GEN_T GL_TEXTURE_GEN_T +#define CGL_TEXTURE_GEN_MODE GL_TEXTURE_GEN_MODE +#define CGL_TEXTURE_BORDER_COLOR GL_TEXTURE_BORDER_COLOR +#define CGL_TEXTURE_WIDTH GL_TEXTURE_WIDTH +#define CGL_TEXTURE_HEIGHT GL_TEXTURE_HEIGHT +#define CGL_TEXTURE_BORDER GL_TEXTURE_BORDER +#define CGL_TEXTURE_COMPONENTS GL_TEXTURE_COMPONENTS +#define CGL_TEXTURE_RED_SIZE GL_TEXTURE_RED_SIZE +#define CGL_TEXTURE_GREEN_SIZE GL_TEXTURE_GREEN_SIZE +#define CGL_TEXTURE_BLUE_SIZE GL_TEXTURE_BLUE_SIZE +#define CGL_TEXTURE_ALPHA_SIZE GL_TEXTURE_ALPHA_SIZE +#define CGL_TEXTURE_LUMINANCE_SIZE GL_TEXTURE_LUMINANCE_SIZE +#define CGL_TEXTURE_INTENSITY_SIZE GL_TEXTURE_INTENSITY_SIZE +#define CGL_NEAREST_MIPMAP_NEAREST GL_NEAREST_MIPMAP_NEAREST +#define CGL_NEAREST_MIPMAP_LINEAR GL_NEAREST_MIPMAP_LINEAR +#define CGL_LINEAR_MIPMAP_NEAREST GL_LINEAR_MIPMAP_NEAREST +#define CGL_LINEAR_MIPMAP_LINEAR GL_LINEAR_MIPMAP_LINEAR +#define CGL_OBJECT_LINEAR GL_OBJECT_LINEAR +#define CGL_OBJECT_PLANE GL_OBJECT_PLANE +#define CGL_EYE_LINEAR GL_EYE_LINEAR +#define CGL_EYE_PLANE GL_EYE_PLANE +#define CGL_SPHERE_MAP GL_SPHERE_MAP +#define CGL_DECAL GL_DECAL +#define CGL_MODULATE GL_MODULATE +#define CGL_NEAREST GL_NEAREST +#define CGL_REPEAT GL_REPEAT +#define CGL_CLAMP GL_CLAMP +#define CGL_S GL_S +#define CGL_T GL_T +#define CGL_R GL_R +#define CGL_Q GL_Q +#define CGL_TEXTURE_GEN_R GL_TEXTURE_GEN_R +#define CGL_TEXTURE_GEN_Q GL_TEXTURE_GEN_Q +#define CGL_VENDOR GL_VENDOR +#define CGL_RENDERER GL_RENDERER +#define CGL_VERSION GL_VERSION +#define CGL_EXTENSIONS GL_EXTENSIONS +#define CGL_NO_ERROR GL_NO_ERROR +#define CGL_INVALID_ENUM GL_INVALID_ENUM +#define CGL_INVALID_VALUE GL_INVALID_VALUE +#define CGL_INVALID_OPERATION GL_INVALID_OPERATION +#define CGL_STACK_OVERFLOW GL_STACK_OVERFLOW +#define CGL_STACK_UNDERFLOW GL_STACK_UNDERFLOW +#define CGL_OUT_OF_MEMORY GL_OUT_OF_MEMORY +#define CGL_CURRENT_BIT GL_CURRENT_BIT +#define CGL_POINT_BIT GL_POINT_BIT +#define CGL_LINE_BIT GL_LINE_BIT +#define CGL_POLYGON_BIT GL_POLYGON_BIT +#define CGL_POLYGON_STIPPLE_BIT GL_POLYGON_STIPPLE_BIT +#define CGL_PIXEL_MODE_BIT GL_PIXEL_MODE_BIT +#define CGL_LIGHTING_BIT GL_LIGHTING_BIT +#define CGL_FOG_BIT GL_FOG_BIT +#define CGL_DEPTH_BUFFER_BIT GL_DEPTH_BUFFER_BIT +#define CGL_ACCUM_BUFFER_BIT GL_ACCUM_BUFFER_BIT +#define CGL_STENCIL_BUFFER_BIT GL_STENCIL_BUFFER_BIT +#define CGL_VIEWPORT_BIT GL_VIEWPORT_BIT +#define CGL_TRANSFORM_BIT GL_TRANSFORM_BIT +#define CGL_ENABLE_BIT GL_ENABLE_BIT +#define CGL_COLOR_BUFFER_BIT GL_COLOR_BUFFER_BIT +#define CGL_HINT_BIT GL_HINT_BIT +#define CGL_EVAL_BIT GL_EVAL_BIT +#define CGL_LIST_BIT GL_LIST_BIT +#define CGL_TEXTURE_BIT GL_TEXTURE_BIT +#define CGL_SCISSOR_BIT GL_SCISSOR_BIT +#define CGL_ALL_ATTRIB_BITS GL_ALL_ATTRIB_BITS +#define CGL_TEXTURE_PRIORITY GL_TEXTURE_PRIORITY +#define CGL_TEXTURE_RESIDENT GL_TEXTURE_RESIDENT +#define CGL_TEXTURE_INTERNAL_FORMAT GL_TEXTURE_INTERNAL_FORMAT +#define CGL_INTENSITY GL_INTENSITY +#define CGL_CLIENT_PIXEL_STORE_BIT GL_CLIENT_PIXEL_STORE_BIT +#define CGL_CLIENT_VERTEX_ARRAY_BIT GL_CLIENT_VERTEX_ARRAY_BIT +#define CGL_ALL_CLIENT_ATTRIB_BITS GL_ALL_CLIENT_ATTRIB_BITS +#define CGL_CLIENT_ALL_ATTRIB_BITS GL_CLIENT_ALL_ATTRIB_BITS +#define CGL_RESCALE_NORMAL GL_RESCALE_NORMAL +#define CGL_CLAMP_TO_EDGE GL_CLAMP_TO_EDGE +#define CGL_MAX_ELEMENTS_VERTICES GL_MAX_ELEMENTS_VERTICES +#define CGL_MAX_ELEMENTS_INDICES GL_MAX_ELEMENTS_INDICES +#define CGL_BGR GL_BGR +#define CGL_BGRA GL_BGRA +#define CGL_LIGHT_MODEL_COLOR_CONTROL GL_LIGHT_MODEL_COLOR_CONTROL +#define CGL_SINGLE_COLOR GL_SINGLE_COLOR +#define CGL_SEPARATE_SPECULAR_COLOR GL_SEPARATE_SPECULAR_COLOR +#define CGL_TEXTURE_MIN_LOD GL_TEXTURE_MIN_LOD +#define CGL_TEXTURE_MAX_LOD GL_TEXTURE_MAX_LOD +#define CGL_TEXTURE_BASE_LEVEL GL_TEXTURE_BASE_LEVEL +#define CGL_TEXTURE_MAX_LEVEL GL_TEXTURE_MAX_LEVEL +#define CGL_SMOOTH_POINT_SIZE_RANGE GL_SMOOTH_POINT_SIZE_RANGE +#define CGL_SMOOTH_POINT_SIZE_GRANULARITY GL_SMOOTH_POINT_SIZE_GRANULARITY +#define CGL_SMOOTH_LINE_WIDTH_RANGE GL_SMOOTH_LINE_WIDTH_RANGE +#define CGL_SMOOTH_LINE_WIDTH_GRANULARITY GL_SMOOTH_LINE_WIDTH_GRANULARITY +#define CGL_ALIASED_POINT_SIZE_RANGE GL_ALIASED_POINT_SIZE_RANGE +#define CGL_ALIASED_LINE_WIDTH_RANGE GL_ALIASED_LINE_WIDTH_RANGE +#define CGL_PACK_SKIP_IMAGES GL_PACK_SKIP_IMAGES +#define CGL_PACK_IMAGE_HEIGHT GL_PACK_IMAGE_HEIGHT +#define CGL_UNPACK_SKIP_IMAGES GL_UNPACK_SKIP_IMAGES +#define CGL_UNPACK_IMAGE_HEIGHT GL_UNPACK_IMAGE_HEIGHT +#define CGL_TEXTURE_DEPTH GL_TEXTURE_DEPTH +#define CGL_TEXTURE_WRAP_R GL_TEXTURE_WRAP_R +#define CGL_CONSTANT_COLOR GL_CONSTANT_COLOR +#define CGL_ONE_MINUS_CONSTANT_COLOR GL_ONE_MINUS_CONSTANT_COLOR +#define CGL_CONSTANT_ALPHA GL_CONSTANT_ALPHA +#define CGL_ONE_MINUS_CONSTANT_ALPHA GL_ONE_MINUS_CONSTANT_ALPHA +#define CGL_COLOR_TABLE GL_COLOR_TABLE +#define CGL_POST_CONVOLUTION_COLOR_TABLE GL_POST_CONVOLUTION_COLOR_TABLE +#define CGL_POST_COLOR_MATRIX_COLOR_TABLE GL_POST_COLOR_MATRIX_COLOR_TABLE +#define CGL_PROXY_COLOR_TABLE GL_PROXY_COLOR_TABLE +#define CGL_PROXY_POST_CONVOLUTION_COLOR_TABLE GL_PROXY_POST_CONVOLUTION_COLOR_TABLE +#define CGL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE +#define CGL_COLOR_TABLE_SCALE GL_COLOR_TABLE_SCALE +#define CGL_COLOR_TABLE_BIAS GL_COLOR_TABLE_BIAS +#define CGL_COLOR_TABLE_FORMAT GL_COLOR_TABLE_FORMAT +#define CGL_COLOR_TABLE_WIDTH GL_COLOR_TABLE_WIDTH +#define CGL_COLOR_TABLE_RED_SIZE GL_COLOR_TABLE_RED_SIZE +#define CGL_COLOR_TABLE_GREEN_SIZE GL_COLOR_TABLE_GREEN_SIZE +#define CGL_COLOR_TABLE_BLUE_SIZE GL_COLOR_TABLE_BLUE_SIZE +#define CGL_COLOR_TABLE_ALPHA_SIZE GL_COLOR_TABLE_ALPHA_SIZE +#define CGL_COLOR_TABLE_LUMINANCE_SIZE GL_COLOR_TABLE_LUMINANCE_SIZE +#define CGL_COLOR_TABLE_INTENSITY_SIZE GL_COLOR_TABLE_INTENSITY_SIZE +#define CGL_CONVOLUTION_BORDER_MODE GL_CONVOLUTION_BORDER_MODE +#define CGL_CONVOLUTION_FILTER_SCALE GL_CONVOLUTION_FILTER_SCALE +#define CGL_CONVOLUTION_FILTER_BIAS GL_CONVOLUTION_FILTER_BIAS +#define CGL_REDUCE GL_REDUCE +#define CGL_CONVOLUTION_FORMAT GL_CONVOLUTION_FORMAT +#define CGL_CONVOLUTION_WIDTH GL_CONVOLUTION_WIDTH +#define CGL_CONVOLUTION_HEIGHT GL_CONVOLUTION_HEIGHT +#define CGL_MAX_CONVOLUTION_WIDTH GL_MAX_CONVOLUTION_WIDTH +#define CGL_MAX_CONVOLUTION_HEIGHT GL_MAX_CONVOLUTION_HEIGHT +#define CGL_POST_CONVOLUTION_RED_SCALE GL_POST_CONVOLUTION_RED_SCALE +#define CGL_POST_CONVOLUTION_GREEN_SCALE GL_POST_CONVOLUTION_GREEN_SCALE +#define CGL_POST_CONVOLUTION_BLUE_SCALE GL_POST_CONVOLUTION_BLUE_SCALE +#define CGL_POST_CONVOLUTION_ALPHA_SCALE GL_POST_CONVOLUTION_ALPHA_SCALE +#define CGL_POST_CONVOLUTION_RED_BIAS GL_POST_CONVOLUTION_RED_BIAS +#define CGL_POST_CONVOLUTION_GREEN_BIAS GL_POST_CONVOLUTION_GREEN_BIAS +#define CGL_POST_CONVOLUTION_BLUE_BIAS GL_POST_CONVOLUTION_BLUE_BIAS +#define CGL_POST_CONVOLUTION_ALPHA_BIAS GL_POST_CONVOLUTION_ALPHA_BIAS +#define CGL_CONSTANT_BORDER GL_CONSTANT_BORDER +#define CGL_REPLICATE_BORDER GL_REPLICATE_BORDER +#define CGL_CONVOLUTION_BORDER_COLOR GL_CONVOLUTION_BORDER_COLOR +#define CGL_COLOR_MATRIX GL_COLOR_MATRIX +#define CGL_COLOR_MATRIX_STACK_DEPTH GL_COLOR_MATRIX_STACK_DEPTH +#define CGL_MAX_COLOR_MATRIX_STACK_DEPTH GL_MAX_COLOR_MATRIX_STACK_DEPTH +#define CGL_POST_COLOR_MATRIX_RED_SCALE GL_POST_COLOR_MATRIX_RED_SCALE +#define CGL_POST_COLOR_MATRIX_GREEN_SCALE GL_POST_COLOR_MATRIX_GREEN_SCALE +#define CGL_POST_COLOR_MATRIX_BLUE_SCALE GL_POST_COLOR_MATRIX_BLUE_SCALE +#define CGL_POST_COLOR_MATRIX_ALPHA_SCALE GL_POST_COLOR_MATRIX_ALPHA_SCALE +#define CGL_POST_COLOR_MATRIX_RED_BIAS GL_POST_COLOR_MATRIX_RED_BIAS +#define CGL_POST_COLOR_MATRIX_GREEN_BIAS GL_POST_COLOR_MATRIX_GREEN_BIAS +#define CGL_POST_COLOR_MATRIX_BLUE_BIAS GL_POST_COLOR_MATRIX_BLUE_BIAS +#define CGL_POST_COLOR_MATRIX_ALPHA_BIAS GL_POST_COLOR_MATRIX_ALPHA_BIAS +#define CGL_HISTOGRAM GL_HISTOGRAM +#define CGL_PROXY_HISTOGRAM GL_PROXY_HISTOGRAM +#define CGL_HISTOGRAM_WIDTH GL_HISTOGRAM_WIDTH +#define CGL_HISTOGRAM_FORMAT GL_HISTOGRAM_FORMAT +#define CGL_HISTOGRAM_RED_SIZE GL_HISTOGRAM_RED_SIZE +#define CGL_HISTOGRAM_GREEN_SIZE GL_HISTOGRAM_GREEN_SIZE +#define CGL_HISTOGRAM_BLUE_SIZE GL_HISTOGRAM_BLUE_SIZE +#define CGL_HISTOGRAM_ALPHA_SIZE GL_HISTOGRAM_ALPHA_SIZE +#define CGL_HISTOGRAM_LUMINANCE_SIZE GL_HISTOGRAM_LUMINANCE_SIZE +#define CGL_HISTOGRAM_SINK GL_HISTOGRAM_SINK +#define CGL_MINMAX GL_MINMAX +#define CGL_MINMAX_FORMAT GL_MINMAX_FORMAT +#define CGL_MINMAX_SINK GL_MINMAX_SINK +#define CGL_TABLE_TOO_LARGE GL_TABLE_TOO_LARGE +#define CGL_BLEND_EQUATION GL_BLEND_EQUATION +#define CGL_MIN GL_MIN +#define CGL_MAX GL_MAX +#define CGL_FUNC_ADD GL_FUNC_ADD +#define CGL_FUNC_SUBTRACT GL_FUNC_SUBTRACT +#define CGL_FUNC_REVERSE_SUBTRACT GL_FUNC_REVERSE_SUBTRACT +#define CGL_BLEND_COLOR GL_BLEND_COLOR +#define CGL_ACTIVE_TEXTURE GL_ACTIVE_TEXTURE +#define CGL_CLIENT_ACTIVE_TEXTURE GL_CLIENT_ACTIVE_TEXTURE +#define CGL_MAX_TEXTURE_UNITS GL_MAX_TEXTURE_UNITS +#define CGL_NORMAL_MAP GL_NORMAL_MAP +#define CGL_REFLECTION_MAP GL_REFLECTION_MAP +#define CGL_TEXTURE_CUBE_MAP GL_TEXTURE_CUBE_MAP +#define CGL_TEXTURE_BINDING_CUBE_MAP GL_TEXTURE_BINDING_CUBE_MAP +#define CGL_TEXTURE_CUBE_MAP_POSITIVE_X GL_TEXTURE_CUBE_MAP_POSITIVE_X +#define CGL_TEXTURE_CUBE_MAP_NEGATIVE_X GL_TEXTURE_CUBE_MAP_NEGATIVE_X +#define CGL_TEXTURE_CUBE_MAP_POSITIVE_Y GL_TEXTURE_CUBE_MAP_POSITIVE_Y +#define CGL_TEXTURE_CUBE_MAP_NEGATIVE_Y GL_TEXTURE_CUBE_MAP_NEGATIVE_Y +#define CGL_TEXTURE_CUBE_MAP_POSITIVE_Z GL_TEXTURE_CUBE_MAP_POSITIVE_Z +#define CGL_TEXTURE_CUBE_MAP_NEGATIVE_Z GL_TEXTURE_CUBE_MAP_NEGATIVE_Z +#define CGL_PROXY_TEXTURE_CUBE_MAP GL_PROXY_TEXTURE_CUBE_MAP +#define CGL_MAX_CUBE_MAP_TEXTURE_SIZE GL_MAX_CUBE_MAP_TEXTURE_SIZE +#define CGL_COMPRESSED_ALPHA GL_COMPRESSED_ALPHA +#define CGL_COMPRESSED_LUMINANCE GL_COMPRESSED_LUMINANCE +#define CGL_COMPRESSED_LUMINANCE_ALPHA GL_COMPRESSED_LUMINANCE_ALPHA +#define CGL_COMPRESSED_INTENSITY GL_COMPRESSED_INTENSITY +#define CGL_COMPRESSED_RGB GL_COMPRESSED_RGB +#define CGL_COMPRESSED_RGBA GL_COMPRESSED_RGBA +#define CGL_TEXTURE_COMPRESSION_HINT GL_TEXTURE_COMPRESSION_HINT +#define CGL_TEXTURE_COMPRESSED_IMAGE_SIZE GL_TEXTURE_COMPRESSED_IMAGE_SIZE +#define CGL_TEXTURE_COMPRESSED GL_TEXTURE_COMPRESSED +#define CGL_NUM_COMPRESSED_TEXTURE_FORMATS GL_NUM_COMPRESSED_TEXTURE_FORMATS +#define CGL_COMPRESSED_TEXTURE_FORMATS GL_COMPRESSED_TEXTURE_FORMATS +#define CGL_MULTISAMPLE GL_MULTISAMPLE +#define CGL_SAMPLE_ALPHA_TO_COVERAGE GL_SAMPLE_ALPHA_TO_COVERAGE +#define CGL_SAMPLE_ALPHA_TO_ONE GL_SAMPLE_ALPHA_TO_ONE +#define CGL_SAMPLE_COVERAGE GL_SAMPLE_COVERAGE +#define CGL_SAMPLE_BUFFERS GL_SAMPLE_BUFFERS +#define CGL_SAMPLES GL_SAMPLES +#define CGL_SAMPLE_COVERAGE_VALUE GL_SAMPLE_COVERAGE_VALUE +#define CGL_SAMPLE_COVERAGE_INVERT GL_SAMPLE_COVERAGE_INVERT +#define CGL_MULTISAMPLE_BIT GL_MULTISAMPLE_BIT +#define CGL_TRANSPOSE_MODELVIEW_MATRIX GL_TRANSPOSE_MODELVIEW_MATRIX +#define CGL_TRANSPOSE_PROJECTION_MATRIX GL_TRANSPOSE_PROJECTION_MATRIX +#define CGL_TRANSPOSE_TEXTURE_MATRIX GL_TRANSPOSE_TEXTURE_MATRIX +#define CGL_TRANSPOSE_COLOR_MATRIX GL_TRANSPOSE_COLOR_MATRIX +#define CGL_COMBINE GL_COMBINE +#define CGL_COMBINE_RGB GL_COMBINE_RGB +#define CGL_COMBINE_ALPHA GL_COMBINE_ALPHA +#define CGL_RGB_SCALE GL_RGB_SCALE +#define CGL_ADD_SIGNED GL_ADD_SIGNED +#define CGL_INTERPOLATE GL_INTERPOLATE +#define CGL_SUBTRACT GL_SUBTRACT +#define CGL_CONSTANT GL_CONSTANT +#define CGL_PRIMARY_COLOR GL_PRIMARY_COLOR +#define CGL_PREVIOUS GL_PREVIOUS +#define CGL_CLAMP_TO_BORDER GL_CLAMP_TO_BORDER +#define CGL_ACTIVE_TEXTURE_ARB GL_ACTIVE_TEXTURE_ARB +#define CGL_CLIENT_ACTIVE_TEXTURE_ARB GL_CLIENT_ACTIVE_TEXTURE_ARB +#define CGL_MAX_TEXTURE_UNITS_ARB GL_MAX_TEXTURE_UNITS_ARB +#define CGL_DEBUG_OBJECT_MESA GL_DEBUG_OBJECT_MESA +#define CGL_DEBUG_PRINT_MESA GL_DEBUG_PRINT_MESA +#define CGL_DEBUG_ASSERT_MESA GL_DEBUG_ASSERT_MESA +#define CGL_TRACE_ALL_BITS_MESA GL_TRACE_ALL_BITS_MESA +#define CGL_TRACE_OPERATIONS_BIT_MESA GL_TRACE_OPERATIONS_BIT_MESA +#define CGL_TRACE_PRIMITIVES_BIT_MESA GL_TRACE_PRIMITIVES_BIT_MESA +#define CGL_TRACE_ARRAYS_BIT_MESA GL_TRACE_ARRAYS_BIT_MESA +#define CGL_TRACE_TEXTURES_BIT_MESA GL_TRACE_TEXTURES_BIT_MESA +#define CGL_TRACE_PIXELS_BIT_MESA GL_TRACE_PIXELS_BIT_MESA +#define CGL_TRACE_ERRORS_BIT_MESA GL_TRACE_ERRORS_BIT_MESA +#define CGL_TRACE_MASK_MESA GL_TRACE_MASK_MESA +#define CGL_TRACE_NAME_MESA GL_TRACE_NAME_MESA +#define CGL_DEPTH_STENCIL_MESA GL_DEPTH_STENCIL_MESA +#define CGL_FRAGMENT_PROGRAM_POSITION_MESA GL_FRAGMENT_PROGRAM_POSITION_MESA +#define CGL_FRAGMENT_PROGRAM_CALLBACK_MESA GL_FRAGMENT_PROGRAM_CALLBACK_MESA +#define CGL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA +#define CGL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA +#define CGL_VERTEX_PROGRAM_POSITION_MESA GL_VERTEX_PROGRAM_POSITION_MESA +#define CGL_VERTEX_PROGRAM_CALLBACK_MESA GL_VERTEX_PROGRAM_CALLBACK_MESA +#define CGL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA +#define CGL_VERTEX_PROGRAM_CALLBACK_DATA_MESA GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA +#define CGL_ALPHA_BLEND_EQUATION_ATI GL_ALPHA_BLEND_EQUATION_ATI +#define CGL_TIME_ELAPSED_EXT GL_TIME_ELAPSED_EXT +#define CGL_READ_FRAMEBUFFER_EXT GL_READ_FRAMEBUFFER_EXT +#define CGL_DRAW_FRAMEBUFFER_EXT GL_DRAW_FRAMEBUFFER_EXT +#define CGL_DRAW_FRAMEBUFFER_BINDING_EXT GL_DRAW_FRAMEBUFFER_BINDING_EXT +#define CGL_READ_FRAMEBUFFER_BINDING_EXT GL_READ_FRAMEBUFFER_BINDING_EXT +#define CGL_DEPTH_STENCIL_EXT GL_DEPTH_STENCIL_EXT +#define CGL_TEXTURE_STENCIL_SIZE_EXT GL_TEXTURE_STENCIL_SIZE_EXT +#define CGL_SRGB_EXT GL_SRGB_EXT +#define CGL_SRGB_ALPHA_EXT GL_SRGB_ALPHA_EXT +#define CGL_SLUMINANCE_ALPHA_EXT GL_SLUMINANCE_ALPHA_EXT +#define CGL_SLUMINANCE_EXT GL_SLUMINANCE_EXT +#define CGL_COMPRESSED_SRGB_EXT GL_COMPRESSED_SRGB_EXT +#define CGL_COMPRESSED_SRGB_ALPHA_EXT GL_COMPRESSED_SRGB_ALPHA_EXT +#define CGL_COMPRESSED_SLUMINANCE_EXT GL_COMPRESSED_SLUMINANCE_EXT +#define CGL_COMPRESSED_SLUMINANCE_ALPHA_EXT GL_COMPRESSED_SLUMINANCE_ALPHA_EXT + +/* extras */ + +#define CGL_TEXTURE_2D GL_TEXTURE_2D +#define CGL_ARGB GL_ARGB +#define CGL_TEXTURE_RECTANGLE_ARB GL_TEXTURE_RECTANGLE_ARB + +G_END_DECLS + +#endif diff --git a/gl/cogl.c b/gl/cogl.c index 1f23e922d..abaa6b8dc 100644 --- a/gl/cogl.c +++ b/gl/cogl.c @@ -23,8 +23,67 @@ * Boston, MA 02111-1307, USA. */ +#include "config.h" #include "cogl.h" + #include +#include + +#if G_BYTE_ORDER == G_LITTLE_ENDIAN +#define PIXEL_TYPE GL_UNSIGNED_BYTE +#else +#define PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV +#endif + +static gulong __enable_flags = 0; + +#if COGL_DEBUG +struct token_string +{ + GLuint Token; + const char *String; +}; + +static const struct token_string Errors[] = { + { GL_NO_ERROR, "no error" }, + { GL_INVALID_ENUM, "invalid enumerant" }, + { GL_INVALID_VALUE, "invalid value" }, + { GL_INVALID_OPERATION, "invalid operation" }, + { GL_STACK_OVERFLOW, "stack overflow" }, + { GL_STACK_UNDERFLOW, "stack underflow" }, + { GL_OUT_OF_MEMORY, "out of memory" }, +#ifdef GL_INVALID_FRAMEBUFFER_OPERATION_EXT + { GL_INVALID_FRAMEBUFFER_OPERATION_EXT, "invalid framebuffer operation" }, +#endif + { ~0, NULL } +}; + +static const char* +error_string(GLenum errorCode) +{ + int i; + for (i = 0; Errors[i].String; i++) { + if (Errors[i].Token == errorCode) + return Errors[i].String; + } + return "unknown"; +} +#endif + +#if COGL_DEBUG +#define GE(x...) G_STMT_START { \ + GLenum err; \ + (x); \ + while ((err = glGetError()) != GL_NO_ERROR) { \ + fprintf(stderr, "glError: %s caught at %s:%u\n", \ + (char *)error_string(err), \ + __FILE__, __LINE__); \ + } \ +} G_STMT_END +#else +#define GE(x) (x); +#endif + CoglFuncPtr cogl_get_proc_address (const gchar* name) @@ -41,14 +100,18 @@ cogl_check_extension (const gchar *name, const gchar *ext) void cogl_paint_init (ClutterColor *color) { - glClearColor (((float) color->red / 0xff * 1.0), - ((float) color->green / 0xff * 1.0), - ((float) color->blue / 0xff * 1.0), - 0.0); + GE( glClearColor (((float) color->red / 0xff * 1.0), + ((float) color->green / 0xff * 1.0), + ((float) color->blue / 0xff * 1.0), + 0.0) ); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glDisable (GL_LIGHTING); glDisable (GL_DEPTH_TEST); + + cogl_enable (CGL_ENABLE_BLEND); + + glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } /* FIXME: inline most of these */ @@ -65,7 +128,7 @@ cogl_pop_matrix (void) } void -cogl_scaled (ClutterFixed x, ClutterFixed y) +cogl_scale (ClutterFixed x, ClutterFixed y) { glScaled (CLUTTER_FIXED_TO_DOUBLE (x), CLUTTER_FIXED_TO_DOUBLE (y), @@ -100,3 +163,367 @@ cogl_rotate (gint angle, gint x, gint y, gint z) { glRotatef ((float)angle, (float)x, (float)y, (float)z); } + +void +cogl_enable (gulong flags) +{ + /* This function essentially caches glEnable state() in the + * hope of lessening number GL traffic. + */ + if (flags & CGL_ENABLE_BLEND) + { + if (!(__enable_flags & CGL_ENABLE_BLEND)) + { + glEnable (GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + } + __enable_flags |= CGL_ENABLE_BLEND; + } + else if (__enable_flags & CGL_ENABLE_BLEND) + { + glDisable (GL_BLEND); + __enable_flags &= ~CGL_ENABLE_BLEND; + } + + if (flags & CGL_ENABLE_TEXTURE_2D) + { + if (!(__enable_flags & CGL_ENABLE_TEXTURE_2D)) + glEnable (GL_TEXTURE_2D); + __enable_flags |= CGL_ENABLE_TEXTURE_2D; + } + else if (__enable_flags & CGL_ENABLE_TEXTURE_2D) + { + glDisable (GL_TEXTURE_2D); + __enable_flags &= ~CGL_ENABLE_TEXTURE_2D; + } + + if (flags & CGL_ENABLE_TEXTURE_RECT) + { + if (!(__enable_flags & CGL_ENABLE_TEXTURE_RECT)) + glEnable (GL_TEXTURE_RECTANGLE_ARB); + + __enable_flags |= CGL_ENABLE_TEXTURE_RECT; + } + else if (__enable_flags & CGL_ENABLE_TEXTURE_RECT) + { + glDisable (GL_TEXTURE_RECTANGLE_ARB); + __enable_flags &= ~CGL_ENABLE_TEXTURE_RECT; + } + + if (flags & CGL_ENABLE_ALPHA_TEST) + { + if (!(__enable_flags & CGL_ENABLE_ALPHA_TEST)) + glEnable (GL_ALPHA_TEST); + + __enable_flags |= CGL_ENABLE_ALPHA_TEST; + } + else if (__enable_flags & CGL_ENABLE_ALPHA_TEST) + { + glDisable (GL_ALPHA_TEST); + __enable_flags &= ~CGL_ENABLE_ALPHA_TEST; + } +} + +void +cogl_color (ClutterColor *color) +{ + glColor4ub (color->red, color->green, color->blue, color->alpha); +} + +gboolean +cogl_texture_can_size (COGLenum pixel_format, + COGLenum pixel_type, + int width, + int height) +{ + GLint new_width = 0; + + GE( glTexImage2D (GL_PROXY_TEXTURE_2D, 0, GL_RGBA, + width, height, 0 /* border */, + pixel_format, pixel_type, NULL) ); + + GE( glGetTexLevelParameteriv (GL_PROXY_TEXTURE_2D, 0, + GL_TEXTURE_WIDTH, &new_width) ); + + return new_width != 0; +} + +void +cogl_texture_quad (gint x1, + gint x2, + gint y1, + gint y2, + ClutterFixed tx1, + ClutterFixed ty1, + ClutterFixed tx2, + ClutterFixed ty2) +{ + gdouble txf1, tyf1, txf2, tyf2; + + txf1 = CLUTTER_FIXED_TO_DOUBLE (tx1); + tyf1 = CLUTTER_FIXED_TO_DOUBLE (ty1); + txf2 = CLUTTER_FIXED_TO_DOUBLE (tx2); + tyf2 = CLUTTER_FIXED_TO_DOUBLE (ty2); + + glBegin (GL_QUADS); + glTexCoord2f (txf2, tyf2); glVertex2i (x2, y2); + glTexCoord2f (txf1, tyf2); glVertex2i (x1, y2); + glTexCoord2f (txf1, tyf1); glVertex2i (x1, y1); + glTexCoord2f (txf2, tyf1); glVertex2i (x2, y1); + glEnd (); +} + +void +cogl_textures_create (guint num, guint *textures) +{ + GE( glGenTextures (num, textures) ); +} + +void +cogl_textures_destroy (guint num, const guint *textures) +{ + GE( glDeleteTextures (num, textures) ); +} + +void +cogl_texture_bind (COGLenum target, guint texture) +{ + GE( glBindTexture (target, texture) ); +} + +void +cogl_texture_set_alignment (COGLenum target, + guint alignment, + guint row_length) +{ + GE( glPixelStorei (GL_UNPACK_ROW_LENGTH, row_length) ); + GE( glPixelStorei (GL_UNPACK_ALIGNMENT, alignment) ); +} + +void +cogl_texture_set_filters (COGLenum target, + COGLenum min_filter, + COGLenum max_filter) +{ + GE( glTexParameteri(target, GL_TEXTURE_MAG_FILTER, max_filter) ); + GE( glTexParameteri(target, GL_TEXTURE_MIN_FILTER, min_filter) ); +} + +void +cogl_texture_set_wrap (COGLenum target, + COGLenum wrap_s, + COGLenum wrap_t) +{ + GE( glTexParameteri(target, GL_TEXTURE_WRAP_S, wrap_s) ); + GE( glTexParameteri(target, GL_TEXTURE_WRAP_T, wrap_s) ); +} + +void +cogl_texture_image_2d (COGLenum target, + COGLint internal_format, + gint width, + gint height, + COGLenum format, + COGLenum type, + const guchar* pixels) +{ + GE( glTexImage2D (target, + 0, /* No mipmap support as yet */ + internal_format, + width, + height, + 0, /* 0 pixel border */ + format, + type, + pixels) ); +} + +void +cogl_texture_sub_image_2d (COGLenum target, + gint xoff, + gint yoff, + gint width, + gint height, + COGLenum format, + COGLenum type, + const guchar* pixels) +{ + GE( glTexSubImage2D (target, + 0, + xoff, + yoff, + width, + height, + format, + type, + pixels)); +} + +void +cogl_rectangle (gint x, gint y, guint width, guint height) +{ + GE( glRecti (x,y ,width, height) ); +} + +/* FIXME: Should use ClutterReal or Fixed */ +void +cogl_trapezoid (gint y1, + gint x11, + gint x21, + gint y2, + gint x12, + gint x22) +{ + GE( glBegin (GL_QUADS) ); + GE( glVertex2i (x11, y1) ); + GE( glVertex2i (x21, y1) ); + GE( glVertex2i (x22, y2) ); + GE( glVertex2i (x12, y2) ); + GE( glEnd () ); +} + + +void +cogl_alpha_func (COGLenum func, + ClutterFixed ref) +{ + GE( glAlphaFunc (func, CLUTTER_FIXED_TO_FLOAT(ref)) ); +} + +#if 0 +/* + * Original floating point implementaiton of the perspective function, + * retained for reference purposes + */ +static inline void +frustum (GLfloat left, + GLfloat right, + GLfloat bottom, + GLfloat top, + GLfloat nearval, + GLfloat farval) +{ + GLfloat x, y, a, b, c, d; + GLfloat m[16]; + + x = (2.0 * nearval) / (right - left); + y = (2.0 * nearval) / (top - bottom); + a = (right + left) / (right - left); + b = (top + bottom) / (top - bottom); + c = -(farval + nearval) / ( farval - nearval); + d = -(2.0 * farval * nearval) / (farval - nearval); + +#define M(row,col) m[col*4+row] + M(0,0) = x; M(0,1) = 0.0F; M(0,2) = a; M(0,3) = 0.0F; + M(1,0) = 0.0F; M(1,1) = y; M(1,2) = b; M(1,3) = 0.0F; + M(2,0) = 0.0F; M(2,1) = 0.0F; M(2,2) = c; M(2,3) = d; + M(3,0) = 0.0F; M(3,1) = 0.0F; M(3,2) = -1.0F; M(3,3) = 0.0F; +#undef M + + GE( glMultMatrixf (m) ); +} + +static inline void +perspective (GLfloat fovy, + GLfloat aspect, + GLfloat zNear, + GLfloat zFar) +{ + GLfloat xmin, xmax, ymin, ymax; + + ymax = zNear * tan (fovy * M_PI / 360.0); + ymin = -ymax; + xmin = ymin * aspect; + xmax = ymax * aspect; + + printf ("%f, %f, %f, %f\n", xmin, xmax, ymin, ymax); + + frustum (xmin, xmax, ymin, ymax, zNear, zFar); +} +#endif + +/* + * Fixed point implementation of the perspective function + */ +void +cogl_perspective (ClutterAngle fovy, + ClutterFixed aspect, + ClutterFixed zNear, + ClutterFixed zFar) +{ + ClutterFixed xmax, ymax; + ClutterFixed x, y, c, d; + +#ifdef HAVE_COGL_GL + GLfloat m[16]; +#else + GLfixed m[16]; +#endif + + memset (&m[0], 0, sizeof (m)); + + /* + * Based on the original algorithm in perspective(): + * + * 1) xmin = -xmax => xmax + xmin == 0 && xmax - xmin == 2 * xmax + * same true for y, hence: a == 0 && b == 0; + * + * 2) When working with small numbers, we can are loosing significant + * precision, hence we use clutter_qmulx() here, not the fast macro. + */ + ymax = clutter_qmulx (zNear, clutter_tani (fovy >> 1)); + xmax = clutter_qmulx (ymax, aspect); + + x = CFX_DIV (zNear, xmax); + y = CFX_DIV (zNear, ymax); + c = CFX_DIV (-(zFar + zNear), ( zFar - zNear)); + d = CFX_DIV (-(clutter_qmulx (2*zFar, zNear)), (zFar - zNear)); + +#define M(row,col) m[col*4+row] +#ifdef HAVE_COGL_GL + M(0,0) = CLUTTER_FIXED_TO_FLOAT (x); + M(1,1) = CLUTTER_FIXED_TO_FLOAT (y); + M(2,2) = CLUTTER_FIXED_TO_FLOAT (c); + M(2,3) = CLUTTER_FIXED_TO_FLOAT (d); + M(3,2) = -1.0F; + + GE( glMultMatrixf (m) ); +#else + M(0,0) = x; + M(1,1) = y; + M(2,2) = c; + M(2,3) = d; + M(3,2) = 1 + ~CFX_ONE; + + GE( glMultMatrixx (m) ); +#endif +#undef M +} + +void +cogl_setup_viewport (guint width, + guint height, + ClutterAngle fovy, + ClutterFixed aspect, + ClutterFixed z_near, + ClutterFixed z_far) +{ + GE( glViewport (0, 0, width, height) ); + + GE( glMatrixMode (GL_PROJECTION) ); + GE( glLoadIdentity () ); + + cogl_perspective (fovy, aspect, z_near, z_far); + + GE( glMatrixMode (GL_MODELVIEW) ); + GE( glLoadIdentity () ); + + /* camera distance from screen, 0.5 * tan (FOV) */ +#define DEFAULT_Z_CAMERA 0.866025404f + + GE( glTranslatef (-0.5f, -0.5f, -DEFAULT_Z_CAMERA) ); + GE( glScalef ( 1.0f / width, + -1.0f / height, + 1.0f / width) ); + GE( glTranslatef (0.0f, -1.0 * height, 0.0f) ); +} diff --git a/gles/Makefile.am b/gles/Makefile.am index a4cef4eeb..9cfc95a7d 100644 --- a/gles/Makefile.am +++ b/gles/Makefile.am @@ -1,5 +1,6 @@ libclutterincludedir = $(includedir)/clutter-@CLUTTER_API_VERSION@/clutter -libclutterinclude_HEADERS = $(top_srcdir)/clutter/cogl/cogl.h +libclutterinclude_HEADERS = $(top_srcdir)/clutter/cogl/cogl.h \ + $(top_srcdir)/clutter/cogl/gles/cogl-defines.h INCLUDES = \ -I$(top_srcdir) \ diff --git a/gles/cogl-defines.h b/gles/cogl-defines.h new file mode 100644 index 000000000..6354d24a7 --- /dev/null +++ b/gles/cogl-defines.h @@ -0,0 +1,440 @@ +/* + * Clutter COGL + * + * A basic GL/GLES Abstraction/Utility Layer + * + * Authored By Matthew Allum + * + * Copyright (C) 2007 OpenedHand + * + * 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, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __COGL_DEFINES_H__ +#define __COGL_DEFINES_H__ + +G_BEGIN_DECLS + +/* ClearBufferMask */ +#define CGL_DEPTH_BUFFER_BIT GL_DEPTH_BUFFER_BIT +#define CGL_STENCIL_BUFFER_BIT GL_STENCIL_BUFFER_BIT +#define CGL_COLOR_BUFFER_BIT GL_COLOR_BUFFER_BIT + +/* Boolean */ +#define CGL_FALSE GL_FALSE +#define CGL_TRUE GL_TRUE + +/* BeginMode */ +#define CGL_POINTS GL_POINTS +#define CGL_LINES GL_LINES +#define CGL_LINE_LOOP GL_LINE_LOOP +#define CGL_LINE_STRIP GL_LINE_STRIP +#define CGL_TRIANGLES GL_TRIANGLES +#define CGL_TRIANGLE_STRIP GL_TRIANGLE_STRIP +#define CGL_TRIANGLE_FAN GL_TRIANGLE_FAN + +/* AlphaFunction */ +#define CGL_NEVER GL_NEVER +#define CGL_LESS GL_LESS +#define CGL_EQUAL GL_EQUAL +#define CGL_LEQUAL GL_LEQUAL +#define CGL_GREATER GL_GREATER +#define CGL_NOTEQUAL GL_NOTEQUAL +#define CGL_GEQUAL GL_GEQUAL +#define CGL_ALWAYS GL_ALWAYS + +/* BlendingFactorDest */ +#define CGL_ZERO GL_ZERO +#define CGL_ONE GL_ONE +#define CGL_SRC_COLOR GL_SRC_COLOR +#define CGL_ONE_MINUS_SRC_COLOR GL_ONE_MINUS_SRC_COLOR +#define CGL_SRC_ALPHA GL_SRC_ALPHA +#define CGL_ONE_MINUS_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA +#define CGL_DST_ALPHA GL_DST_ALPHA +#define CGL_ONE_MINUS_DST_ALPHA GL_ONE_MINUS_DST_ALPHA + +/* BlendingFactorSrc */ +#define CGL_DST_COLOR GL_DST_COLOR +#define CGL_ONE_MINUS_DST_COLOR GL_ONE_MINUS_DST_COLOR +#define CGL_SRC_ALPHA_SATURATE GL_SRC_ALPHA_SATURATE +/* Missing; */ +/* GL_ZERO */ +/* GL_ONE */ +/* GL_SRC_ALPHA */ +/* GL_ONE_MINUS_SRC_ALPHA */ +/* GL_DST_ALPHA */ +/* GL_ONE_MINUS_DST_ALPHA */ + +/* CullFaceMode */ +#define CGL_FRONT GL_FRONT +#define CGL_BACK GL_BACK +#define CGL_FRONT_AND_BACK GL_FRONT_AND_BACK + +/* EnableCap */ +#define CGL_FOG GL_FOG +#define CGL_LIGHTING GL_LIGHTING +#define CGL_CULL_FACE GL_CULL_FACE +#define CGL_ALPHA_TEST GL_ALPHA_TEST +#define CGL_BLEND GL_BLEND +#define CGL_COLOR_LOGIC_OP GL_COLOR_LOGIC_OP +#define CGL_DITHER GL_DITHER +#define CGL_STENCIL_TEST GL_STENCIL_TEST +#define CGL_DEPTH_TEST GL_DEPTH_TEST +#define CGL_POINT_SMOOTH GL_POINT_SMOOTH +#define CGL_LINE_SMOOTH GL_LINE_SMOOTH +#define CGL_SCISSOR_TEST GL_SCISSOR_TEST +#define CGL_COLOR_MATERIAL GL_COLOR_MATERIAL +#define CGL_NORMALIZE GL_NORMALIZE +#define CGL_RESCALE_NORMAL GL_RESCALE_NORMAL +#define CGL_POLYGON_OFFSET_FILL GL_POLYGON_OFFSET_FILL +#define CGL_VERTEX_ARRAY GL_VERTEX_ARRAY +#define CGL_NORMAL_ARRAY GL_NORMAL_ARRAY +#define CGL_COLOR_ARRAY GL_COLOR_ARRAY +#define CGL_TEXTURE_COORD_ARRAY GL_TEXTURE_COORD_ARRAY +#define CGL_MULTISAMPLE GL_MULTISAMPLE +#define CGL_SAMPLE_ALPHA_TO_COVERAGE GL_SAMPLE_ALPHA_TO_COVERAGE +#define CGL_SAMPLE_ALPHA_TO_ONE GL_SAMPLE_ALPHA_TO_ONE +#define CGL_SAMPLE_COVERAGE GL_SAMPLE_COVERAGE + +/* Errors */ +#define CGL_NO_ERROR GL_NO_ERROR +#define CGL_INVALID_ENUM GL_INVALID_ENUM +#define CGL_INVALID_VALUE GL_INVALID_VALUE +#define CGL_INVALID_OPERATION GL_INVALID_OPERATION +#define CGL_STACK_OVERFLOW GL_STACK_OVERFLOW +#define CGL_STACK_UNDERFLOW GL_STACK_UNDERFLOW +#define CGL_OUT_OF_MEMORY GL_OUT_OF_MEMORY + +/* Fog mode */ +#define CGL_EXP GL_EXP +#define CGL_EXP2 GL_EXP2 +#define CGL_FOG_DENSITY GL_FOG_DENSITY + +/* FogParameter */ +#define CGL_FOG_START GL_FOG_START +#define CGL_FOG_END GL_FOG_END +#define CGL_FOG_MODE GL_FOG_MODE +#define CGL_FOG_COLOR GL_FOG_COLOR +#define CGL_CW GL_CW +#define CGL_CCW GL_CCW + +/* GetPName */ +#define CGL_CURRENT_COLOR GL_CURRENT_COLOR +#define CGL_CURRENT_NORMAL GL_CURRENT_NORMAL +#define CGL_CURRENT_TEXTURE_COORDS GL_CURRENT_TEXTURE_COORDS +#define CGL_POINT_SIZE GL_POINT_SIZE +#define CGL_POINT_SIZE_MIN GL_POINT_SIZE_MIN +#define CGL_POINT_SIZE_MAX GL_POINT_SIZE_MAX +#define CGL_POINT_FADE_THRESHOLD_SIZE GL_POINT_FADE_THRESHOLD_SIZE +#define CGL_POINT_DISTANCE_ATTENUATION GL_POINT_DISTANCE_ATTENUATION +#define CGL_SMOOTH_POINT_SIZE_RANGE GL_SMOOTH_POINT_SIZE_RANGE +#define CGL_LINE_WIDTH GL_LINE_WIDTH +#define CGL_SMOOTH_LINE_WIDTH_RANGE GL_SMOOTH_LINE_WIDTH_RANGE +#define CGL_ALIASED_POINT_SIZE_RANGE GL_ALIASED_POINT_SIZE_RANGE +#define CGL_ALIASED_LINE_WIDTH_RANGE GL_ALIASED_LINE_WIDTH_RANGE +#define CGL_CULL_FACE_MODE GL_CULL_FACE_MODE +#define CGL_FRONT_FACE GL_FRONT_FACE +#define CGL_SHADE_MODEL GL_SHADE_MODEL +#define CGL_DEPTH_RANGE GL_DEPTH_RANGE +#define CGL_DEPTH_WRITEMASK GL_DEPTH_WRITEMASK +#define CGL_DEPTH_CLEAR_VALUE GL_DEPTH_CLEAR_VALUE +#define CGL_DEPTH_FUNC GL_DEPTH_FUNC +#define CGL_STENCIL_CLEAR_VALUE GL_STENCIL_CLEAR_VALUE +#define CGL_STENCIL_FUNC GL_STENCIL_FUNC +#define CGL_STENCIL_VALUE_MASK GL_STENCIL_VALUE_MASK +#define CGL_STENCIL_FAIL GL_STENCIL_FAIL +#define CGL_STENCIL_PASS_DEPTH_FAIL GL_STENCIL_PASS_DEPTH_FAIL +#define CGL_STENCIL_PASS_DEPTH_PASS GL_STENCIL_PASS_DEPTH_PASS +#define CGL_STENCIL_REF GL_STENCIL_REF +#define CGL_STENCIL_WRITEMASK GL_STENCIL_WRITEMASK +#define CGL_MATRIX_MODE GL_MATRIX_MODE +#define CGL_VIEWPORT GL_VIEWPORT +#define CGL_MODELVIEW_STACK_DEPTH GL_MODELVIEW_STACK_DEPTH +#define CGL_PROJECTION_STACK_DEPTH GL_PROJECTION_STACK_DEPTH +#define CGL_TEXTURE_STACK_DEPTH GL_TEXTURE_STACK_DEPTH +#define CGL_MODELVIEW_MATRIX GL_MODELVIEW_MATRIX +#define CGL_PROJECTION_MATRIX GL_PROJECTION_MATRIX +#define CGL_TEXTURE_MATRIX GL_TEXTURE_MATRIX +#define CGL_ALPHA_TEST_FUNC GL_ALPHA_TEST_FUNC +#define CGL_ALPHA_TEST_REF GL_ALPHA_TEST_REF +#define CGL_BLEND_DST GL_BLEND_DST +#define CGL_BLEND_SRC GL_BLEND_SRC +#define CGL_LOGIC_OP_MODE GL_LOGIC_OP_MODE +#define CGL_SCISSOR_BOX GL_SCISSOR_BOX +#define CGL_SCISSOR_TEST GL_SCISSOR_TEST +#define CGL_COLOR_CLEAR_VALUE GL_COLOR_CLEAR_VALUE +#define CGL_COLOR_WRITEMASK GL_COLOR_WRITEMASK +#define CGL_UNPACK_ALIGNMENT GL_UNPACK_ALIGNMENT +#define CGL_PACK_ALIGNMENT GL_PACK_ALIGNMENT +#define CGL_MAX_LIGHTS GL_MAX_LIGHTS +#define CGL_MAX_CLIP_PLANES GL_MAX_CLIP_PLANES +#define CGL_MAX_TEXTURE_SIZE GL_MAX_TEXTURE_SIZE +#define CGL_MAX_MODELVIEW_STACK_DEPTH GL_MAX_MODELVIEW_STACK_DEPTH +#define CGL_MAX_PROJECTION_STACK_DEPTH GL_MAX_PROJECTION_STACK_DEPTH +#define CGL_MAX_TEXTURE_STACK_DEPTH GL_MAX_TEXTURE_STACK_DEPTH +#define CGL_MAX_VIEWPORT_DIMS GL_MAX_VIEWPORT_DIMS +#define CGL_MAX_ELEMENTS_VERTICES GL_MAX_ELEMENTS_VERTICES +#define CGL_MAX_ELEMENTS_INDICES GL_MAX_ELEMENTS_INDICES +#define CGL_MAX_TEXTURE_UNITS GL_MAX_TEXTURE_UNITS +#define CGL_SUBPIXEL_BITS GL_SUBPIXEL_BITS +#define CGL_RED_BITS GL_RED_BITS +#define CGL_GREEN_BITS GL_GREEN_BITS +#define CGL_BLUE_BITS GL_BLUE_BITS +#define CGL_ALPHA_BITS GL_ALPHA_BITS +#define CGL_DEPTH_BITS GL_DEPTH_BITS +#define CGL_STENCIL_BITS GL_STENCIL_BITS +#define CGL_POLYGON_OFFSET_UNITS GL_POLYGON_OFFSET_UNITS +#define CGL_POLYGON_OFFSET_FILL GL_POLYGON_OFFSET_FILL +#define CGL_POLYGON_OFFSET_FACTOR GL_POLYGON_OFFSET_FACTOR +#define CGL_VERTEX_ARRAY_SIZE GL_VERTEX_ARRAY_SIZE +#define CGL_VERTEX_ARRAY_TYPE GL_VERTEX_ARRAY_TYPE +#define CGL_VERTEX_ARRAY_STRIDE GL_VERTEX_ARRAY_STRIDE +#define CGL_NORMAL_ARRAY_TYPE GL_NORMAL_ARRAY_TYPE +#define CGL_NORMAL_ARRAY_STRIDE GL_NORMAL_ARRAY_STRIDE +#define CGL_COLOR_ARRAY_SIZE GL_COLOR_ARRAY_SIZE +#define CGL_COLOR_ARRAY_TYPE GL_COLOR_ARRAY_TYPE +#define CGL_COLOR_ARRAY_STRIDE GL_COLOR_ARRAY_STRIDE +#define CGL_TEXTURE_COORD_ARRAY_SIZE GL_TEXTURE_COORD_ARRAY_SIZE +#define CGL_TEXTURE_COORD_ARRAY_TYPE GL_TEXTURE_COORD_ARRAY_TYPE +#define CGL_TEXTURE_COORD_ARRAY_STRIDE GL_TEXTURE_COORD_ARRAY_STRIDE +#define CGL_VERTEX_ARRAY_POINTER GL_VERTEX_ARRAY_POINTER +#define CGL_NORMAL_ARRAY_POINTER GL_NORMAL_ARRAY_POINTER +#define CGL_COLOR_ARRAY_POINTER GL_COLOR_ARRAY_POINTER +#define CGL_TEXTURE_COORD_ARRAY_POINTER GL_TEXTURE_COORD_ARRAY_POINTER +#define CGL_SAMPLE_BUFFERS GL_SAMPLE_BUFFERS +#define CGL_SAMPLES GL_SAMPLES +#define CGL_SAMPLE_COVERAGE_VALUE GL_SAMPLE_COVERAGE_VALUE +#define CGL_SAMPLE_COVERAGE_INVERT GL_SAMPLE_COVERAGE_INVERT + +/* GetTextureParameter - missing */ +/* GL_TEXTURE_MAG_FILTER */ +/* GL_TEXTURE_MIN_FILTER */ +/* GL_TEXTURE_WRAP_S */ +/* GL_TEXTURE_WRAP_T */ + + +#define CGL_IMPLEMENTATION_COLOR_READ_TYPE_OES GL_IMPLEMENTATION_COLOR_READ_TYPE_OES +#define CGL_IMPLEMENTATION_COLOR_READ_FORMAT_OES GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES +#define CGL_NUM_COMPRESSED_TEXTURE_FORMATS GL_NUM_COMPRESSED_TEXTURE_FORMATS +#define CGL_COMPRESSED_TEXTURE_FORMATS GL_COMPRESSED_TEXTURE_FORMATS + +/* OES_matrix_get */ +#define CGL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS +#define CGL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS +#define CGL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS +/* HintMode */ +#define CGL_DONT_CARE GL_DONT_CARE +#define CGL_FASTEST GL_FASTEST +#define CGL_NICEST GL_NICEST + +/* HintTarget */ +#define CGL_PERSPECTIVE_CORRECTION_HINT GL_PERSPECTIVE_CORRECTION_HINT +#define CGL_POINT_SMOOTH_HINT GL_POINT_SMOOTH_HINT +#define CGL_LINE_SMOOTH_HINT GL_LINE_SMOOTH_HINT +#define CGL_POLYGON_SMOOTH_HINT GL_POLYGON_SMOOTH_HINT +#define CGL_FOG_HINT GL_FOG_HINT +#define CGL_GENERATE_MIPMAP_HINT GL_GENERATE_MIPMAP_HINT + +/* LightModelParameter */ +#define CGL_LIGHT_MODEL_AMBIENT GL_LIGHT_MODEL_AMBIENT +#define CGL_LIGHT_MODEL_TWO_SIDE GL_LIGHT_MODEL_TWO_SIDE + +/* LightParameter */ +#define CGL_AMBIENT GL_AMBIENT +#define CGL_DIFFUSE GL_DIFFUSE +#define CGL_SPECULAR GL_SPECULAR +#define CGL_POSITION GL_POSITION +#define CGL_SPOT_DIRECTION GL_SPOT_DIRECTION +#define CGL_SPOT_EXPONENT GL_SPOT_EXPONENT +#define CGL_SPOT_CUTOFF GL_SPOT_CUTOFF +#define CGL_CONSTANT_ATTENUATION GL_CONSTANT_ATTENUATION +#define CGL_LINEAR_ATTENUATION GL_LINEAR_ATTENUATION +#define CGL_QUADRATIC_ATTENUATION GL_QUADRATIC_ATTENUATION + +/* DataType */ +#define CGL_BYTE GL_BYTE +#define CGL_UNSIGNED_BYTE GL_UNSIGNED_BYTE +#define CGL_SHORT GL_SHORT +#define CGL_UNSIGNED_SHORT GL_UNSIGNED_SHORT +#define CGL_FLOAT GL_FLOAT +#define CGL_FIXED GL_FIXED + +/* LogicOp */ +#define CGL_CLEAR GL_CLEAR +#define CGL_AND GL_AND +#define CGL_AND_REVERSE GL_AND_REVERSE +#define CGL_COPY GL_COPY +#define CGL_AND_INVERTED GL_AND_INVERTED +#define CGL_NOOP GL_NOOP +#define CGL_XOR GL_XOR +#define CGL_OR GL_OR +#define CGL_NOR GL_NOR +#define CGL_EQUIV GL_EQUIV +#define CGL_INVERT GL_INVERT +#define CGL_OR_REVERSE GL_OR_REVERSE +#define CGL_COPY_INVERTED GL_COPY_INVERTED +#define CGL_OR_INVERTED GL_OR_INVERTED +#define CGL_NAND GL_NAND +#define CGL_SET GL_SET + +/* MaterialParameter */ +#define CGL_EMISSION GL_EMISSION +#define CGL_SHININESS GL_SHININESS +#define CGL_AMBIENT_AND_DIFFUSE GL_AMBIENT_AND_DIFFUSE + +/* MatrixMode */ +#define CGL_MODELVIEW GL_MODELVIEW +#define CGL_PROJECTION GL_PROJECTION +#define CGL_TEXTURE GL_TEXTURE + +/* PixelFormat */ +#define CGL_ALPHA GL_ALPHA +#define CGL_RGB GL_RGB +#define CGL_RGBA GL_RGBA +#define CGL_LUMINANCE GL_LUMINANCE +#define CGL_LUMINANCE_ALPHA GL_LUMINANCE_ALPHA + +/* PixelStoreParameter */ +#define CGL_UNPACK_ALIGNMENT GL_UNPACK_ALIGNMENT +#define CGL_PACK_ALIGNMENT GL_PACK_ALIGNMENT + +/* PixelType */ +/* GL_UNSIGNED_BYTE */ +#define CGL_UNSIGNED_SHORT_4_4_4_4 GL_UNSIGNED_SHORT_4_4_4_4 +#define CGL_UNSIGNED_SHORT_5_5_5_1 GL_UNSIGNED_SHORT_5_5_5_1 +#define CGL_UNSIGNED_SHORT_5_6_5 CGL_UNSIGNED_SHORT_5_6_5 + +/* ShadingModel */ +#define CGL_FLAT GL_FLAT +#define CGL_SMOOTH GL_SMOOTH + +/* StencilFunction */ +/* GL_NEVER */ +/* GL_LESS */ +/* GL_EQUAL */ +/* GL_LEQUAL */ +/* GL_GREATER */ +/* GL_NOTEQUAL */ +/* GL_GEQUAL */ +/* GL_ALWAYS */ + +/* StencilOp */ +#define CGL_KEEP GL_KEEP +#define CGL_REPLACE GL_REPLACE +#define CGL_INCR GL_INCR +#define CGL_DECR GL_DECR + +/* StringName */ +#define CGL_VENDOR GL_VENDOR +#define CGL_RENDERER GL_RENDERER +#define CGL_VERSION GL_VERSION +#define CGL_EXTENSIONS GL_EXTENSIONS + +/* TextureEnvMode */ +#define CGL_MODULATE GL_MODULATE +#define CGL_DECAL GL_DECAL +#define CGL_ADD GL_ADD +/* GL_BLEND */ +/* GL_REPLACE */ + +/* TextureEnvParameter */ +#define CGL_TEXTURE_ENV_MODE GL_TEXTURE_ENV_MODE +#define CGL_TEXTURE_ENV_COLOR GL_TEXTURE_ENV_COLOR + +/* TextureEnvTarget */ +#define CGL_TEXTURE_ENV GL_TEXTURE_ENV + +/* TextureMagFilter */ +#define CGL_NEAREST GL_NEAREST +#define CGL_LINEAR GL_LINEAR + +/* TextureMinFilter */ +/* GL_NEAREST */ +/* GL_LINEAR */ +#define CGL_NEAREST_MIPMAP_NEAREST GL_NEAREST_MIPMAP_NEAREST +#define CGL_LINEAR_MIPMAP_NEAREST GL_LINEAR_MIPMAP_NEAREST +#define CGL_NEAREST_MIPMAP_LINEAR GL_NEAREST_MIPMAP_LINEAR +#define CGL_LINEAR_MIPMAP_LINEAR GL_LINEAR_MIPMAP_LINEAR + +/* TextureParameterName */ +#define CGL_TEXTURE_MAG_FILTER GL_TEXTURE_MAG_FILTER +#define CGL_TEXTURE_MIN_FILTER GL_TEXTURE_MIN_FILTER +#define CGL_TEXTURE_WRAP_S GL_TEXTURE_WRAP_S +#define CGL_TEXTURE_WRAP_T GL_TEXTURE_WRAP_T +#define CGL_GENERATE_MIPMAP GL_GENERATE_MIPMAP + +#define CGL_ACTIVE_TEXTURE GL_ACTIVE_TEXTURE +#define CGL_CLIENT_ACTIVE_TEXTURE GL_CLIENT_ACTIVE_TEXTURE + +/* TextureWrapMode */ +#define CGL_REPEAT GL_REPEAT +#define CGL_CLAMP_TO_EDGE GL_CLAMP_TO_EDGE + +/* PixelInternalFormat */ + +/* Buffer Objects */ +#define CGL_ARRAY_BUFFER GL_ARRAY_BUFFER +#define CGL_ELEMENT_ARRAY_BUFFER GL_ELEMENT_ARRAY_BUFFER +#define CGL_ARRAY_BUFFER_BINDING GL_ARRAY_BUFFER_BINDING +#define CGL_ELEMENT_ARRAY_BUFFER_BINDING GL_ELEMENT_ARRAY_BUFFER_BINDING +#define CGL_VERTEX_ARRAY_BUFFER_BINDING GL_VERTEX_ARRAY_BUFFER_BINDING +#define CGL_NORMAL_ARRAY_BUFFER_BINDING GL_NORMAL_ARRAY_BUFFER_BINDING +#define CGL_COLOR_ARRAY_BUFFER_BINDING GL_COLOR_ARRAY_BUFFER_BINDING +#define CGL_TEXTURE_COORD_ARRAY_BUFFER_BINDING GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING +#define CGL_STATIC_DRAW GL_STATIC_DRAW +#define CGL_DYNAMIC_DRAW GL_DYNAMIC_DRAW +#define CGL_WRITE_ONLY GL_WRITE_ONLY +#define CGL_BUFFER_SIZE GL_BUFFER_SIZE +#define CGL_BUFFER_USAGE GL_BUFFER_USAGE +#define CGL_BUFFER_ACCESS GL_BUFFER_ACCESS +#define CGL_SUBTRACT GL_SUBTRACT +#define CGL_COMBINE GL_COMBINE +#define CGL_COMBINE_RGB GL_COMBINE_RGB +#define CGL_COMBINE_ALPHA GL_COMBINE_ALPHA +#define CGL_RGB_SCALE GL_RGB_SCALE +#define CGL_ADD_SIGNED GL_ADD_SIGNED +#define CGL_INTERPOLATE GL_INTERPOLATE +#define CGL_CONSTANT GL_CONSTANT +#define CGL_PRIMARY_COLOR GL_PRIMARY_COLOR +#define CGL_PREVIOUS GL_PREVIOUS +#define CGL_ALPHA_SCALE GL_ALPHA_SCALE +#define CGL_POINT_SPRITE_OES GL_POINT_SPRITE_OES +#define CGL_COORD_REPLACE_OES GL_COORD_REPLACE_OES +#define CGL_POINT_SIZE_ARRAY_OES GL_POINT_SIZE_ARRAY_OES +#define CGL_POINT_SIZE_ARRAY_TYPE_OES GL_POINT_SIZE_ARRAY_TYPE_OES +#define CGL_POINT_SIZE_ARRAY_STRIDE_OES GL_POINT_SIZE_ARRAY_STRIDE_OES +#define CGL_POINT_SIZE_ARRAY_POINTER_OES GL_POINT_SIZE_ARRAY_POINTER_OES +#define CGL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES +#define CGL_MAX_VERTEX_UNITS_OES GL_MAX_VERTEX_UNITS_OES +#define CGL_MAX_PALETTE_MATRICES_OES GL_MAX_PALETTE_MATRICES_OES +#define CGL_MATRIX_PALETTE_OES GL_MATRIX_PALETTE_OES +#define CGL_MATRIX_INDEX_ARRAY_OES GL_MATRIX_INDEX_ARRAY_OES +#define CGL_WEIGHT_ARRAY_OES GL_WEIGHT_ARRAY_OES +#define CGL_MATRIX_INDEX_ARRAY_SIZE_OES GL_MATRIX_INDEX_ARRAY_SIZE_OES +#define CGL_MATRIX_INDEX_ARRAY_TYPE_OES GL_MATRIX_INDEX_ARRAY_TYPE_OES +#define CGL_MATRIX_INDEX_ARRAY_STRIDE_OES GL_MATRIX_INDEX_ARRAY_STRIDE_OES +#define CGL_MATRIX_INDEX_ARRAY_POINTER_OES GL_MATRIX_INDEX_ARRAY_POINTER_OES +#define CGL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES +#define CGL_WEIGHT_ARRAY_SIZE_OES GL_WEIGHT_ARRAY_SIZE_OES +#define CGL_WEIGHT_ARRAY_TYPE_OES GL_WEIGHT_ARRAY_TYPE_OES +#define CGL_WEIGHT_ARRAY_STRIDE_OES GL_WEIGHT_ARRAY_STRIDE_OES +#define CGL_WEIGHT_ARRAY_POINTER_OES GL_WEIGHT_ARRAY_POINTER_OES +#define CGL_WEIGHT_ARRAY_BUFFER_BINDING_OES GL_WEIGHT_ARRAY_BUFFER_BINDING_OES +#define CGL_TEXTURE_CROP_RECT_OES GL_TEXTURE_CROP_RECT_OES + +G_END_DECLS + +#endif diff --git a/gles/cogl.c b/gles/cogl.c index 97b045f36..274d79529 100644 --- a/gles/cogl.c +++ b/gles/cogl.c @@ -26,6 +26,54 @@ #include "cogl.h" #include + +#if COGL_DEBUG +struct token_string +{ + GLuint Token; + const char *String; +}; + +static const struct token_string Errors[] = { + { GL_NO_ERROR, "no error" }, + { GL_INVALID_ENUM, "invalid enumerant" }, + { GL_INVALID_VALUE, "invalid value" }, + { GL_INVALID_OPERATION, "invalid operation" }, + { GL_STACK_OVERFLOW, "stack overflow" }, + { GL_STACK_UNDERFLOW, "stack underflow" }, + { GL_OUT_OF_MEMORY, "out of memory" }, +#ifdef GL_INVALID_FRAMEBUFFER_OPERATION_EXT + { GL_INVALID_FRAMEBUFFER_OPERATION_EXT, "invalid framebuffer operation" }, +#endif + { ~0, NULL } +}; + +static const char* +error_string(GLenum errorCode) +{ + int i; + for (i = 0; Errors[i].String; i++) { + if (Errors[i].Token == errorCode) + return Errors[i].String; + } + return "unknown"; +} +#endif + +#if COGL_DEBUG +#define GE(x...) { \ + GLenum err; \ + (x); \ + while ((err = glGetError()) != GL_NO_ERROR) { \ + fprintf(stderr, "glError: %s caught at %s:%u\n", \ + (char *)error_string(err), \ + __FILE__, __LINE__); \ + } \ +} +#else +#define GE(x) (x); +#endif + CoglFuncPtr cogl_get_proc_address (const gchar* name) { @@ -67,21 +115,21 @@ cogl_pop_matrix (void) void cogl_scaled (ClutterFixed x, ClutterFixed y) { - glScalex (x, y, CFX_ONE); + GE( glScalex (x, y, CFX_ONE) ); } void cogl_translatex (ClutterFixed x, ClutterFixed y, ClutterFixed z) { - glTranslatex (x, y, z); + GE( glTranslatex (x, y, z) ); } void cogl_translate (gint x, gint y, gint z) { - glTranslatex (CLUTTER_INT_TO_FIXED(x), - CLUTTER_INT_TO_FIXED(y), - CLUTTER_INT_TO_FIXED(z)); + GE( glTranslatex (CLUTTER_INT_TO_FIXED(x), + CLUTTER_INT_TO_FIXED(y), + CLUTTER_INT_TO_FIXED(z)) ); } void @@ -90,14 +138,14 @@ cogl_rotatex (ClutterFixed angle, ClutterFixed y, ClutterFixed z) { - glRotatex (angle,x,y,z); + GE( glRotatex (angle,x,y,z) ); } void cogl_rotate (gint angle, gint x, gint y, gint z) { - glRotatef (CLUTTER_INT_TO_FIXED(angle), - CLUTTER_INT_TO_FIXED(x), - CLUTTER_INT_TO_FIXED(y), - CLUTTER_INT_TO_FIXED(z)); + GE( glRotatef (CLUTTER_INT_TO_FIXED(angle), + CLUTTER_INT_TO_FIXED(x), + CLUTTER_INT_TO_FIXED(y), + CLUTTER_INT_TO_FIXED(z)) ); }