Menu
▾
▴
[csdOpenGL.NET-CVS] csdOpenGL/generator Exceptions.cs,NONE,1.1 Makefile,1.7,1.8 csdGL.cs,1.2,1.3 gtkContext.cs,1.5,1.6
|
From: Tim R. <ti...@us...> - 2004-08-01 13:26:54
|
Update of /cvsroot/csdopenglnet/csdOpenGL/generator In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv29602/generator Modified Files: Makefile csdGL.cs gtkContext.cs Added Files: Exceptions.cs Log Message: added a property for each glEnabled-flag Index: gtkContext.cs =================================================================== RCS file: /cvsroot/csdopenglnet/csdOpenGL/generator/gtkContext.cs,v retrieving revision 1.5 retrieving revision 1.6 diff -C2 -d -r1.5 -r1.6 *** gtkContext.cs 27 Jul 2004 13:38:46 -0000 1.5 --- gtkContext.cs 1 Aug 2004 13:26:42 -0000 1.6 *************** *** 7,13 **** using System.Runtime.InteropServices; - public class NoGLContextException : Exception {} - public class NoXDisplayException : Exception {} - public class GdkGLContext : csdGLXTokens { --- 7,10 ---- *************** *** 78,82 **** IntPtr visualInfo = glXChooseVisual( xdisplay, gdk_x11_get_default_screen(), attributeList ); ! if (xdisplay==IntPtr.Zero) throw new NoGLContextException(); try { --- 75,79 ---- IntPtr visualInfo = glXChooseVisual( xdisplay, gdk_x11_get_default_screen(), attributeList ); ! if (visualInfo==IntPtr.Zero) throw new NoGLContextException(); try { Index: Makefile =================================================================== RCS file: /cvsroot/csdopenglnet/csdOpenGL/generator/Makefile,v retrieving revision 1.7 retrieving revision 1.8 diff -C2 -d -r1.7 -r1.8 *** Makefile 27 Jul 2004 11:24:53 -0000 1.7 --- Makefile 1 Aug 2004 13:26:42 -0000 1.8 *************** *** 1,5 **** FILES=generator.cs AssemblyInfo.cs define.cs typedef.cs function.cs ! GLUTFILES=csdGLBase.cs csdGL.cs csdGLUBase.cs csdGLUTBase.cs csdFreeGLUTBase.cs csdFreeGLUT_extBase.cs csdFreeGLUT_stdBase.cs ! GLFILES=csdGLBase.cs csdGL.cs csdGLUBase.cs csdGLUTBase.cs CC=mcs --- 1,4 ---- FILES=generator.cs AssemblyInfo.cs define.cs typedef.cs function.cs ! GLFILES=csdGLBase.cs csdGL.cs csdGLUBase.cs csdGLUTBase.cs Exceptions.cs CC=mcs *************** *** 34,46 **** mono ./csdGenerator.exe glut_8h.xml libcsdGL.so csdGLUTBase csdGLUBase csdGLUTBase.cs gl_8h.xml - csdFreeGLUTBase.cs: csdGenerator.exe gl_8h.xml freeglut_8h.xml - mono ./csdGenerator.exe freeglut_8h.xml libcsdGL.so csdFreeGLUTBase csdGLUBase csdFreeGLUTBase.cs gl_8h.xml - - csdFreeGLUT_extBase.cs: csdGenerator.exe gl_8h.xml freeglut_ext_8h.xml - mono ./csdGenerator.exe freeglut_ext_8h.xml libcsdGL.so csdFreeGLUT_extBase csdFreeGLUTBase csdFreeGLUT_extBase.cs glu_8h.xml gl_8h.xml - - csdFreeGLUT_stdBase.cs: csdGenerator.exe gl_8h.xml freeglut_std_8h.xml - mono ./csdGenerator.exe freeglut_std_8h.xml libcsdGL.so csdFreeGLUT_stdBase csdFreeGLUT_extBase csdFreeGLUT_stdBase.cs glu_8h.xml gl_8h.xml - gl_8h.xml: --- 33,36 ---- *************** *** 53,65 **** ln -sf ../doxygen/xml/glut_8h.xml . - freeglut_8h.xml: - ln -sf ../doxygen/xml/freeglut_8h.xml . - - freeglut_std_8h.xml: - ln -sf ../doxygen/xml/freeglut_std_8h.xml . - - freeglut_ext_8h.xml: - ln -sf ../doxygen/xml/freeglut_ext_8h.xml . - glxtokens_8h.xml: ln -sf ../doxygen/xml/glxtokens_8h.xml . --- 43,46 ---- Index: csdGL.cs =================================================================== RCS file: /cvsroot/csdopenglnet/csdOpenGL/generator/csdGL.cs,v retrieving revision 1.2 retrieving revision 1.3 diff -C2 -d -r1.2 -r1.3 *** csdGL.cs 1 Aug 2004 10:55:47 -0000 1.2 --- csdGL.cs 1 Aug 2004 13:26:42 -0000 1.3 *************** *** 1,11 **** using System; ! using System.Runtime.InteropServices; ! namespace csDragons { namespace OpenGL { public class csdGL : csdGLUTBase { } --- 1,515 ---- using System; ! using System.Diagnostics; namespace csDragons { namespace OpenGL { + /** \brief Main class for csdGL + * + * This class combines all OpenGL functionality. + */ public class csdGL : csdGLUTBase { + /** \brief control flag for type of error handling + * + * If this attribute is set to true then the extended + * OpenGL methods will automatically check for errors and + * raise Exceptions. + */ + public bool raiseExceptions = true; + + /** \brief check OpenGL-Error flag + * + * This method checks the OpenGL error flag and raises the corresponding + * Exception if an error is available. + */ + public void checkErrors() { + Debug.Indent(); + Debug.WriteLine( "Entering csdGL.checkErros()" ); + + uint error = glGetError(); + + if (error==GL_INVALID_ENUM) { + Debug.WriteLine( "OpenGL-Error: GL_INVALID_ENUM" ); + throw new GLInvalidEnumException(); + } else if (error==GL_INVALID_VALUE) { + Debug.WriteLine( "OpenGL-Error: GL_INVALID_VALUE" ); + throw new GLInvalidValue(); + } else if (error==GL_INVALID_OPERATION) { + Debug.WriteLine( "OpenGL-Error: GL_INVALID_OPERATION" ); + throw new GLInvalidOperation(); + } else if (error==GL_STACK_OVERFLOW) { + Debug.WriteLine( "OpenGL-Error: GL_STACK_OVERFLOW" ); + throw new GLStackOverflow(); + } else if (error==GL_STACK_UNDERFLOW) { + Debug.WriteLine( "OpenGL-Error: GL_STACK_UNDERFLOW" ); + throw new GLStackUnderflow(); + } else if (error==GL_OUT_OF_MEMORY) { + Debug.WriteLine( "OpenGL-Error: GL_OUT_OF_MEMORY" ); + throw new GLOutOfMemory(); + } + + Debug.WriteLine( "Exiting csdGL.checkErros()" ); + Debug.Unindent(); + } + + /** \brief retrieve errors and ignore them + * + * This method resets the OpenGL error flag and ignores + * the error. + */ + public void ignoreErrors() { + Debug.Indent(); + Debug.WriteLine( "Entering csdGL.ignoreErros()" ); + + try { + checkErrors(); + } catch ( GLException e ) { + Debug.WriteLine( e.ToString() ); + } + + Debug.WriteLine( "Exiting csdGL.ignoreErrors()" ); + Debug.Unindent(); + } + + /** \brief get OpenGL flag + * + * This methode returns the value of a flag. It calls checkErrors() for + * error handling + * @param flag Specifies a symbolic constant indicating a GL capability + */ + protected bool getFlag( uint flag ) { + Debug.Indent(); + Debug.WriteLine( "Entering csdGL.getFlag( uint )" ); + + bool result = GL_TRUE==glIsEnabled( flag ); + + if (raiseExceptions) { + checkErrors(); + } + + Debug.WriteLine( "Exiting csdGL.getFlag( uint )*" ); + Debug.Unindent(); + + return result; + } + + /** \brieg set OpenGL flag + * + * This methode sets the state for a specific OpenGL flag. It calls + * checkErrors() for error handling. + * @param flag specifies a symbolic constant indicating a GL capability + * @param state specifies whether the flag shall be turned on or off + */ + protected void setFlag( uint flag, bool state ) { + Debug.Indent(); + Debug.WriteLine( "Entering csdGL.setFlag( uint, bool )" ); + + if (state) { + glEnable( flag ); + } else { + glDisable( flag ); + } + + if (raiseExceptions) { + checkErrors(); + } + + Debug.WriteLine( "Exiting csdGL.setFlag( uint, bool )" ); + Debug.Unindent(); + } + + /** \brief If enabled, do alpha testing. + */ + public bool AlphaTest { + get { return getFlag( GL_ALPHA_TEST ); } + set { setFlag( GL_ALPHA_TEST, value ); } + } + + /** \brief If enabled, compute surface normal vectors analytically when either GL_MAP2_VERTEX_3 or GL_MAP2_VERTEX_4 is used to generate vertices. + */ + public bool AutoNormal { + get { return getFlag( GL_AUTO_NORMAL ); } + set { setFlag( GL_AUTO_NORMAL, value ); } + } + + /** \brief If enabled, blend the incoming RGBA color values with the values in the color buffers. + */ + public bool Blend { + get { return getFlag( GL_BLEND ); } + set { setFlag( GL_BLEND, value ); } + } + + /** \brief If enabled, clip geometry against user-defined clipping plane 0. + */ + public bool ClipPlane0 { + get { return getFlag( GL_CLIP_PLANE0 ); } + set { setFlag( GL_CLIP_PLANE0, value ); } + } + + /** \brief If enabled, clip geometry against user-defined clipping plane 1. + */ + public bool ClipPlane1 { + get { return getFlag( GL_CLIP_PLANE1 ); } + set { setFlag( GL_CLIP_PLANE1, value ); } + } + + /** \brief If enabled, clip geometry against user-defined clipping plane 2. + */ + public bool ClipPlane2 { + get { return getFlag( GL_CLIP_PLANE2 ); } + set { setFlag( GL_CLIP_PLANE2, value ); } + } + + /** \brief If enabled, clip geometry against user-defined clipping plane 3. + */ + public bool ClipPlane3 { + get { return getFlag( GL_CLIP_PLANE3 ); } + set { setFlag( GL_CLIP_PLANE3, value ); } + } + + /** \brief If enabled, clip geometry against user-defined clipping plane 4. + */ + public bool ClipPlane4 { + get { return getFlag( GL_CLIP_PLANE4 ); } + set { setFlag( GL_CLIP_PLANE4, value ); } + } + + /** \brief If enabled, clip geometry against user-defined clipping plane 5. + */ + public bool ClipPlane5 { + get { return getFlag( GL_CLIP_PLANE5 ); } + set { setFlag( GL_CLIP_PLANE5, value ); } + } + + /** \brief If enabled, have one or more material parameters track the current color. + */ + public bool ColorMaterial { + get { return getFlag( GL_COLOR_MATERIAL ); } + set { setFlag( GL_COLOR_MATERIAL, value ); } + } + + /** \brief If enabled, cull polygons based on their winding in window coordinates. + */ + public bool CullFace{ + get { return getFlag( GL_CULL_FACE ); } + set { setFlag( GL_CULL_FACE, value ); } + } + + /** \brief If enabled, do depth comparisons and update the depth buffer. + */ + public bool DepthTest { + get { return getFlag( GL_DEPTH_TEST ); } + set { setFlag( GL_DEPTH_TEST, value ); } + } + + /** \brief If enabled, dither color components or indices before they are written to the color buffer. + */ + public bool Dither { + get { return getFlag( GL_DITHER ); } + set { setFlag( GL_DITHER, value ); } + } + + /** \brief If enabled, blend a fog color into the posttexturing color. + */ + public bool Fog { + get { return getFlag( GL_FOG ); } + set { setFlag( GL_FOG, value ); } + } + + /** \brief If enabled, include light 0 in the evaluation of the lighting equation. + */ + public bool Light0 { + get { return getFlag( GL_LIGHT0 ); } + set { setFlag( GL_LIGHT0, value ); } + } + + /** \brief If enabled, include light 1 in the evaluation of the lighting equation. + */ + public bool Light1 { + get { return getFlag( GL_LIGHT1 ); } + set { setFlag( GL_LIGHT1, value ); } + } + + /** \brief If enabled, include light 2 in the evaluation of the lighting equation. + */ + public bool Light2 { + get { return getFlag( GL_LIGHT2 ); } + set { setFlag( GL_LIGHT2, value ); } + } + + /** \brief If enabled, include light 3 in the evaluation of the lighting equation. + */ + public bool Light3 { + get { return getFlag( GL_LIGHT3 ); } + set { setFlag( GL_LIGHT3, value ); } + } + + /** \brief If enabled, include light 4 in the evaluation of the lighting equation. + */ + public bool Light4 { + get { return getFlag( GL_LIGHT4 ); } + set { setFlag( GL_LIGHT4, value ); } + } + + /** \brief If enabled, include light 5 in the evaluation of the lighting equation. + */ + public bool Light5 { + get { return getFlag( GL_LIGHT5 ); } + set { setFlag( GL_LIGHT5, value ); } + } + + /** \brief If enabled, include light 6 in the evaluation of the lighting equation. + */ + public bool Light6 { + get { return getFlag( GL_LIGHT6 ); } + set { setFlag( GL_LIGHT6, value ); } + } + + /** \brief If enabled, include light 7 in the evaluation of the lighting equation. + */ + public bool Light7 { + get { return getFlag( GL_LIGHT7 ); } + set { setFlag( GL_LIGHT7, value ); } + } + + /** \brief If enabled, use the current lighting parameters to compute the vertex color or index. Otherwise, simply associate the current color or index with each vertex. + */ + public bool Lighting { + get { return getFlag( GL_LIGHTING ); } + set { setFlag( GL_LIGHTING, value ); } + } + + /** \brief If enabled, draw lines with correct filtering. Otherwise, draw aliased lines. + */ + public bool LineSmooth { + get { return getFlag( GL_LINE_SMOOTH ); } + set { setFlag( GL_LINE_SMOOTH, value ); } + } + + /** \brief If enabled, use the current line stipple pattern when drawing lines. + */ + public bool LineStipple { + get { return getFlag( GL_LINE_STIPPLE ); } + set { setFlag( GL_LINE_STIPPLE, value ); } + } + + /** \brief If enabled, apply the currently selected logical operation to the incoming and and color buffer indices. + */ + public bool LogicOp { + get { return getFlag( GL_LOGIC_OP ); } + set { setFlag( GL_LOGIC_OP, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate RGBA values. + */ + public bool Map1Color4 { + get { return getFlag( GL_MAP1_COLOR_4 ); } + set { setFlag( GL_MAP1_COLOR_4, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate color indices. + */ + public bool Map1Index { + get { return getFlag( GL_MAP1_INDEX ); } + set { setFlag( GL_MAP1_INDEX, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate normals. + */ + public bool Map1Normal { + get { return getFlag( GL_MAP1_NORMAL ); } + set { setFlag( GL_MAP1_NORMAL, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate s texture coordinates. + */ + public bool Map1TectureCoord1 { + get { return getFlag( GL_MAP1_TEXTURE_COORD_1 ); } + set { setFlag( GL_MAP1_TEXTURE_COORD_1, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate s and t texture coordinates. + */ + public bool Map1TectureCoord2 { + get { return getFlag( GL_MAP1_TEXTURE_COORD_2 ); } + set { setFlag( GL_MAP1_TEXTURE_COORD_2, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate s, t and r texture coordinates. + */ + public bool Map1TectureCoord3 { + get { return getFlag( GL_MAP1_TEXTURE_COORD_3 ); } + set { setFlag( GL_MAP1_TEXTURE_COORD_3, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate s, t, r and q texture coordinates. + */ + public bool Map1TectureCoord4 { + get { return getFlag( GL_MAP1_TEXTURE_COORD_4 ); } + set { setFlag( GL_MAP1_TEXTURE_COORD_4, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate x, y and z vertex coordinates. + */ + public bool Map1Vertex3 { + get { return getFlag( GL_MAP1_VERTEX_3 ); } + set { setFlag( GL_MAP1_VERTEX_3, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate homogeneous x, y, z and w vertex coordinates. + */ + public bool Map1Vertex4 { + get { return getFlag( GL_MAP1_VERTEX_4 ); } + set { setFlag( GL_MAP1_VERTEX_4, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate RGBA values. + */ + public bool Map2Color4 { + get { return getFlag( GL_MAP2_COLOR_4 ); } + set { setFlag( GL_MAP2_COLOR_4, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate color indices. + */ + public bool Map2Index { + get { return getFlag( GL_MAP2_INDEX ); } + set { setFlag( GL_MAP2_INDEX, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate normals. + */ + public bool Map2Normal { + get { return getFlag( GL_MAP2_NORMAL ); } + set { setFlag( GL_MAP2_NORMAL, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate s texture coordinates. + */ + public bool Map2TectureCoord1 { + get { return getFlag( GL_MAP2_TEXTURE_COORD_1 ); } + set { setFlag( GL_MAP2_TEXTURE_COORD_1, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate s and t texture coordinates. + */ + public bool Map2TectureCoord2 { + get { return getFlag( GL_MAP2_TEXTURE_COORD_2 ); } + set { setFlag( GL_MAP2_TEXTURE_COORD_2, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate s, t and r texture coordinates. + */ + public bool Map2TectureCoord3 { + get { return getFlag( GL_MAP2_TEXTURE_COORD_3 ); } + set { setFlag( GL_MAP2_TEXTURE_COORD_3, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate s, t, r and q texture coordinates. + */ + public bool Map2TectureCoord4 { + get { return getFlag( GL_MAP2_TEXTURE_COORD_4 ); } + set { setFlag( GL_MAP2_TEXTURE_COORD_4, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate x, y and z vertex coordinates. + */ + public bool Map2Vertex3 { + get { return getFlag( GL_MAP2_VERTEX_3 ); } + set { setFlag( GL_MAP2_VERTEX_3, value ); } + } + + /** \brief If enabled, calls to glEvalCoord1, glEvalMesh1 and glEvalPoint1 will generate homogeneous x, y, z and w vertex coordinates. + */ + public bool Map2Vertex4 { + get { return getFlag( GL_MAP2_VERTEX_4 ); } + set { setFlag( GL_MAP2_VERTEX_4, value ); } + } + + /** \brief If enabled, normal vectors specified with glNormal are scaled to unit length after transformation. + */ + public bool Normalize { + get { return getFlag( GL_NORMALIZE ); } + set { setFlag( GL_NORMALIZE, value ); } + } + + /** \brief If enabled, draw points with proper filtering. Otherwise, draw aliased points. + */ + public bool PointSmooth { + get { return getFlag( GL_POINT_SMOOTH ); } + set { setFlag( GL_POINT_SMOOTH, value ); } + } + + /** \brief If enabled, draw polygons with proper filtering. Otherwise, draw aliased polygons. + */ + public bool PolygonSmooth { + get { return getFlag( GL_POLYGON_SMOOTH ); } + set { setFlag( GL_POLYGON_SMOOTH, value ); } + } + + /** \brief If enabled, use the current polygon stipple patttern when rendering polygons. + */ + public bool PolygonStipple { + get { return getFlag( GL_POLYGON_STIPPLE ); } + set { setFlag( GL_POLYGON_STIPPLE, value ); } + } + + /** \brief If enabled, discard fragments that are outside the scissor rectangle. + */ + public bool ScissorTest { + get { return getFlag( GL_SCISSOR_TEST ); } + set { setFlag( GL_SCISSOR_TEST, value ); } + } + + /** \brief If enabled, do stencil testing and update the stencil buffer. + */ + public bool StencilTest { + get { return getFlag( GL_STENCIL_TEST ); } + set { setFlag( GL_STENCIL_TEST, value ); } + } + + /** \brief If enabled, one-dimensional texturing is performed (unless two-dimensional texturing is also enabled). + */ + public bool Texture1D { + get { return getFlag( GL_TEXTURE_1D ); } + set { setFlag( GL_TEXTURE_1D, value ); } + } + + /** \brief If enabled, two-dimensional texturing is performed. + */ + public bool Texture2D { + get { return getFlag( GL_TEXTURE_2D ); } + set { setFlag( GL_TEXTURE_2D, value ); } + } + + /** \brief If enabled, the q texture coordinate is computed using the texture generation function defined with glTexGen. Otherwise, the current q texture coordinate is used. + */ + public bool TextureGenQ { + get { return getFlag( GL_TEXTURE_GEN_Q ); } + set { setFlag( GL_TEXTURE_GEN_Q, value ); } + } + + /** \brief If enabled, the r texture coordinate is computed using the texture generation function defined with glTexGen. Otherwise, the current r texture coordinate is used. + */ + public bool TextureGenR { + get { return getFlag( GL_TEXTURE_GEN_R ); } + set { setFlag( GL_TEXTURE_GEN_R, value ); } + } + + /** \brief If enabled, the s texture coordinate is computed using the texture generation function defined with glTexGen. Otherwise, the current s texture coordinate is used. + */ + public bool TextureGenS { + get { return getFlag( GL_TEXTURE_GEN_S ); } + set { setFlag( GL_TEXTURE_GEN_S, value ); } + } + + /** \brief If enabled, the t texture coordinate is computed using the texture generation function defined with glTexGen. Otherwise, the current t texture coordinate is used. + */ + public bool TextureGenT { + get { return getFlag( GL_TEXTURE_GEN_T ); } + set { setFlag( GL_TEXTURE_GEN_T, value ); } + } + } --- NEW FILE: Exceptions.cs --- using System; namespace csDragons { namespace OpenGL { /** \brief General OpenGL Error * * This class is the base class for all OpenGL Exceptions */ public class GLException : Exception {}; /** \brief Invalid OpenGL enumeration value * * An unacceptable value is specified for an enumerated argument. * The offending command is ignored, having no side effect other than to set the error flag. */ public class GLInvalidEnumException : GLException {}; /** \brief Invalid OpenGL argument value * * A numeric argument is out of range. The offending command is ignored, * having no side effect other than to set the error flag. */ public class GLInvalidValue : GLException {}; /** \brief Invalid OpenGL operation * * The specified operation is not allowed in the current state. * The offending command is ignored, having no side effect other than to set the error flag. */ public class GLInvalidOperation : GLException {}; /** \brief Stack Overflow * * This command would cause a stack overflow. The offending command is * ignored, having no side effect other than to set the error flag. */ public class GLStackOverflow : GLException {}; /** \brief Stack Underflow * * This command would cause a stack underflow. The offending command is * ignored, having no side effect other than to set the error flag. */ public class GLStackUnderflow : GLException {}; /** \brief Out of Memory * * There is not enough memory left to execute the command. The state of * the GL is undefined, except for the state of the error flags, after this error is recorded. */ public class GLOutOfMemory : GLException {}; /** \brief No GL Context available * * This Exception is raised if there is an fatal error * during obtaining the OpenGL context. */ public class NoGLContextException : GLException {} /** \brief No X Display available * * This Exception is raised if no XDisplay can be used. */ public class NoXDisplayException : GLException {} } } |
