Participer au site avec un Tip
Rechercher
 
Bug Suggérer des Améliorations / Corrections
Share Partager sur Facebook Partager sur Twitter
Links Notre chaîne YouTube Notre discord

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Module « PySide6.QtOpenGL »

Classe « QOpenGLFunctions_1_1 »

Informations générales

Héritage

builtins.object
    Object
        QAbstractOpenGLFunctions
            QOpenGLFunctions_1_1

Définition

class QOpenGLFunctions_1_1(QAbstractOpenGLFunctions):

Description [extrait de QOpenGLFunctions_1_1.__doc__]

QOpenGLFunctions_1_1(self) -> None

Constructeur(s)

Signature du constructeur Description
__new__(*args, **kwargs) Create and return a new object. See help(type) for accurate signature. [extrait de __new__.__doc__]
__init__(self) -> None __init__(self) -> None [extrait de __init__.__doc__]

Liste des opérateurs

Opérateurs hérités de la classe object

__eq__, __ge__, __gt__, __le__, __lt__, __ne__

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques Méthodes dépréciées
Signature de la méthodeDescription
__delattr__(self, name) Implement delattr(self, name). [extrait de __delattr__.__doc__]
__setattr__(self, name, value) Implement setattr(self, name, value). [extrait de __setattr__.__doc__]
glAccum(self, op: int, value: float) -> None glAccum(self, op: int, value: float) -> None [extrait de glAccum.__doc__]
glAlphaFunc(self, func: int, ref: float) -> None glAlphaFunc(self, func: int, ref: float) -> None [extrait de glAlphaFunc.__doc__]
glArrayElement(self, i: int) -> None glArrayElement(self, i: int) -> None [extrait de glArrayElement.__doc__]
glBegin(self, mode: int) -> None glBegin(self, mode: int) -> None [extrait de glBegin.__doc__]
glBindTexture(self, target: int, texture: int) -> None glBindTexture(self, target: int, texture: int) -> None [extrait de glBindTexture.__doc__]
glBlendFunc(self, sfactor: int, dfactor: int) -> None glBlendFunc(self, sfactor: int, dfactor: int) -> None [extrait de glBlendFunc.__doc__]
glCallList(self, list: int) -> None glCallList(self, list: int) -> None [extrait de glCallList.__doc__]
glCallLists(self, n: int, type: int, lists: int) -> None glCallLists(self, n: int, type: int, lists: int) -> None [extrait de glCallLists.__doc__]
glClear(self, mask: int) -> None glClear(self, mask: int) -> None [extrait de glClear.__doc__]
glClearAccum(self, red: float, green: float, blue: float, alpha: float) -> None glClearAccum(self, red: float, green: float, blue: float, alpha: float) -> None [extrait de glClearAccum.__doc__]
glClearColor(self, red: float, green: float, blue: float, alpha: float) -> None glClearColor(self, red: float, green: float, blue: float, alpha: float) -> None [extrait de glClearColor.__doc__]
glClearDepth(self, depth: float) -> None glClearDepth(self, depth: float) -> None [extrait de glClearDepth.__doc__]
glClearIndex(self, c: float) -> None glClearIndex(self, c: float) -> None [extrait de glClearIndex.__doc__]
glClearStencil(self, s: int) -> None glClearStencil(self, s: int) -> None [extrait de glClearStencil.__doc__]
glClipPlane(self, plane: int, equation: Sequence[float]) -> None glClipPlane(self, plane: int, equation: Sequence[float]) -> None [extrait de glClipPlane.__doc__]
glColor3b(self, red: int, green: int, blue: int) -> None glColor3b(self, red: int, green: int, blue: int) -> None [extrait de glColor3b.__doc__]
glColor3bv(self, v: bytes) -> None glColor3bv(self, v: bytes) -> None [extrait de glColor3bv.__doc__]
glColor3d(self, red: float, green: float, blue: float) -> None glColor3d(self, red: float, green: float, blue: float) -> None [extrait de glColor3d.__doc__]
glColor3dv(self, v: Sequence[float]) -> None glColor3dv(self, v: Sequence[float]) -> None [extrait de glColor3dv.__doc__]
glColor3f(self, red: float, green: float, blue: float) -> None glColor3f(self, red: float, green: float, blue: float) -> None [extrait de glColor3f.__doc__]
glColor3fv(self, v: Sequence[float]) -> None glColor3fv(self, v: Sequence[float]) -> None [extrait de glColor3fv.__doc__]
glColor3i(self, red: int, green: int, blue: int) -> None glColor3i(self, red: int, green: int, blue: int) -> None [extrait de glColor3i.__doc__]
glColor3iv(self, v: Sequence[int]) -> None glColor3iv(self, v: Sequence[int]) -> None [extrait de glColor3iv.__doc__]
glColor3s(self, red: int, green: int, blue: int) -> None glColor3s(self, red: int, green: int, blue: int) -> None [extrait de glColor3s.__doc__]
glColor3sv(self, v: Sequence[int]) -> None glColor3sv(self, v: Sequence[int]) -> None [extrait de glColor3sv.__doc__]
glColor3ub(self, red: int, green: int, blue: int) -> None glColor3ub(self, red: int, green: int, blue: int) -> None [extrait de glColor3ub.__doc__]
glColor3ubv(self, v: bytes) -> None glColor3ubv(self, v: bytes) -> None [extrait de glColor3ubv.__doc__]
glColor3ui(self, red: int, green: int, blue: int) -> None glColor3ui(self, red: int, green: int, blue: int) -> None [extrait de glColor3ui.__doc__]
glColor3uiv(self, v: Sequence[int]) -> None glColor3uiv(self, v: Sequence[int]) -> None [extrait de glColor3uiv.__doc__]
glColor3us(self, red: int, green: int, blue: int) -> None glColor3us(self, red: int, green: int, blue: int) -> None [extrait de glColor3us.__doc__]
glColor3usv(self, v: Sequence[int]) -> None glColor3usv(self, v: Sequence[int]) -> None [extrait de glColor3usv.__doc__]
glColor4b(self, red: int, green: int, blue: int, alpha: int) -> None glColor4b(self, red: int, green: int, blue: int, alpha: int) -> None [extrait de glColor4b.__doc__]
glColor4bv(self, v: bytes) -> None glColor4bv(self, v: bytes) -> None [extrait de glColor4bv.__doc__]
glColor4d(self, red: float, green: float, blue: float, alpha: float) -> None glColor4d(self, red: float, green: float, blue: float, alpha: float) -> None [extrait de glColor4d.__doc__]
glColor4dv(self, v: Sequence[float]) -> None glColor4dv(self, v: Sequence[float]) -> None [extrait de glColor4dv.__doc__]
glColor4f(self, red: float, green: float, blue: float, alpha: float) -> None glColor4f(self, red: float, green: float, blue: float, alpha: float) -> None [extrait de glColor4f.__doc__]
glColor4fv(self, v: Sequence[float]) -> None glColor4fv(self, v: Sequence[float]) -> None [extrait de glColor4fv.__doc__]
glColor4i(self, red: int, green: int, blue: int, alpha: int) -> None glColor4i(self, red: int, green: int, blue: int, alpha: int) -> None [extrait de glColor4i.__doc__]
glColor4iv(self, v: Sequence[int]) -> None glColor4iv(self, v: Sequence[int]) -> None [extrait de glColor4iv.__doc__]
glColor4s(self, red: int, green: int, blue: int, alpha: int) -> None glColor4s(self, red: int, green: int, blue: int, alpha: int) -> None [extrait de glColor4s.__doc__]
glColor4sv(self, v: Sequence[int]) -> None glColor4sv(self, v: Sequence[int]) -> None [extrait de glColor4sv.__doc__]
glColor4ub(self, red: int, green: int, blue: int, alpha: int) -> None glColor4ub(self, red: int, green: int, blue: int, alpha: int) -> None [extrait de glColor4ub.__doc__]
glColor4ubv(self, v: bytes) -> None glColor4ubv(self, v: bytes) -> None [extrait de glColor4ubv.__doc__]
glColor4ui(self, red: int, green: int, blue: int, alpha: int) -> None glColor4ui(self, red: int, green: int, blue: int, alpha: int) -> None [extrait de glColor4ui.__doc__]
glColor4uiv(self, v: Sequence[int]) -> None glColor4uiv(self, v: Sequence[int]) -> None [extrait de glColor4uiv.__doc__]
glColor4us(self, red: int, green: int, blue: int, alpha: int) -> None glColor4us(self, red: int, green: int, blue: int, alpha: int) -> None [extrait de glColor4us.__doc__]
glColor4usv(self, v: Sequence[int]) -> None glColor4usv(self, v: Sequence[int]) -> None [extrait de glColor4usv.__doc__]
glColorMask(self, red: int, green: int, blue: int, alpha: int) -> None glColorMask(self, red: int, green: int, blue: int, alpha: int) -> None [extrait de glColorMask.__doc__]
glColorMaterial(self, face: int, mode: int) -> None glColorMaterial(self, face: int, mode: int) -> None [extrait de glColorMaterial.__doc__]
glColorPointer(self, size: int, type: int, stride: int, pointer: int) -> None glColorPointer(self, size: int, type: int, stride: int, pointer: int) -> None [extrait de glColorPointer.__doc__]
glCopyPixels(self, x: int, y: int, width: int, height: int, type: int) -> None glCopyPixels(self, x: int, y: int, width: int, height: int, type: int) -> None [extrait de glCopyPixels.__doc__]
glCopyTexImage1D(self, target: int, level: int, internalformat: int, x: int, y: int, width: int, border: int) -> None glCopyTexImage1D(self, target: int, level: int, internalformat: int, x: int, y: int, width: int, border: int) -> None [extrait de glCopyTexImage1D.__doc__]
glCopyTexImage2D(self, target: int, level: int, internalformat: int, x: int, y: int, width: int, height: int, border: int) -> None glCopyTexImage2D(self, target: int, level: int, internalformat: int, x: int, y: int, width: int, height: int, border: int) -> None [extrait de glCopyTexImage2D.__doc__]
glCopyTexSubImage1D(self, target: int, level: int, xoffset: int, x: int, y: int, width: int) -> None glCopyTexSubImage1D(self, target: int, level: int, xoffset: int, x: int, y: int, width: int) -> None [extrait de glCopyTexSubImage1D.__doc__]
glCopyTexSubImage2D(self, target: int, level: int, xoffset: int, yoffset: int, x: int, y: int, width: int, height: int) -> None glCopyTexSubImage2D(self, target: int, level: int, xoffset: int, yoffset: int, x: int, y: int, width: int, height: int) -> None [extrait de glCopyTexSubImage2D.__doc__]
glCullFace(self, mode: int) -> None glCullFace(self, mode: int) -> None [extrait de glCullFace.__doc__]
glDeleteLists(self, list: int, range: int) -> None glDeleteLists(self, list: int, range: int) -> None [extrait de glDeleteLists.__doc__]
glDeleteTextures(self, n: int, textures: Sequence[int]) -> None glDeleteTextures(self, n: int, textures: Sequence[int]) -> None [extrait de glDeleteTextures.__doc__]
glDepthFunc(self, func: int) -> None glDepthFunc(self, func: int) -> None [extrait de glDepthFunc.__doc__]
glDepthMask(self, flag: int) -> None glDepthMask(self, flag: int) -> None [extrait de glDepthMask.__doc__]
glDepthRange(self, nearVal: float, farVal: float) -> None glDepthRange(self, nearVal: float, farVal: float) -> None [extrait de glDepthRange.__doc__]
glDisable(self, cap: int) -> None glDisable(self, cap: int) -> None [extrait de glDisable.__doc__]
glDisableClientState(self, array: int) -> None glDisableClientState(self, array: int) -> None [extrait de glDisableClientState.__doc__]
glDrawArrays(self, mode: int, first: int, count: int) -> None glDrawArrays(self, mode: int, first: int, count: int) -> None [extrait de glDrawArrays.__doc__]
glDrawBuffer(self, mode: int) -> None glDrawBuffer(self, mode: int) -> None [extrait de glDrawBuffer.__doc__]
glDrawElements(self, mode: int, count: int, type: int, indices: int) -> None glDrawElements(self, mode: int, count: int, type: int, indices: int) -> None [extrait de glDrawElements.__doc__]
glDrawPixels(self, width: int, height: int, format: int, type: int, pixels: int) -> None glDrawPixels(self, width: int, height: int, format: int, type: int, pixels: int) -> None [extrait de glDrawPixels.__doc__]
glEdgeFlag(self, flag: int) -> None glEdgeFlag(self, flag: int) -> None [extrait de glEdgeFlag.__doc__]
glEdgeFlagPointer(self, stride: int, pointer: int) -> None glEdgeFlagPointer(self, stride: int, pointer: int) -> None [extrait de glEdgeFlagPointer.__doc__]
glEnable(self, cap: int) -> None glEnable(self, cap: int) -> None [extrait de glEnable.__doc__]
glEnableClientState(self, array: int) -> None glEnableClientState(self, array: int) -> None [extrait de glEnableClientState.__doc__]
glEnd(self) -> None glEnd(self) -> None [extrait de glEnd.__doc__]
glEndList(self) -> None glEndList(self) -> None [extrait de glEndList.__doc__]
glEvalCoord1d(self, u: float) -> None glEvalCoord1d(self, u: float) -> None [extrait de glEvalCoord1d.__doc__]
glEvalCoord1dv(self, u: Sequence[float]) -> None glEvalCoord1dv(self, u: Sequence[float]) -> None [extrait de glEvalCoord1dv.__doc__]
glEvalCoord1f(self, u: float) -> None glEvalCoord1f(self, u: float) -> None [extrait de glEvalCoord1f.__doc__]
glEvalCoord1fv(self, u: Sequence[float]) -> None glEvalCoord1fv(self, u: Sequence[float]) -> None [extrait de glEvalCoord1fv.__doc__]
glEvalCoord2d(self, u: float, v: float) -> None glEvalCoord2d(self, u: float, v: float) -> None [extrait de glEvalCoord2d.__doc__]
glEvalCoord2dv(self, u: Sequence[float]) -> None glEvalCoord2dv(self, u: Sequence[float]) -> None [extrait de glEvalCoord2dv.__doc__]
glEvalCoord2f(self, u: float, v: float) -> None glEvalCoord2f(self, u: float, v: float) -> None [extrait de glEvalCoord2f.__doc__]
glEvalCoord2fv(self, u: Sequence[float]) -> None glEvalCoord2fv(self, u: Sequence[float]) -> None [extrait de glEvalCoord2fv.__doc__]
glEvalMesh1(self, mode: int, i1: int, i2: int) -> None glEvalMesh1(self, mode: int, i1: int, i2: int) -> None [extrait de glEvalMesh1.__doc__]
glEvalMesh2(self, mode: int, i1: int, i2: int, j1: int, j2: int) -> None glEvalMesh2(self, mode: int, i1: int, i2: int, j1: int, j2: int) -> None [extrait de glEvalMesh2.__doc__]
glEvalPoint1(self, i: int) -> None glEvalPoint1(self, i: int) -> None [extrait de glEvalPoint1.__doc__]
glEvalPoint2(self, i: int, j: int) -> None glEvalPoint2(self, i: int, j: int) -> None [extrait de glEvalPoint2.__doc__]
glFinish(self) -> None glFinish(self) -> None [extrait de glFinish.__doc__]
glFlush(self) -> None glFlush(self) -> None [extrait de glFlush.__doc__]
glFogf(self, pname: int, param: float) -> None glFogf(self, pname: int, param: float) -> None [extrait de glFogf.__doc__]
glFogfv(self, pname: int, params: Sequence[float]) -> None glFogfv(self, pname: int, params: Sequence[float]) -> None [extrait de glFogfv.__doc__]
glFogi(self, pname: int, param: int) -> None glFogi(self, pname: int, param: int) -> None [extrait de glFogi.__doc__]
glFogiv(self, pname: int, params: Sequence[int]) -> None glFogiv(self, pname: int, params: Sequence[int]) -> None [extrait de glFogiv.__doc__]
glFrontFace(self, mode: int) -> None glFrontFace(self, mode: int) -> None [extrait de glFrontFace.__doc__]
glFrustum(self, left: float, right: float, bottom: float, top: float, zNear: float, zFar: float) -> None glFrustum(self, left: float, right: float, bottom: float, top: float, zNear: float, zFar: float) -> None [extrait de glFrustum.__doc__]
glGenLists(self, range: int) -> int glGenLists(self, range: int) -> int [extrait de glGenLists.__doc__]
glGetError(self) -> int glGetError(self) -> int [extrait de glGetError.__doc__]
glGetString(self, name: int) -> str glGetString(self, name: int) -> str [extrait de glGetString.__doc__]
glHint(self, target: int, mode: int) -> None glHint(self, target: int, mode: int) -> None [extrait de glHint.__doc__]
glIndexd(self, c: float) -> None glIndexd(self, c: float) -> None [extrait de glIndexd.__doc__]
glIndexdv(self, c: Sequence[float]) -> None glIndexdv(self, c: Sequence[float]) -> None [extrait de glIndexdv.__doc__]
glIndexf(self, c: float) -> None glIndexf(self, c: float) -> None [extrait de glIndexf.__doc__]
glIndexfv(self, c: Sequence[float]) -> None glIndexfv(self, c: Sequence[float]) -> None [extrait de glIndexfv.__doc__]
glIndexi(self, c: int) -> None glIndexi(self, c: int) -> None [extrait de glIndexi.__doc__]
glIndexiv(self, c: Sequence[int]) -> None glIndexiv(self, c: Sequence[int]) -> None [extrait de glIndexiv.__doc__]
glIndexMask(self, mask: int) -> None glIndexMask(self, mask: int) -> None [extrait de glIndexMask.__doc__]
glIndexPointer(self, type: int, stride: int, pointer: int) -> None glIndexPointer(self, type: int, stride: int, pointer: int) -> None [extrait de glIndexPointer.__doc__]
glIndexs(self, c: int) -> None glIndexs(self, c: int) -> None [extrait de glIndexs.__doc__]
glIndexsv(self, c: Sequence[int]) -> None glIndexsv(self, c: Sequence[int]) -> None [extrait de glIndexsv.__doc__]
glIndexub(self, c: int) -> None glIndexub(self, c: int) -> None [extrait de glIndexub.__doc__]
glIndexubv(self, c: bytes) -> None glIndexubv(self, c: bytes) -> None [extrait de glIndexubv.__doc__]
glInitNames(self) -> None glInitNames(self) -> None [extrait de glInitNames.__doc__]
glInterleavedArrays(self, format: int, stride: int, pointer: int) -> None glInterleavedArrays(self, format: int, stride: int, pointer: int) -> None [extrait de glInterleavedArrays.__doc__]
glIsEnabled(self, cap: int) -> int glIsEnabled(self, cap: int) -> int [extrait de glIsEnabled.__doc__]
glIsList(self, list: int) -> int glIsList(self, list: int) -> int [extrait de glIsList.__doc__]
glIsTexture(self, texture: int) -> int glIsTexture(self, texture: int) -> int [extrait de glIsTexture.__doc__]
glLightf(self, light: int, pname: int, param: float) -> None glLightf(self, light: int, pname: int, param: float) -> None [extrait de glLightf.__doc__]
glLightfv(self, light: int, pname: int, params: Sequence[float]) -> None glLightfv(self, light: int, pname: int, params: Sequence[float]) -> None [extrait de glLightfv.__doc__]
glLighti(self, light: int, pname: int, param: int) -> None glLighti(self, light: int, pname: int, param: int) -> None [extrait de glLighti.__doc__]
glLightiv(self, light: int, pname: int, params: Sequence[int]) -> None glLightiv(self, light: int, pname: int, params: Sequence[int]) -> None [extrait de glLightiv.__doc__]
glLightModelf(self, pname: int, param: float) -> None glLightModelf(self, pname: int, param: float) -> None [extrait de glLightModelf.__doc__]
glLightModelfv(self, pname: int, params: Sequence[float]) -> None glLightModelfv(self, pname: int, params: Sequence[float]) -> None [extrait de glLightModelfv.__doc__]
glLightModeli(self, pname: int, param: int) -> None glLightModeli(self, pname: int, param: int) -> None [extrait de glLightModeli.__doc__]
glLightModeliv(self, pname: int, params: Sequence[int]) -> None glLightModeliv(self, pname: int, params: Sequence[int]) -> None [extrait de glLightModeliv.__doc__]
glLineStipple(self, factor: int, pattern: int) -> None glLineStipple(self, factor: int, pattern: int) -> None [extrait de glLineStipple.__doc__]
glLineWidth(self, width: float) -> None glLineWidth(self, width: float) -> None [extrait de glLineWidth.__doc__]
glListBase(self, base: int) -> None glListBase(self, base: int) -> None [extrait de glListBase.__doc__]
glLoadIdentity(self) -> None glLoadIdentity(self) -> None [extrait de glLoadIdentity.__doc__]
glLoadMatrixd(self, m: Sequence[float]) -> None glLoadMatrixd(self, m: Sequence[float]) -> None [extrait de glLoadMatrixd.__doc__]
glLoadMatrixf(self, m: Sequence[float]) -> None glLoadMatrixf(self, m: Sequence[float]) -> None [extrait de glLoadMatrixf.__doc__]
glLoadName(self, name: int) -> None glLoadName(self, name: int) -> None [extrait de glLoadName.__doc__]
glLogicOp(self, opcode: int) -> None glLogicOp(self, opcode: int) -> None [extrait de glLogicOp.__doc__]
glMap1d(self, target: int, u1: float, u2: float, stride: int, order: int, points: Sequence[float]) -> None glMap1d(self, target: int, u1: float, u2: float, stride: int, order: int, points: Sequence[float]) -> None [extrait de glMap1d.__doc__]
glMap1f(self, target: int, u1: float, u2: float, stride: int, order: int, points: Sequence[float]) -> None glMap1f(self, target: int, u1: float, u2: float, stride: int, order: int, points: Sequence[float]) -> None [extrait de glMap1f.__doc__]
glMap2d(self, target: int, u1: float, u2: float, ustride: int, uorder: int, v1: float, v2: float, vstride: int, vorder: int, points: Sequence[float]) -> None glMap2d(self, target: int, u1: float, u2: float, ustride: int, uorder: int, v1: float, v2: float, vstride: int, vorder: int, points: Sequence[float]) -> None [extrait de glMap2d.__doc__]
glMap2f(self, target: int, u1: float, u2: float, ustride: int, uorder: int, v1: float, v2: float, vstride: int, vorder: int, points: Sequence[float]) -> None glMap2f(self, target: int, u1: float, u2: float, ustride: int, uorder: int, v1: float, v2: float, vstride: int, vorder: int, points: Sequence[float]) -> None [extrait de glMap2f.__doc__]
glMapGrid1d(self, un: int, u1: float, u2: float) -> None glMapGrid1d(self, un: int, u1: float, u2: float) -> None [extrait de glMapGrid1d.__doc__]
glMapGrid1f(self, un: int, u1: float, u2: float) -> None glMapGrid1f(self, un: int, u1: float, u2: float) -> None [extrait de glMapGrid1f.__doc__]
glMapGrid2d(self, un: int, u1: float, u2: float, vn: int, v1: float, v2: float) -> None glMapGrid2d(self, un: int, u1: float, u2: float, vn: int, v1: float, v2: float) -> None [extrait de glMapGrid2d.__doc__]
glMapGrid2f(self, un: int, u1: float, u2: float, vn: int, v1: float, v2: float) -> None glMapGrid2f(self, un: int, u1: float, u2: float, vn: int, v1: float, v2: float) -> None [extrait de glMapGrid2f.__doc__]
glMaterialf(self, face: int, pname: int, param: float) -> None glMaterialf(self, face: int, pname: int, param: float) -> None [extrait de glMaterialf.__doc__]
glMaterialfv(self, face: int, pname: int, params: Sequence[float]) -> None glMaterialfv(self, face: int, pname: int, params: Sequence[float]) -> None [extrait de glMaterialfv.__doc__]
glMateriali(self, face: int, pname: int, param: int) -> None glMateriali(self, face: int, pname: int, param: int) -> None [extrait de glMateriali.__doc__]
glMaterialiv(self, face: int, pname: int, params: Sequence[int]) -> None glMaterialiv(self, face: int, pname: int, params: Sequence[int]) -> None [extrait de glMaterialiv.__doc__]
glMatrixMode(self, mode: int) -> None glMatrixMode(self, mode: int) -> None [extrait de glMatrixMode.__doc__]
glMultMatrixd(self, m: Sequence[float]) -> None glMultMatrixd(self, m: Sequence[float]) -> None [extrait de glMultMatrixd.__doc__]
glMultMatrixf(self, m: Sequence[float]) -> None glMultMatrixf(self, m: Sequence[float]) -> None [extrait de glMultMatrixf.__doc__]
glNewList(self, list: int, mode: int) -> None glNewList(self, list: int, mode: int) -> None [extrait de glNewList.__doc__]
glNormal3b(self, nx: int, ny: int, nz: int) -> None glNormal3b(self, nx: int, ny: int, nz: int) -> None [extrait de glNormal3b.__doc__]
glNormal3bv(self, v: bytes) -> None glNormal3bv(self, v: bytes) -> None [extrait de glNormal3bv.__doc__]
glNormal3d(self, nx: float, ny: float, nz: float) -> None glNormal3d(self, nx: float, ny: float, nz: float) -> None [extrait de glNormal3d.__doc__]
glNormal3dv(self, v: Sequence[float]) -> None glNormal3dv(self, v: Sequence[float]) -> None [extrait de glNormal3dv.__doc__]
glNormal3f(self, nx: float, ny: float, nz: float) -> None glNormal3f(self, nx: float, ny: float, nz: float) -> None [extrait de glNormal3f.__doc__]
glNormal3fv(self, v: Sequence[float]) -> None glNormal3fv(self, v: Sequence[float]) -> None [extrait de glNormal3fv.__doc__]
glNormal3i(self, nx: int, ny: int, nz: int) -> None glNormal3i(self, nx: int, ny: int, nz: int) -> None [extrait de glNormal3i.__doc__]
glNormal3iv(self, v: Sequence[int]) -> None glNormal3iv(self, v: Sequence[int]) -> None [extrait de glNormal3iv.__doc__]
glNormal3s(self, nx: int, ny: int, nz: int) -> None glNormal3s(self, nx: int, ny: int, nz: int) -> None [extrait de glNormal3s.__doc__]
glNormal3sv(self, v: Sequence[int]) -> None glNormal3sv(self, v: Sequence[int]) -> None [extrait de glNormal3sv.__doc__]
glNormalPointer(self, type: int, stride: int, pointer: int) -> None glNormalPointer(self, type: int, stride: int, pointer: int) -> None [extrait de glNormalPointer.__doc__]
glOrtho(self, left: float, right: float, bottom: float, top: float, zNear: float, zFar: float) -> None glOrtho(self, left: float, right: float, bottom: float, top: float, zNear: float, zFar: float) -> None [extrait de glOrtho.__doc__]
glPassThrough(self, token: float) -> None glPassThrough(self, token: float) -> None [extrait de glPassThrough.__doc__]
glPixelMapfv(self, map: int, mapsize: int, values: Sequence[float]) -> None glPixelMapfv(self, map: int, mapsize: int, values: Sequence[float]) -> None [extrait de glPixelMapfv.__doc__]
glPixelMapuiv(self, map: int, mapsize: int, values: Sequence[int]) -> None glPixelMapuiv(self, map: int, mapsize: int, values: Sequence[int]) -> None [extrait de glPixelMapuiv.__doc__]
glPixelMapusv(self, map: int, mapsize: int, values: Sequence[int]) -> None glPixelMapusv(self, map: int, mapsize: int, values: Sequence[int]) -> None [extrait de glPixelMapusv.__doc__]
glPixelStoref(self, pname: int, param: float) -> None glPixelStoref(self, pname: int, param: float) -> None [extrait de glPixelStoref.__doc__]
glPixelStorei(self, pname: int, param: int) -> None glPixelStorei(self, pname: int, param: int) -> None [extrait de glPixelStorei.__doc__]
glPixelTransferf(self, pname: int, param: float) -> None glPixelTransferf(self, pname: int, param: float) -> None [extrait de glPixelTransferf.__doc__]
glPixelTransferi(self, pname: int, param: int) -> None glPixelTransferi(self, pname: int, param: int) -> None [extrait de glPixelTransferi.__doc__]
glPixelZoom(self, xfactor: float, yfactor: float) -> None glPixelZoom(self, xfactor: float, yfactor: float) -> None [extrait de glPixelZoom.__doc__]
glPointSize(self, size: float) -> None glPointSize(self, size: float) -> None [extrait de glPointSize.__doc__]
glPolygonMode(self, face: int, mode: int) -> None glPolygonMode(self, face: int, mode: int) -> None [extrait de glPolygonMode.__doc__]
glPolygonOffset(self, factor: float, units: float) -> None glPolygonOffset(self, factor: float, units: float) -> None [extrait de glPolygonOffset.__doc__]
glPopAttrib(self) -> None glPopAttrib(self) -> None [extrait de glPopAttrib.__doc__]
glPopClientAttrib(self) -> None glPopClientAttrib(self) -> None [extrait de glPopClientAttrib.__doc__]
glPopMatrix(self) -> None glPopMatrix(self) -> None [extrait de glPopMatrix.__doc__]
glPopName(self) -> None glPopName(self) -> None [extrait de glPopName.__doc__]
glPrioritizeTextures(self, n: int, textures: Sequence[int], priorities: Sequence[float]) -> None glPrioritizeTextures(self, n: int, textures: Sequence[int], priorities: Sequence[float]) -> None [extrait de glPrioritizeTextures.__doc__]
glPushAttrib(self, mask: int) -> None glPushAttrib(self, mask: int) -> None [extrait de glPushAttrib.__doc__]
glPushClientAttrib(self, mask: int) -> None glPushClientAttrib(self, mask: int) -> None [extrait de glPushClientAttrib.__doc__]
glPushMatrix(self) -> None glPushMatrix(self) -> None [extrait de glPushMatrix.__doc__]
glPushName(self, name: int) -> None glPushName(self, name: int) -> None [extrait de glPushName.__doc__]
glRasterPos2d(self, x: float, y: float) -> None glRasterPos2d(self, x: float, y: float) -> None [extrait de glRasterPos2d.__doc__]
glRasterPos2dv(self, v: Sequence[float]) -> None glRasterPos2dv(self, v: Sequence[float]) -> None [extrait de glRasterPos2dv.__doc__]
glRasterPos2f(self, x: float, y: float) -> None glRasterPos2f(self, x: float, y: float) -> None [extrait de glRasterPos2f.__doc__]
glRasterPos2fv(self, v: Sequence[float]) -> None glRasterPos2fv(self, v: Sequence[float]) -> None [extrait de glRasterPos2fv.__doc__]
glRasterPos2i(self, x: int, y: int) -> None glRasterPos2i(self, x: int, y: int) -> None [extrait de glRasterPos2i.__doc__]
glRasterPos2iv(self, v: Sequence[int]) -> None glRasterPos2iv(self, v: Sequence[int]) -> None [extrait de glRasterPos2iv.__doc__]
glRasterPos2s(self, x: int, y: int) -> None glRasterPos2s(self, x: int, y: int) -> None [extrait de glRasterPos2s.__doc__]
glRasterPos2sv(self, v: Sequence[int]) -> None glRasterPos2sv(self, v: Sequence[int]) -> None [extrait de glRasterPos2sv.__doc__]
glRasterPos3d(self, x: float, y: float, z: float) -> None glRasterPos3d(self, x: float, y: float, z: float) -> None [extrait de glRasterPos3d.__doc__]
glRasterPos3dv(self, v: Sequence[float]) -> None glRasterPos3dv(self, v: Sequence[float]) -> None [extrait de glRasterPos3dv.__doc__]
glRasterPos3f(self, x: float, y: float, z: float) -> None glRasterPos3f(self, x: float, y: float, z: float) -> None [extrait de glRasterPos3f.__doc__]
glRasterPos3fv(self, v: Sequence[float]) -> None glRasterPos3fv(self, v: Sequence[float]) -> None [extrait de glRasterPos3fv.__doc__]
glRasterPos3i(self, x: int, y: int, z: int) -> None glRasterPos3i(self, x: int, y: int, z: int) -> None [extrait de glRasterPos3i.__doc__]
glRasterPos3iv(self, v: Sequence[int]) -> None glRasterPos3iv(self, v: Sequence[int]) -> None [extrait de glRasterPos3iv.__doc__]
glRasterPos3s(self, x: int, y: int, z: int) -> None glRasterPos3s(self, x: int, y: int, z: int) -> None [extrait de glRasterPos3s.__doc__]
glRasterPos3sv(self, v: Sequence[int]) -> None glRasterPos3sv(self, v: Sequence[int]) -> None [extrait de glRasterPos3sv.__doc__]
glRasterPos4d(self, x: float, y: float, z: float, w: float) -> None glRasterPos4d(self, x: float, y: float, z: float, w: float) -> None [extrait de glRasterPos4d.__doc__]
glRasterPos4dv(self, v: Sequence[float]) -> None glRasterPos4dv(self, v: Sequence[float]) -> None [extrait de glRasterPos4dv.__doc__]
glRasterPos4f(self, x: float, y: float, z: float, w: float) -> None glRasterPos4f(self, x: float, y: float, z: float, w: float) -> None [extrait de glRasterPos4f.__doc__]
glRasterPos4fv(self, v: Sequence[float]) -> None glRasterPos4fv(self, v: Sequence[float]) -> None [extrait de glRasterPos4fv.__doc__]
glRasterPos4i(self, x: int, y: int, z: int, w: int) -> None glRasterPos4i(self, x: int, y: int, z: int, w: int) -> None [extrait de glRasterPos4i.__doc__]
glRasterPos4iv(self, v: Sequence[int]) -> None glRasterPos4iv(self, v: Sequence[int]) -> None [extrait de glRasterPos4iv.__doc__]
glRasterPos4s(self, x: int, y: int, z: int, w: int) -> None glRasterPos4s(self, x: int, y: int, z: int, w: int) -> None [extrait de glRasterPos4s.__doc__]
glRasterPos4sv(self, v: Sequence[int]) -> None glRasterPos4sv(self, v: Sequence[int]) -> None [extrait de glRasterPos4sv.__doc__]
glReadBuffer(self, mode: int) -> None glReadBuffer(self, mode: int) -> None [extrait de glReadBuffer.__doc__]
glRectd(self, x1: float, y1: float, x2: float, y2: float) -> None glRectd(self, x1: float, y1: float, x2: float, y2: float) -> None [extrait de glRectd.__doc__]
glRectdv(self, v1: Sequence[float], v2: Sequence[float]) -> None glRectdv(self, v1: Sequence[float], v2: Sequence[float]) -> None [extrait de glRectdv.__doc__]
glRectf(self, x1: float, y1: float, x2: float, y2: float) -> None glRectf(self, x1: float, y1: float, x2: float, y2: float) -> None [extrait de glRectf.__doc__]
glRectfv(self, v1: Sequence[float], v2: Sequence[float]) -> None glRectfv(self, v1: Sequence[float], v2: Sequence[float]) -> None [extrait de glRectfv.__doc__]
glRecti(self, x1: int, y1: int, x2: int, y2: int) -> None glRecti(self, x1: int, y1: int, x2: int, y2: int) -> None [extrait de glRecti.__doc__]
glRectiv(self, v1: Sequence[int], v2: Sequence[int]) -> None glRectiv(self, v1: Sequence[int], v2: Sequence[int]) -> None [extrait de glRectiv.__doc__]
glRects(self, x1: int, y1: int, x2: int, y2: int) -> None glRects(self, x1: int, y1: int, x2: int, y2: int) -> None [extrait de glRects.__doc__]
glRectsv(self, v1: Sequence[int], v2: Sequence[int]) -> None glRectsv(self, v1: Sequence[int], v2: Sequence[int]) -> None [extrait de glRectsv.__doc__]
glRenderMode(self, mode: int) -> int glRenderMode(self, mode: int) -> int [extrait de glRenderMode.__doc__]
glRotated(self, angle: float, x: float, y: float, z: float) -> None glRotated(self, angle: float, x: float, y: float, z: float) -> None [extrait de glRotated.__doc__]
glRotatef(self, angle: float, x: float, y: float, z: float) -> None glRotatef(self, angle: float, x: float, y: float, z: float) -> None [extrait de glRotatef.__doc__]
glScaled(self, x: float, y: float, z: float) -> None glScaled(self, x: float, y: float, z: float) -> None [extrait de glScaled.__doc__]
glScalef(self, x: float, y: float, z: float) -> None glScalef(self, x: float, y: float, z: float) -> None [extrait de glScalef.__doc__]
glScissor(self, x: int, y: int, width: int, height: int) -> None glScissor(self, x: int, y: int, width: int, height: int) -> None [extrait de glScissor.__doc__]
glShadeModel(self, mode: int) -> None glShadeModel(self, mode: int) -> None [extrait de glShadeModel.__doc__]
glStencilFunc(self, func: int, ref: int, mask: int) -> None glStencilFunc(self, func: int, ref: int, mask: int) -> None [extrait de glStencilFunc.__doc__]
glStencilMask(self, mask: int) -> None glStencilMask(self, mask: int) -> None [extrait de glStencilMask.__doc__]
glStencilOp(self, fail: int, zfail: int, zpass: int) -> None glStencilOp(self, fail: int, zfail: int, zpass: int) -> None [extrait de glStencilOp.__doc__]
glTexCoord1d(self, s: float) -> None glTexCoord1d(self, s: float) -> None [extrait de glTexCoord1d.__doc__]
glTexCoord1dv(self, v: Sequence[float]) -> None glTexCoord1dv(self, v: Sequence[float]) -> None [extrait de glTexCoord1dv.__doc__]
glTexCoord1f(self, s: float) -> None glTexCoord1f(self, s: float) -> None [extrait de glTexCoord1f.__doc__]
glTexCoord1fv(self, v: Sequence[float]) -> None glTexCoord1fv(self, v: Sequence[float]) -> None [extrait de glTexCoord1fv.__doc__]
glTexCoord1i(self, s: int) -> None glTexCoord1i(self, s: int) -> None [extrait de glTexCoord1i.__doc__]
glTexCoord1iv(self, v: Sequence[int]) -> None glTexCoord1iv(self, v: Sequence[int]) -> None [extrait de glTexCoord1iv.__doc__]
glTexCoord1s(self, s: int) -> None glTexCoord1s(self, s: int) -> None [extrait de glTexCoord1s.__doc__]
glTexCoord1sv(self, v: Sequence[int]) -> None glTexCoord1sv(self, v: Sequence[int]) -> None [extrait de glTexCoord1sv.__doc__]
glTexCoord2d(self, s: float, t: float) -> None glTexCoord2d(self, s: float, t: float) -> None [extrait de glTexCoord2d.__doc__]
glTexCoord2dv(self, v: Sequence[float]) -> None glTexCoord2dv(self, v: Sequence[float]) -> None [extrait de glTexCoord2dv.__doc__]
glTexCoord2f(self, s: float, t: float) -> None glTexCoord2f(self, s: float, t: float) -> None [extrait de glTexCoord2f.__doc__]
glTexCoord2fv(self, v: Sequence[float]) -> None glTexCoord2fv(self, v: Sequence[float]) -> None [extrait de glTexCoord2fv.__doc__]
glTexCoord2i(self, s: int, t: int) -> None glTexCoord2i(self, s: int, t: int) -> None [extrait de glTexCoord2i.__doc__]
glTexCoord2iv(self, v: Sequence[int]) -> None glTexCoord2iv(self, v: Sequence[int]) -> None [extrait de glTexCoord2iv.__doc__]
glTexCoord2s(self, s: int, t: int) -> None glTexCoord2s(self, s: int, t: int) -> None [extrait de glTexCoord2s.__doc__]
glTexCoord2sv(self, v: Sequence[int]) -> None glTexCoord2sv(self, v: Sequence[int]) -> None [extrait de glTexCoord2sv.__doc__]
glTexCoord3d(self, s: float, t: float, r: float) -> None glTexCoord3d(self, s: float, t: float, r: float) -> None [extrait de glTexCoord3d.__doc__]
glTexCoord3dv(self, v: Sequence[float]) -> None glTexCoord3dv(self, v: Sequence[float]) -> None [extrait de glTexCoord3dv.__doc__]
glTexCoord3f(self, s: float, t: float, r: float) -> None glTexCoord3f(self, s: float, t: float, r: float) -> None [extrait de glTexCoord3f.__doc__]
glTexCoord3fv(self, v: Sequence[float]) -> None glTexCoord3fv(self, v: Sequence[float]) -> None [extrait de glTexCoord3fv.__doc__]
glTexCoord3i(self, s: int, t: int, r: int) -> None glTexCoord3i(self, s: int, t: int, r: int) -> None [extrait de glTexCoord3i.__doc__]
glTexCoord3iv(self, v: Sequence[int]) -> None glTexCoord3iv(self, v: Sequence[int]) -> None [extrait de glTexCoord3iv.__doc__]
glTexCoord3s(self, s: int, t: int, r: int) -> None glTexCoord3s(self, s: int, t: int, r: int) -> None [extrait de glTexCoord3s.__doc__]
glTexCoord3sv(self, v: Sequence[int]) -> None glTexCoord3sv(self, v: Sequence[int]) -> None [extrait de glTexCoord3sv.__doc__]
glTexCoord4d(self, s: float, t: float, r: float, q: float) -> None glTexCoord4d(self, s: float, t: float, r: float, q: float) -> None [extrait de glTexCoord4d.__doc__]
glTexCoord4dv(self, v: Sequence[float]) -> None glTexCoord4dv(self, v: Sequence[float]) -> None [extrait de glTexCoord4dv.__doc__]
glTexCoord4f(self, s: float, t: float, r: float, q: float) -> None glTexCoord4f(self, s: float, t: float, r: float, q: float) -> None [extrait de glTexCoord4f.__doc__]
glTexCoord4fv(self, v: Sequence[float]) -> None glTexCoord4fv(self, v: Sequence[float]) -> None [extrait de glTexCoord4fv.__doc__]
glTexCoord4i(self, s: int, t: int, r: int, q: int) -> None glTexCoord4i(self, s: int, t: int, r: int, q: int) -> None [extrait de glTexCoord4i.__doc__]
glTexCoord4iv(self, v: Sequence[int]) -> None glTexCoord4iv(self, v: Sequence[int]) -> None [extrait de glTexCoord4iv.__doc__]
glTexCoord4s(self, s: int, t: int, r: int, q: int) -> None glTexCoord4s(self, s: int, t: int, r: int, q: int) -> None [extrait de glTexCoord4s.__doc__]
glTexCoord4sv(self, v: Sequence[int]) -> None glTexCoord4sv(self, v: Sequence[int]) -> None [extrait de glTexCoord4sv.__doc__]
glTexCoordPointer(self, size: int, type: int, stride: int, pointer: int) -> None glTexCoordPointer(self, size: int, type: int, stride: int, pointer: int) -> None [extrait de glTexCoordPointer.__doc__]
glTexEnvf(self, target: int, pname: int, param: float) -> None glTexEnvf(self, target: int, pname: int, param: float) -> None [extrait de glTexEnvf.__doc__]
glTexEnvfv(self, target: int, pname: int, params: Sequence[float]) -> None glTexEnvfv(self, target: int, pname: int, params: Sequence[float]) -> None [extrait de glTexEnvfv.__doc__]
glTexEnvi(self, target: int, pname: int, param: int) -> None glTexEnvi(self, target: int, pname: int, param: int) -> None [extrait de glTexEnvi.__doc__]
glTexEnviv(self, target: int, pname: int, params: Sequence[int]) -> None glTexEnviv(self, target: int, pname: int, params: Sequence[int]) -> None [extrait de glTexEnviv.__doc__]
glTexGend(self, coord: int, pname: int, param: float) -> None glTexGend(self, coord: int, pname: int, param: float) -> None [extrait de glTexGend.__doc__]
glTexGendv(self, coord: int, pname: int, params: Sequence[float]) -> None glTexGendv(self, coord: int, pname: int, params: Sequence[float]) -> None [extrait de glTexGendv.__doc__]
glTexGenf(self, coord: int, pname: int, param: float) -> None glTexGenf(self, coord: int, pname: int, param: float) -> None [extrait de glTexGenf.__doc__]
glTexGenfv(self, coord: int, pname: int, params: Sequence[float]) -> None glTexGenfv(self, coord: int, pname: int, params: Sequence[float]) -> None [extrait de glTexGenfv.__doc__]
glTexGeni(self, coord: int, pname: int, param: int) -> None glTexGeni(self, coord: int, pname: int, param: int) -> None [extrait de glTexGeni.__doc__]
glTexGeniv(self, coord: int, pname: int, params: Sequence[int]) -> None glTexGeniv(self, coord: int, pname: int, params: Sequence[int]) -> None [extrait de glTexGeniv.__doc__]
glTexImage1D(self, target: int, level: int, internalformat: int, width: int, border: int, format: int, type: int, pixels: int) -> None glTexImage1D(self, target: int, level: int, internalformat: int, width: int, border: int, format: int, type: int, pixels: int) -> None [extrait de glTexImage1D.__doc__]
glTexImage2D(self, target: int, level: int, internalformat: int, width: int, height: int, border: int, format: int, type: int, pixels: int) -> None glTexImage2D(self, target: int, level: int, internalformat: int, width: int, height: int, border: int, format: int, type: int, pixels: int) -> None [extrait de glTexImage2D.__doc__]
glTexParameterf(self, target: int, pname: int, param: float) -> None glTexParameterf(self, target: int, pname: int, param: float) -> None [extrait de glTexParameterf.__doc__]
glTexParameterfv(self, target: int, pname: int, params: Sequence[float]) -> None glTexParameterfv(self, target: int, pname: int, params: Sequence[float]) -> None [extrait de glTexParameterfv.__doc__]
glTexParameteri(self, target: int, pname: int, param: int) -> None glTexParameteri(self, target: int, pname: int, param: int) -> None [extrait de glTexParameteri.__doc__]
glTexParameteriv(self, target: int, pname: int, params: Sequence[int]) -> None glTexParameteriv(self, target: int, pname: int, params: Sequence[int]) -> None [extrait de glTexParameteriv.__doc__]
glTexSubImage1D(self, target: int, level: int, xoffset: int, width: int, format: int, type: int, pixels: int) -> None glTexSubImage1D(self, target: int, level: int, xoffset: int, width: int, format: int, type: int, pixels: int) -> None [extrait de glTexSubImage1D.__doc__]
glTexSubImage2D(self, target: int, level: int, xoffset: int, yoffset: int, width: int, height: int, format: int, type: int, pixels: int) -> None glTexSubImage2D(self, target: int, level: int, xoffset: int, yoffset: int, width: int, height: int, format: int, type: int, pixels: int) -> None [extrait de glTexSubImage2D.__doc__]
glTranslated(self, x: float, y: float, z: float) -> None glTranslated(self, x: float, y: float, z: float) -> None [extrait de glTranslated.__doc__]
glTranslatef(self, x: float, y: float, z: float) -> None glTranslatef(self, x: float, y: float, z: float) -> None [extrait de glTranslatef.__doc__]
glVertex2d(self, x: float, y: float) -> None glVertex2d(self, x: float, y: float) -> None [extrait de glVertex2d.__doc__]
glVertex2dv(self, v: Sequence[float]) -> None glVertex2dv(self, v: Sequence[float]) -> None [extrait de glVertex2dv.__doc__]
glVertex2f(self, x: float, y: float) -> None glVertex2f(self, x: float, y: float) -> None [extrait de glVertex2f.__doc__]
glVertex2fv(self, v: Sequence[float]) -> None glVertex2fv(self, v: Sequence[float]) -> None [extrait de glVertex2fv.__doc__]
glVertex2i(self, x: int, y: int) -> None glVertex2i(self, x: int, y: int) -> None [extrait de glVertex2i.__doc__]
glVertex2iv(self, v: Sequence[int]) -> None glVertex2iv(self, v: Sequence[int]) -> None [extrait de glVertex2iv.__doc__]
glVertex2s(self, x: int, y: int) -> None glVertex2s(self, x: int, y: int) -> None [extrait de glVertex2s.__doc__]
glVertex2sv(self, v: Sequence[int]) -> None glVertex2sv(self, v: Sequence[int]) -> None [extrait de glVertex2sv.__doc__]
glVertex3d(self, x: float, y: float, z: float) -> None glVertex3d(self, x: float, y: float, z: float) -> None [extrait de glVertex3d.__doc__]
glVertex3dv(self, v: Sequence[float]) -> None glVertex3dv(self, v: Sequence[float]) -> None [extrait de glVertex3dv.__doc__]
glVertex3f(self, x: float, y: float, z: float) -> None glVertex3f(self, x: float, y: float, z: float) -> None [extrait de glVertex3f.__doc__]
glVertex3fv(self, v: Sequence[float]) -> None glVertex3fv(self, v: Sequence[float]) -> None [extrait de glVertex3fv.__doc__]
glVertex3i(self, x: int, y: int, z: int) -> None glVertex3i(self, x: int, y: int, z: int) -> None [extrait de glVertex3i.__doc__]
glVertex3iv(self, v: Sequence[int]) -> None glVertex3iv(self, v: Sequence[int]) -> None [extrait de glVertex3iv.__doc__]
glVertex3s(self, x: int, y: int, z: int) -> None glVertex3s(self, x: int, y: int, z: int) -> None [extrait de glVertex3s.__doc__]
glVertex3sv(self, v: Sequence[int]) -> None glVertex3sv(self, v: Sequence[int]) -> None [extrait de glVertex3sv.__doc__]
glVertex4d(self, x: float, y: float, z: float, w: float) -> None glVertex4d(self, x: float, y: float, z: float, w: float) -> None [extrait de glVertex4d.__doc__]
glVertex4dv(self, v: Sequence[float]) -> None glVertex4dv(self, v: Sequence[float]) -> None [extrait de glVertex4dv.__doc__]
glVertex4f(self, x: float, y: float, z: float, w: float) -> None glVertex4f(self, x: float, y: float, z: float, w: float) -> None [extrait de glVertex4f.__doc__]
glVertex4fv(self, v: Sequence[float]) -> None glVertex4fv(self, v: Sequence[float]) -> None [extrait de glVertex4fv.__doc__]
glVertex4i(self, x: int, y: int, z: int, w: int) -> None glVertex4i(self, x: int, y: int, z: int, w: int) -> None [extrait de glVertex4i.__doc__]
glVertex4iv(self, v: Sequence[int]) -> None glVertex4iv(self, v: Sequence[int]) -> None [extrait de glVertex4iv.__doc__]
glVertex4s(self, x: int, y: int, z: int, w: int) -> None glVertex4s(self, x: int, y: int, z: int, w: int) -> None [extrait de glVertex4s.__doc__]
glVertex4sv(self, v: Sequence[int]) -> None glVertex4sv(self, v: Sequence[int]) -> None [extrait de glVertex4sv.__doc__]
glVertexPointer(self, size: int, type: int, stride: int, pointer: int) -> None glVertexPointer(self, size: int, type: int, stride: int, pointer: int) -> None [extrait de glVertexPointer.__doc__]
glViewport(self, x: int, y: int, width: int, height: int) -> None glViewport(self, x: int, y: int, width: int, height: int) -> None [extrait de glViewport.__doc__]
initializeOpenGLFunctions(self) -> bool initializeOpenGLFunctions(self) -> bool [extrait de initializeOpenGLFunctions.__doc__]

Méthodes héritées de la classe QAbstractOpenGLFunctions

__init_subclass__, __subclasshook__, isInitialized, owningContext, setOwningContext

Méthodes héritées de la classe Object

__getattribute__, __init_subclass__, __subclasshook__

Méthodes héritées de la classe object

__dir__, __format__, __hash__, __reduce__, __reduce_ex__, __repr__, __sizeof__, __str__




Le tutoriel Python complet (Text+Vidéos)
Le tutoriel Python en vidéos
Evaluez vos compétences en Python