| |
- glActiveTexture(...)
- glActiveTexture( GLenum(texture) ) -> None
- glClientActiveTexture(...)
- glClientActiveTexture( GLenum(texture) ) -> None
glCompressedTexImage1D( target,level,internalformat,width,border,data )
pyConverters: target=None, level=None, internalformat=None, width= - asIntConverter(value, *args)
, border=None, data=None
cConverters: target=None, level=None, internalformat=None, width=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x823e56c>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexImage1D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None glCompressedTexImage2D( target,level,internalformat,width,height,border,data )
pyConverters: target=None, level=None, internalformat=None, width= - asIntConverter(value, *args)
, height= - asIntConverter(value, *args)
, border=None, data=None
cConverters: target=None, level=None, internalformat=None, width=None, height=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x823e7ec>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexImage2D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None glCompressedTexImage3D( target,level,internalformat,width,height,depth,border,data )
pyConverters: target=None, level=None, internalformat=None, width= - asIntConverter(value, *args)
, height= - asIntConverter(value, *args)
, depth= - asIntConverter(value, *args)
, border=None, data=None
cConverters: target=None, level=None, internalformat=None, width=None, height=None, depth=None, border=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x828abcc>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexImage3D( GLenum(target), GLint(level), GLenum(internalformat), GLsizei(width), GLsizei(height), GLsizei(depth), GLint(border), GLsizei(imageSize), c_void_p(data) ) -> None glCompressedTexSubImage1D( target,level,xoffset,width,format,data )
cConverters: target=None, level=None, xoffset=None, width=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x823e60c>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexSubImage1D( GLenum(target), GLint(level), GLint(xoffset), GLsizei(width), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None glCompressedTexSubImage2D( target,level,xoffset,yoffset,width,height,format,data )
pyConverters: target=None, level=None, xoffset= - asIntConverter(value, *args)
, yoffset= - asIntConverter(value, *args)
, width= - asIntConverter(value, *args)
, height= - asIntConverter(value, *args)
, format=None, data=None
cConverters: target=None, level=None, xoffset=None, yoffset=None, width=None, height=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x828a7ec>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexSubImage2D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLsizei(width), GLsizei(height), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None glCompressedTexSubImage3D( target,level,xoffset,yoffset,zoffset,width,height,depth,format,data )
pyConverters: target=None, level=None, xoffset= - asIntConverter(value, *args)
, yoffset= - asIntConverter(value, *args)
, zoffset= - asIntConverter(value, *args)
, width= - asIntConverter(value, *args)
, height= - asIntConverter(value, *args)
, depth= - asIntConverter(value, *args)
, format=None, data=None
cConverters: target=None, level=None, xoffset=None, yoffset=None, zoffset=None, width=None, height=None, depth=None, format=None, imageSize=<OpenGL.GL.images.CompressedImageConverter object at 0x828a6ac>, data=None
cResolvers: Not Used
storeValues: Not Used
returnValues: Not Used
Wrapping Operation: glCompressedTexSubImage3D( GLenum(target), GLint(level), GLint(xoffset), GLint(yoffset), GLint(zoffset), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLsizei(imageSize), c_void_p(data) ) -> None glLoadTransposeMatrixd( m )
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x878243c>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLoadTransposeMatrixd( GLdoubleArray(m) ) -> None glLoadTransposeMatrixf( m )
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x878257c>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glLoadTransposeMatrixf( GLfloatArray(m) ) -> None glMultTransposeMatrixd( m )
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x87824dc>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultTransposeMatrixd( GLdoubleArray(m) ) -> None glMultTransposeMatrixf( m )
cConverters: m=<OpenGL.converters.getPyArgsName object at 0x878261c>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultTransposeMatrixf( GLfloatArray(m) ) -> None - glMultiTexCoord1d(...)
- glMultiTexCoord1d( GLenum(target), GLdouble(s) ) -> None
glMultiTexCoord1dv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851ca04>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord1dv( GLenum(target), GLdoubleArray(v) ) -> None - glMultiTexCoord1f(...)
- glMultiTexCoord1f( GLenum(target), GLfloat(s) ) -> None
glMultiTexCoord1fv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cc84>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord1fv( GLenum(target), GLfloatArray(v) ) -> None - glMultiTexCoord1i(...)
- glMultiTexCoord1i( GLenum(target), GLint(s) ) -> None
glMultiTexCoord1iv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cf04>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord1iv( GLenum(target), GLintArray(v) ) -> None - glMultiTexCoord1s(...)
- glMultiTexCoord1s( GLenum(target), GLshort(s) ) -> None
glMultiTexCoord1sv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x87821bc>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord1sv( GLenum(target), GLshortArray(v) ) -> None - glMultiTexCoord2d(...)
- glMultiTexCoord2d( GLenum(target), GLdouble(s), GLdouble(t) ) -> None
glMultiTexCoord2dv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851caa4>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord2dv( GLenum(target), GLdoubleArray(v) ) -> None - glMultiTexCoord2f(...)
- glMultiTexCoord2f( GLenum(target), GLfloat(s), GLfloat(t) ) -> None
glMultiTexCoord2fv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cd24>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord2fv( GLenum(target), GLfloatArray(v) ) -> None - glMultiTexCoord2i(...)
- glMultiTexCoord2i( GLenum(target), GLint(s), GLint(t) ) -> None
glMultiTexCoord2iv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cfa4>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord2iv( GLenum(target), GLintArray(v) ) -> None - glMultiTexCoord2s(...)
- glMultiTexCoord2s( GLenum(target), GLshort(s), GLshort(t) ) -> None
glMultiTexCoord2sv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878225c>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord2sv( GLenum(target), GLshortArray(v) ) -> None - glMultiTexCoord3d(...)
- glMultiTexCoord3d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r) ) -> None
glMultiTexCoord3dv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cb44>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord3dv( GLenum(target), GLdoubleArray(v) ) -> None - glMultiTexCoord3f(...)
- glMultiTexCoord3f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r) ) -> None
glMultiTexCoord3fv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cdc4>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord3fv( GLenum(target), GLfloatArray(v) ) -> None - glMultiTexCoord3i(...)
- glMultiTexCoord3i( GLenum(target), GLint(s), GLint(t), GLint(r) ) -> None
glMultiTexCoord3iv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878207c>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord3iv( GLenum(target), GLintArray(v) ) -> None - glMultiTexCoord3s(...)
- glMultiTexCoord3s( GLenum(target), GLshort(s), GLshort(t), GLshort(r) ) -> None
glMultiTexCoord3sv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x87822fc>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord3sv( GLenum(target), GLshortArray(v) ) -> None - glMultiTexCoord4d(...)
- glMultiTexCoord4d( GLenum(target), GLdouble(s), GLdouble(t), GLdouble(r), GLdouble(q) ) -> None
glMultiTexCoord4dv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851cbe4>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord4dv( GLenum(target), GLdoubleArray(v) ) -> None - glMultiTexCoord4f(...)
- glMultiTexCoord4f( GLenum(target), GLfloat(s), GLfloat(t), GLfloat(r), GLfloat(q) ) -> None
glMultiTexCoord4fv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x851ce64>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord4fv( GLenum(target), GLfloatArray(v) ) -> None - glMultiTexCoord4i(...)
- glMultiTexCoord4i( GLenum(target), GLint(s), GLint(t), GLint(r), GLint(q) ) -> None
glMultiTexCoord4iv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878211c>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord4iv( GLenum(target), GLintArray(v) ) -> None - glMultiTexCoord4s(...)
- glMultiTexCoord4s( GLenum(target), GLshort(s), GLshort(t), GLshort(r), GLshort(q) ) -> None
glMultiTexCoord4sv( target,v )
pyConverters: target=None, v= - asArraySize(incoming, function, args)
cConverters: target=None, v=<OpenGL.converters.getPyArgsName object at 0x878239c>
cResolvers: Not Used
storeValues: Not Used
returnValues: - returnPointer(result, baseOperation, pyArgs, cArgs)
- Return the converted object as result of function
Note: this is a hack that always returns pyArgs[0]!
Wrapping Operation: glMultiTexCoord4sv( GLenum(target), GLshortArray(v) ) -> None - glSampleCoverage(...)
- glSampleCoverage( GLclampf(value), GLboolean(invert) ) -> None
|