glIsEnabled man page on Oracle

Man page or keyword search:  
man Server   33470 pages
apropos Keyword Search (all sections)
Output format
Oracle logo
[printable version]

GLISENABLED(3G)			 OpenGL Manual		       GLISENABLED(3G)

NAME
       glIsEnabled - test whether a capability is enabled

C SPECIFICATION
       GLboolean glIsEnabled(GLenum cap);

PARAMETERS
       cap
	   Specifies a symbolic constant indicating a GL capability.

DESCRIPTION
       glIsEnabled returns GL_TRUE if cap is an enabled capability and returns
       GL_FALSE otherwise. Initially all capabilities except GL_DITHER are
       disabled; GL_DITHER is initially enabled.

       The following capabilities are accepted for cap:

       ┌─────────────────────────────────┬─────────────────────────────┐
       │				 │			       │
       │			Constant │			   See │
       │				 │			       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_ALPHA_TEST			 │ glAlphaFunc()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_AUTO_NORMAL			 │ glEvalCoord()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_BLEND			 │ glBlendFunc(), glLogicOp()  │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_CLIP_PLANEi			 │ glClipPlane()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_COLOR_ARRAY			 │ glColorPointer()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_COLOR_LOGIC_OP		 │ glLogicOp()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_COLOR_MATERIAL		 │ glColorMaterial()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_COLOR_SUM			 │ glSecondaryColor()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_COLOR_TABLE			 │ glColorTable()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_CONVOLUTION_1D		 │ glConvolutionFilter1D()     │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_CONVOLUTION_2D		 │ glConvolutionFilter2D()     │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_CULL_FACE			 │ glCullFace()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_DEPTH_TEST			 │ glDepthFunc(),	       │
       │				 │ glDepthRange()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_DITHER			 │ glEnable()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_EDGE_FLAG_ARRAY		 │ glEdgeFlagPointer()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_FOG				 │ glFog()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_FOG_COORD_ARRAY		 │ glFogCoordPointer()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_HISTOGRAM			 │ glHistogram()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_INDEX_ARRAY			 │ glIndexPointer()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_INDEX_LOGIC_OP		 │ glLogicOp()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_LIGHTi			 │ glLightModel(), glLight()   │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_LIGHTING			 │ glMaterial(),	       │
       │				 │ glLightModel(), glLight()   │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_LINE_SMOOTH			 │ glLineWidth()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_LINE_STIPPLE			 │ glLineStipple()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP1_COLOR_4			 │ glMap1()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP1_INDEX			 │ glMap1()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP1_NORMAL			 │ glMap1()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP1_TEXTURE_COORD_1		 │ glMap1()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP1_TEXTURE_COORD_2		 │ glMap1()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP1_TEXTURE_COORD_3		 │ glMap1()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP1_TEXTURE_COORD_4		 │ glMap1()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP2_COLOR_4			 │ glMap2()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP2_INDEX			 │ glMap2()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP2_NORMAL			 │ glMap2()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP2_TEXTURE_COORD_1		 │ glMap2()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP2_TEXTURE_COORD_2		 │ glMap2()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP2_TEXTURE_COORD_3		 │ glMap2()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP2_TEXTURE_COORD_4		 │ glMap2()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP2_VERTEX_3		 │ glMap2()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MAP2_VERTEX_4		 │ glMap2()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MINMAX			 │ glMinmax()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_MULTISAMPLE			 │ glSampleCoverage()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_NORMAL_ARRAY			 │ glNormalPointer()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_NORMALIZE			 │ glNormal()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_POINT_SMOOTH			 │ glPointSize()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_POINT_SPRITE			 │ glEnable()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_POLYGON_SMOOTH		 │ glPolygonMode()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_POLYGON_OFFSET_FILL		 │ glPolygonOffset()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_POLYGON_OFFSET_LINE		 │ glPolygonOffset()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_POLYGON_OFFSET_POINT		 │ glPolygonOffset()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_POLYGON_STIPPLE		 │ glPolygonStipple()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_POST_COLOR_MATRIX_COLOR_TABLE │ glColorTable()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_POST_CONVOLUTION_COLOR_TABLE	 │ glColorTable()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_RESCALE_NORMAL		 │ glNormal()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_SAMPLE_ALPHA_TO_COVERAGE	 │ glSampleCoverage()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_SAMPLE_ALPHA_TO_ONE		 │ glSampleCoverage()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_SAMPLE_COVERAGE		 │ glSampleCoverage()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_SCISSOR_TEST			 │ glScissor()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_SECONDARY_COLOR_ARRAY	 │ glSecondaryColorPointer()   │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_SEPARABLE_2D			 │ glSeparableFilter2D()       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_STENCIL_TEST			 │ glStencilFunc(),	       │
       │				 │ glStencilOp()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_TEXTURE_1D			 │ glTexImage1D()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_TEXTURE_2D			 │ glTexImage2D()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_TEXTURE_3D			 │ glTexImage3D()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_TEXTURE_COORD_ARRAY		 │ glTexCoordPointer()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_TEXTURE_CUBE_MAP		 │ glTexImage2D()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_TEXTURE_GEN_Q		 │ glTexGen()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_TEXTURE_GEN_R		 │ glTexGen()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_TEXTURE_GEN_S		 │ glTexGen()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_TEXTURE_GEN_T		 │ glTexGen()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_VERTEX_ARRAY			 │ glVertexPointer()	       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_VERTEX_PROGRAM_POINT_SIZE	 │ glEnable()		       │
       ├─────────────────────────────────┼─────────────────────────────┤
       │GL_VERTEX_PROGRAM_TWO_SIDE	 │ glEnable()		       │
       └─────────────────────────────────┴─────────────────────────────┘

NOTES
       If an error is generated, glIsEnabled returns 0.

       GL_COLOR_LOGIC_OP, GL_COLOR_ARRAY, GL_EDGE_FLAG_ARRAY, GL_INDEX_ARRAY,
       GL_INDEX_LOGIC_OP, GL_NORMAL_ARRAY, GL_POLYGON_OFFSET_FILL,
       GL_POLYGON_OFFSET_LINE, GL_POLYGON_OFFSET_POINT,
       GL_TEXTURE_COORD_ARRAY, and GL_VERTEX_ARRAY are available only if the
       GL version is 1.1 or greater.

       GL_RESCALE_NORMAL, and GL_TEXTURE_3D are available only if the GL
       version is 1.2 or greater.

       GL_MULTISAMPLE, GL_SAMPLE_ALPHA_TO_COVERAGE, GL_SAMPLE_ALPHA_TO_ONE,
       GL_SAMPLE_COVERAGE, GL_TEXTURE_CUBE_MAP are available only if the GL
       version is 1.3 or greater.

       GL_FOG_COORD_ARRAY and GL_SECONDARY_COLOR_ARRAY are available only if
       the GL version is 1.4 or greater.

       GL_POINT_SPRITE, GL_VERTEX_PROGRAM_POINT_SIZE, and
       GL_VERTEX_PROGRAM_TWO_SIDE are available only if the GL version is 2.0
       or greater.

       GL_COLOR_TABLE, GL_CONVOLUTION_1D, GL_CONVOLUTION_2D, GL_HISTOGRAM,
       GL_MINMAX, GL_POST_COLOR_MATRIX_COLOR_TABLE,
       GL_POST_CONVOLUTION_COLOR_TABLE, and GL_SEPARABLE_2D are available only
       if ARB_imaging is returned when glGet() is called with GL_EXTENSIONS.

       For OpenGL versions 1.3 and greater, or when the ARB_multitexture
       extension is supported, the following parameters return the associated
       value for the active texture unit: GL_TEXTURE_1D, GL_TEXTURE_2D,
       GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP, GL_TEXTURE_GEN_S, GL_TEXTURE_GEN_T,
       GL_TEXTURE_GEN_R, GL_TEXTURE_GEN_Q, GL_TEXTURE_MATRIX, and
       GL_TEXTURE_STACK_DEPTH. Likewise, the following parameters return the
       associated value for the active client texture unit:
       GL_TEXTURE_COORD_ARRAY, GL_TEXTURE_COORD_ARRAY_SIZE,
       GL_TEXTURE_COORD_ARRAY_STRIDE, GL_TEXTURE_COORD_ARRAY_TYPE.

ERRORS
       GL_INVALID_ENUM is generated if cap is not an accepted value.

       GL_INVALID_OPERATION is generated if glIsEnabled is executed between
       the execution of glBegin() and the corresponding execution of glEnd().

SEE ALSO
       glEnable(), glEnableClientState(), glGet()

COPYRIGHT
       Copyright © 1991-2006 Silicon Graphics, Inc. This document is licensed
       under the SGI Free Software B License. For details, see
       http://oss.sgi.com/projects/FreeB/.

AUTHORS
       opengl.org

opengl.org			  04/29/2014		       GLISENABLED(3G)
[top]

List of man pages available for Oracle

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net