from __builtin__ import object as _object
from __builtin__ import property as _swig_property

if False:
    from typing import Dict, List, Tuple, Union, Optional


class RV_PIXEL(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    @property
    def a(self): pass

    @property
    def b(self): pass

    @property
    def g(self): pass

    @property
    def r(self): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class RV_AOV(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    @property
    def name(self): pass

    @property
    def numberOfChannels(self): pass

    @property
    def pPixels(self): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MLightLinks(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def getIgnoredLights(self, *args): pass

    def getIgnoredObjects(self, *args): pass

    def getLinkedLights(self, *args): pass

    def getLinkedObjects(self, *args): pass

    def getShadowIgnoredLights(self, *args): pass

    def getShadowIgnoredObjects(self, *args): pass

    def getShadowLinkedLights(self, *args): pass

    def getShadowLinkedObjects(self, *args): pass

    def parseLinks(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MRenderingInfo(_object):
    def __getattr__(self, name): pass

    def __init__(self, *args, **kwargs): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def cameraPath(self, *args): pass

    def height(self, *args): pass

    def originX(self, *args): pass

    def originY(self, *args): pass

    def projectionMatrix(self, *args): pass

    def renderTarget(self, *args): pass

    def renderingAPI(self, *args): pass

    def renderingVersion(self, *args): pass

    def viewMatrix(self, *args): pass

    def width(self, *args): pass

    __dict__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MVaryingParameter(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def addElement(self, *args): pass

    def assign(self, *args): pass

    def destinationSet(self, *args): pass

    def dimension(self, *args): pass

    def getBuffer(self, *args): pass

    def getElement(self, *args): pass

    def getElementSize(self, *args): pass

    def getMaximumStride(self, *args): pass

    def getSourceSetName(self, *args): pass

    def getSourceType(self, *args): pass

    def getUpdateId(self, *args): pass

    def name(self, *args): pass

    def numElements(self, *args): pass

    def removeElements(self, *args): pass

    def semantic(self, *args): pass

    def semanticName(self, *args): pass

    def setSource(self, *args): pass

    def type(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kBinormal = 8

    kChar = 3

    kColor = 4

    kDouble = 2

    kFloat = 1

    kInt16 = 5

    kInt32 = 7

    kInvalidParameter = -1

    kNoSemantic = 0

    kNormal = 2

    kPosition = 1

    kStructure = 0

    kTangent = 7

    kTexCoord = 3

    kUnsignedChar = 4

    kUnsignedInt16 = 6

    kUnsignedInt32 = 8

    kWeight = 5


class MRenderView(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    @staticmethod
    def className(*args, **kwargs): pass

    @staticmethod
    def doesRenderEditorExist(*args, **kwargs): pass

    @staticmethod
    def endRender(*args, **kwargs): pass

    @staticmethod
    def getRenderRegion(*args, **kwargs): pass

    @staticmethod
    def refresh(*args, **kwargs): pass

    @staticmethod
    def setCurrentCamera(*args, **kwargs): pass

    @staticmethod
    def setDrawTileBoundary(*args, **kwargs): pass

    @staticmethod
    def startRegionRender(*args, **kwargs): pass

    @staticmethod
    def startRender(*args, **kwargs): pass

    @staticmethod
    def updatePixels(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MGeometryList(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def addLast(self, *args): pass

    def cullMode(self, *args): pass

    def geometry(self, *args): pass

    def isDone(self, *args): pass

    def length(self, *args): pass

    def next(self, *args): pass

    def objectToWorldMatrix(self, *args): pass

    def path(self, *args): pass

    def projectionMatrix(self, *args): pass

    def reset(self, *args): pass

    def setCurrentElement(self, *args): pass

    def viewMatrix(self, *args): pass

    @property
    def MSetupFlags(self): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kAll = -1

    kCullCCW = 2

    kCullCW = 1

    kCullNone = 0

    kCulling = 4

    kFixedFunctionLighting = 2

    kMatrices = 1

    kNone = 0


class MSwatchRenderRegister(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    @staticmethod
    def registerSwatchRender(*args, **kwargs): pass

    @staticmethod
    def unregisterSwatchRender(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MHwrCallback(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def deviceDeleted(self, *args): pass

    def deviceLost(self, *args): pass

    def deviceNew(self, *args): pass

    def deviceReset(self, *args): pass

    @staticmethod
    def addCallback(*args, **kwargs): pass

    @staticmethod
    def removeCallback(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class floatPtr(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def cast(self, *args): pass

    def value(self, *args): pass

    @staticmethod
    def frompointer(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MGeometryPrimitive(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def data(self, *args): pass

    def dataType(self, *args): pass

    def drawPrimitiveType(self, *args): pass

    def elementCount(self, *args): pass

    def uniqueID(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kInvalidIndexType = 0

    kLineLoop = 4

    kLineStrip = 3

    kLines = 2

    kMaxDrawPrimitiveTypeIndex = 11

    kPoints = 1

    kPolygon = 10

    kQuadStrip = 9

    kQuads = 8

    kTriangleFan = 7

    kTriangleStrip = 6

    kTriangles = 5


class shortPtr(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def cast(self, *args): pass

    def value(self, *args): pass

    @staticmethod
    def frompointer(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class doublePtr(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def cast(self, *args): pass

    def value(self, *args): pass

    @staticmethod
    def frompointer(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MGeometryData(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def collectionNumber(self, *args): pass

    def data(self, *args): pass

    def dataType(self, *args): pass

    def elementCount(self, *args): pass

    def elementSize(self, *args): pass

    def elementType(self, *args): pass

    def elementTypeSize(self, *args): pass

    def objectName(self, *args): pass

    def objectOwnsData(self, *args): pass

    def setCollectionNumber(self, *args): pass

    def setObjectOwnsData(self, *args): pass

    def uniqueID(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kAPISupported = 6

    kBiNormal = 8

    kChar = 2

    kColor = 4

    kColorMask = 11

    kDouble = 1

    kFloat = 0

    kFour = 4

    kInt16 = 4

    kInt32 = 6

    kInvalidDataType = 0

    kInvalidElementSize = 0

    kInvalidElementType = -1

    kMaxDataTypeIndex = 13

    kNormal = 2

    kOne = 1

    kPosition = 1

    kPrimitiveCenter = 10

    kTangent = 7

    kTexCoord = 3

    kThree = 3

    kTwo = 2

    kUnsignedChar = 3

    kUnsignedInt16 = 5

    kUnsignedInt32 = 7

    kUserData = 12

    kVelocity = 9

    kWeight = 5


class MUniformParameter(_object):
    def UIHidden(self, *args): pass

    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def getAsBool(self, *args): pass

    def getAsFloat(self, *args): pass

    def getAsFloatArray(self, *args): pass

    def getAsInt(self, *args): pass

    def getAsString(self, *args): pass

    def getPlug(self, *args): pass

    def getSource(self, *args): pass

    def hasChanged(self, *args): pass

    def isATexture(self, *args): pass

    def keyable(self, *args): pass

    def name(self, *args): pass

    def numColumns(self, *args): pass

    def numElements(self, *args): pass

    def numRows(self, *args): pass

    def semantic(self, *args): pass

    def setAsBool(self, *args): pass

    def setAsFloat(self, *args): pass

    def setAsFloatArray(self, *args): pass

    def setAsInt(self, *args): pass

    def setAsString(self, *args): pass

    def setDirty(self, *args): pass

    def setEnumFieldNames(self, *args): pass

    def setKeyable(self, *args): pass

    def setRangeMax(self, *args): pass

    def setRangeMin(self, *args): pass

    def setSoftRangeMax(self, *args): pass

    def setSoftRangeMin(self, *args): pass

    def setUIHidden(self, *args): pass

    def setUINiceName(self, *args): pass

    def type(self, *args): pass

    def userData(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kSemanticBackgroundColor = 46

    kSemanticBump = 11

    kSemanticBumpTexture = 30

    kSemanticColor = 9

    kSemanticColorTexture = 28

    kSemanticEnvironment = 12

    kSemanticFarClipPlane = 49

    kSemanticFrameNumber = 47

    kSemanticHWSEdgeLevel = 54

    kSemanticHWSFaceLevel = 53

    kSemanticHWSFrontCCW = 57

    kSemanticHWSHighlighting = 59

    kSemanticHWSInstancedDraw = 58

    kSemanticHWSObjectLevel = 52

    kSemanticHWSOccluder = 56

    kSemanticHWSPrimitiveBase = 50

    kSemanticHWSPrimitiveCountPerInstance = 51

    kSemanticHWSVertexLevel = 55

    kSemanticLocalViewer = 44

    kSemanticNearClipPlane = 48

    kSemanticNormal = 10

    kSemanticNormalTexture = 29

    kSemanticNormalizationTexture = 31

    kSemanticObjectDir = 1

    kSemanticObjectPos = 5

    kSemanticOpaqueDepthTexture = 33

    kSemanticProjectionDir = 4

    kSemanticProjectionInverseMatrix = 20

    kSemanticProjectionInverseTransposeMatrix = 21

    kSemanticProjectionMatrix = 19

    kSemanticProjectionPos = 8

    kSemanticProjectionTransposeMatrix = 37

    kSemanticTime = 34

    kSemanticTranspDepthTexture = 32

    kSemanticUnknown = 0

    kSemanticViewDir = 3

    kSemanticViewInverseMatrix = 17

    kSemanticViewInverseTransposeMatrix = 18

    kSemanticViewMatrix = 16

    kSemanticViewPos = 7

    kSemanticViewProjectionInverseMatrix = 41

    kSemanticViewProjectionInverseTransposeMatrix = 43

    kSemanticViewProjectionMatrix = 40

    kSemanticViewProjectionTransposeMatrix = 42

    kSemanticViewTransposeMatrix = 36

    kSemanticViewportPixelSize = 45

    kSemanticWorldDir = 2

    kSemanticWorldInverseMatrix = 14

    kSemanticWorldInverseTransposeMatrix = 15

    kSemanticWorldMatrix = 13

    kSemanticWorldPos = 6

    kSemanticWorldTransposeMatrix = 35

    kSemanticWorldViewInverseMatrix = 23

    kSemanticWorldViewInverseTransposeMatrix = 24

    kSemanticWorldViewMatrix = 22

    kSemanticWorldViewProjectionInverseMatrix = 26

    kSemanticWorldViewProjectionInverseTransposeMatrix = 27

    kSemanticWorldViewProjectionMatrix = 25

    kSemanticWorldViewProjectionTransposeMatrix = 39

    kSemanticWorldViewTransposeMatrix = 38

    kType1DTexture = 4

    kType2DTexture = 5

    kType3DTexture = 6

    kTypeBool = 1

    kTypeCubeTexture = 7

    kTypeEnum = 10

    kTypeEnvTexture = 8

    kTypeFloat = 3

    kTypeInt = 2

    kTypeString = 9

    kTypeUnknown = 0


class MSwatchRenderBase(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def cancelParallelRendering(self, *args): pass

    def doIteration(self, *args): pass

    def image(self, *args): pass

    def node(self, *args): pass

    def renderParallel(self, *args): pass

    def renderQuality(self, *args): pass

    def resolution(self, *args): pass

    def setRenderQuality(self, *args): pass

    def swatchNode(self, *args): pass

    @staticmethod
    def cancelCurrentSwatchRender(*args, **kwargs): pass

    @staticmethod
    def enableSwatchRender(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MHardwareRenderer(_object):
    def __getattr__(self, name): pass

    def __init__(self, *args, **kwargs): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def addDrawProcedure(self, *args): pass

    def backEndString(self, *args): pass

    def dereferenceGeometry(self, *args): pass

    def drawSwatchBackGroundQuads(self, *args): pass

    def findDrawProcedure(self, *args): pass

    def getBufferSize(self, *args): pass

    def getColorBufferPixelFormat(self, *args): pass

    def getCurrentExposureNumber(self, *args): pass

    def getDepthBufferPixelFormat(self, *args): pass

    def getDrawProcedureCount(self, *args): pass

    def getDrawProcedureListNames(self, *args): pass

    def getSwatchLightDirection(self, *args): pass

    def getSwatchOrthoCameraSetting(self, *args): pass

    def getSwatchPerspectiveCameraSetting(self, *args): pass

    def getSwatchPerspectiveCameraTranslation(self, *args): pass

    def getTotalExposureCount(self, *args): pass

    def glFunctionTable(self, *args): pass

    def insertDrawProcedure(self, *args): pass

    def makeResourceContextCurrent(self, *args): pass

    def makeSwatchContextCurrent(self, *args): pass

    def readSwatchContextPixels(self, *args): pass

    def referenceDefaultGeometry(self, *args): pass

    def removeDrawProcedure(self, *args): pass

    def restoreCurrent(self, *args): pass

    @staticmethod
    def theRenderer(*args, **kwargs): pass

    __dict__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kDefaultCube = 2

    kDefaultPlane = 1

    kDefaultSphere = 0

    kDepth_Float32 = 2

    kFailure = 1

    kItemExists = 2

    kItemNotFound = 3

    kLocationNotFound = 4

    kPostExposure = 2

    kPostRendering = 3

    kPreExposure = 1

    kPreRendering = 0

    kRGBA_Fix8 = 0

    kRGBA_Float16 = 1

    kSuccess = 0


from . import OpenMaya


class MFnImageSource(OpenMaya.MFnDependencyNode):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def getImageName(self, *args): pass

    def sourceCamera(self, *args): pass

    def sourceLayer(self, *args): pass

    def type(self, *args): pass

    @staticmethod
    def className(*args, **kwargs): pass

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}


class MRenderData(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def screenToWorld(self, *args): pass

    def worldToScreen(self, *args): pass

    @property
    def aspectRatio(self): pass

    @property
    def bottom(self): pass

    @property
    def bytesPerChannel(self): pass

    @property
    def depthArr(self): pass

    @property
    def eyePoint(self): pass

    @property
    def fieldOfView(self): pass

    @property
    def internalData(self): pass

    @property
    def left(self): pass

    @property
    def perspective(self): pass

    @property
    def resX(self): pass

    @property
    def resY(self): pass

    @property
    def rgbaArr(self): pass

    @property
    def right(self): pass

    @property
    def top(self): pass

    @property
    def viewDirection(self): pass

    @property
    def worldToEyeMatrix(self): pass

    @property
    def xsize(self): pass

    @property
    def ysize(self): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MRenderSetupPrivate(_object):
    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    @staticmethod
    def className(*args, **kwargs): pass

    __dict__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MGeometryManager(_object):
    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    @staticmethod
    def className(*args, **kwargs): pass

    @staticmethod
    def dereferenceDefaultGeometry(*args, **kwargs): pass

    @staticmethod
    def getGeometry(*args, **kwargs): pass

    @staticmethod
    def referenceDefaultGeometry(*args, **kwargs): pass

    __dict__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kDefaultCube = 2

    kDefaultPlane = 1

    kDefaultSphere = 0


class MFnRenderLayer(OpenMaya.MFnDependencyNode):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def adjustmentPlug(self, *args): pass

    def externalRenderPasses(self, *args): pass

    def inCurrentRenderLayer(self, *args): pass

    def inLayer(self, *args): pass

    def isPlugAdjusted(self, *args): pass

    def layerChildren(self, *args): pass

    def listMembers(self, *args): pass

    def passHasLight(self, *args): pass

    def passHasObject(self, *args): pass

    def type(self, *args): pass

    @staticmethod
    def className(*args, **kwargs): pass

    @staticmethod
    def currentLayer(*args, **kwargs): pass

    @staticmethod
    def defaultRenderLayer(*args, **kwargs): pass

    @staticmethod
    def findLayerByName(*args, **kwargs): pass

    @staticmethod
    def listAllRenderLayers(*args, **kwargs): pass

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}


class MGLFunctionTable(_object):
    def __getattr__(self, name): pass

    def __init__(self, *args, **kwargs): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def extensionExists(self, *args): pass

    def glAccum(self, *args): pass

    def glActiveTexture(self, *args): pass

    def glActiveVaryingNV(self, *args): pass

    def glAlphaFragmentOp1ATI(self, *args): pass

    def glAlphaFragmentOp2ATI(self, *args): pass

    def glAlphaFragmentOp3ATI(self, *args): pass

    def glAlphaFunc(self, *args): pass

    def glAreProgramsResidentNV(self, *args): pass

    def glAreTexturesResident(self, *args): pass

    def glArrayElement(self, *args): pass

    def glAttachObjectARB(self, *args): pass

    def glBegin(self, *args): pass

    def glBeginFragmentShaderATI(self, *args): pass

    def glBeginOcclusionQueryNV(self, *args): pass

    def glBeginQueryARB(self, *args): pass

    def glBeginTransformFeedbackEXT(self, *args): pass

    def glBeginTransformFeedbackNV(self, *args): pass

    def glBeginVertexShaderEXT(self, *args): pass

    def glBindAttribLocationARB(self, *args): pass

    def glBindBufferARB(self, *args): pass

    def glBindBufferBaseEXT(self, *args): pass

    def glBindBufferBaseNV(self, *args): pass

    def glBindBufferOffsetEXT(self, *args): pass

    def glBindBufferOffsetNV(self, *args): pass

    def glBindBufferRangeEXT(self, *args): pass

    def glBindBufferRangeNV(self, *args): pass

    def glBindFragmentShaderATI(self, *args): pass

    def glBindFramebufferEXT(self, *args): pass

    def glBindLightParameterEXT(self, *args): pass

    def glBindMaterialParameterEXT(self, *args): pass

    def glBindParameterEXT(self, *args): pass

    def glBindProgram(self, *args): pass

    def glBindProgramNV(self, *args): pass

    def glBindRenderbufferEXT(self, *args): pass

    def glBindTexGenParameterEXT(self, *args): pass

    def glBindTexture(self, *args): pass

    def glBindTextureUnitParameterEXT(self, *args): pass

    def glBindVertexShaderEXT(self, *args): pass

    def glBitmap(self, *args): pass

    def glBlendEquationEXT(self, *args): pass

    def glBlendFunc(self, *args): pass

    def glBlitFramebufferEXT(self, *args): pass

    def glBufferDataARB(self, *args): pass

    def glBufferSubDataARB(self, *args): pass

    def glCallList(self, *args): pass

    def glCallLists(self, *args): pass

    def glCheckFramebufferStatusEXT(self, *args): pass

    def glClear(self, *args): pass

    def glClearAccum(self, *args): pass

    def glClearColor(self, *args): pass

    def glClearDepth(self, *args): pass

    def glClearIndex(self, *args): pass

    def glClearStencil(self, *args): pass

    def glClientActiveTexture(self, *args): pass

    def glClipPlane(self, *args): pass

    def glColor3b(self, *args): pass

    def glColor3bv(self, *args): pass

    def glColor3d(self, *args): pass

    def glColor3dv(self, *args): pass

    def glColor3f(self, *args): pass

    def glColor3fv(self, *args): pass

    def glColor3i(self, *args): pass

    def glColor3iv(self, *args): pass

    def glColor3s(self, *args): pass

    def glColor3sv(self, *args): pass

    def glColor3ub(self, *args): pass

    def glColor3ubv(self, *args): pass

    def glColor3ui(self, *args): pass

    def glColor3uiv(self, *args): pass

    def glColor3us(self, *args): pass

    def glColor3usv(self, *args): pass

    def glColor4b(self, *args): pass

    def glColor4bv(self, *args): pass

    def glColor4d(self, *args): pass

    def glColor4dv(self, *args): pass

    def glColor4f(self, *args): pass

    def glColor4fv(self, *args): pass

    def glColor4i(self, *args): pass

    def glColor4iv(self, *args): pass

    def glColor4s(self, *args): pass

    def glColor4sv(self, *args): pass

    def glColor4ub(self, *args): pass

    def glColor4ubv(self, *args): pass

    def glColor4ui(self, *args): pass

    def glColor4uiv(self, *args): pass

    def glColor4us(self, *args): pass

    def glColor4usv(self, *args): pass

    def glColorFragmentOp1ATI(self, *args): pass

    def glColorFragmentOp2ATI(self, *args): pass

    def glColorFragmentOp3ATI(self, *args): pass

    def glColorMask(self, *args): pass

    def glColorMaterial(self, *args): pass

    def glColorPointer(self, *args): pass

    def glCombinerInputNV(self, *args): pass

    def glCombinerOutputNV(self, *args): pass

    def glCombinerParameterfNV(self, *args): pass

    def glCombinerParameterfvNV(self, *args): pass

    def glCombinerParameteriNV(self, *args): pass

    def glCombinerParameterivNV(self, *args): pass

    def glCompileShaderARB(self, *args): pass

    def glCompressedTexImage1D(self, *args): pass

    def glCompressedTexImage2D(self, *args): pass

    def glCompressedTexImage3D(self, *args): pass

    def glCompressedTexSubImage1D(self, *args): pass

    def glCompressedTexSubImage2D(self, *args): pass

    def glCompressedTexSubImage3D(self, *args): pass

    def glCopyPixels(self, *args): pass

    def glCopyTexImage1D(self, *args): pass

    def glCopyTexImage2D(self, *args): pass

    def glCopyTexSubImage1D(self, *args): pass

    def glCopyTexSubImage2D(self, *args): pass

    def glCopyTexSubImage3D(self, *args): pass

    def glCreateProgramObjectARB(self, *args): pass

    def glCreateShaderObjectARB(self, *args): pass

    def glCullFace(self, *args): pass

    def glCullParameterdvEXT(self, *args): pass

    def glCullParameterfvEXT(self, *args): pass

    def glDeleteBuffersARB(self, *args): pass

    def glDeleteFencesNV(self, *args): pass

    def glDeleteFragmentShaderATI(self, *args): pass

    def glDeleteFramebuffersEXT(self, *args): pass

    def glDeleteLists(self, *args): pass

    def glDeleteObjectARB(self, *args): pass

    def glDeleteOcclusionQueriesNV(self, *args): pass

    def glDeletePrograms(self, *args): pass

    def glDeleteProgramsNV(self, *args): pass

    def glDeleteQueriesARB(self, *args): pass

    def glDeleteRenderbuffersEXT(self, *args): pass

    def glDeleteTextures(self, *args): pass

    def glDeleteVertexShaderEXT(self, *args): pass

    def glDepthFunc(self, *args): pass

    def glDepthMask(self, *args): pass

    def glDepthRange(self, *args): pass

    def glDetachObjectARB(self, *args): pass

    def glDisable(self, *args): pass

    def glDisableClientState(self, *args): pass

    def glDisableVariantClientStateEXT(self, *args): pass

    def glDisableVertexAttribArray(self, *args): pass

    def glDrawArrays(self, *args): pass

    def glDrawBuffer(self, *args): pass

    def glDrawElements(self, *args): pass

    def glDrawPixels(self, *args): pass

    def glDrawRangeElements(self, *args): pass

    def glEdgeFlag(self, *args): pass

    def glEdgeFlagPointer(self, *args): pass

    def glEdgeFlagv(self, *args): pass

    def glEnable(self, *args): pass

    def glEnableClientState(self, *args): pass

    def glEnableVariantClientStateEXT(self, *args): pass

    def glEnableVertexAttribArray(self, *args): pass

    def glEnd(self, *args): pass

    def glEndFragmentShaderATI(self, *args): pass

    def glEndList(self, *args): pass

    def glEndOcclusionQueryNV(self, *args): pass

    def glEndQueryARB(self, *args): pass

    def glEndTransformFeedbackEXT(self, *args): pass

    def glEndTransformFeedbackNV(self, *args): pass

    def glEndVertexShaderEXT(self, *args): pass

    def glEvalCoord1d(self, *args): pass

    def glEvalCoord1dv(self, *args): pass

    def glEvalCoord1f(self, *args): pass

    def glEvalCoord1fv(self, *args): pass

    def glEvalCoord2d(self, *args): pass

    def glEvalCoord2dv(self, *args): pass

    def glEvalCoord2f(self, *args): pass

    def glEvalCoord2fv(self, *args): pass

    def glEvalMesh1(self, *args): pass

    def glEvalMesh2(self, *args): pass

    def glEvalPoint1(self, *args): pass

    def glEvalPoint2(self, *args): pass

    def glExecuteProgramNV(self, *args): pass

    def glExtractComponentEXT(self, *args): pass

    def glFeedbackBuffer(self, *args): pass

    def glFinalCombinerInputNV(self, *args): pass

    def glFinish(self, *args): pass

    def glFinishFenceNV(self, *args): pass

    def glFlush(self, *args): pass

    def glFlushVertexArrayRangeNV(self, *args): pass

    def glFogCoordPointerEXT(self, *args): pass

    def glFogCoorddEXT(self, *args): pass

    def glFogCoorddvEXT(self, *args): pass

    def glFogCoordfEXT(self, *args): pass

    def glFogCoordfvEXT(self, *args): pass

    def glFogf(self, *args): pass

    def glFogfv(self, *args): pass

    def glFogi(self, *args): pass

    def glFogiv(self, *args): pass

    def glFramebufferRenderbufferEXT(self, *args): pass

    def glFramebufferTexture1DEXT(self, *args): pass

    def glFramebufferTexture2DEXT(self, *args): pass

    def glFramebufferTexture3DEXT(self, *args): pass

    def glFrontFace(self, *args): pass

    def glFrustum(self, *args): pass

    def glGenBuffersARB(self, *args): pass

    def glGenFencesNV(self, *args): pass

    def glGenFragmentShadersATI(self, *args): pass

    def glGenFramebuffersEXT(self, *args): pass

    def glGenLists(self, *args): pass

    def glGenOcclusionQueriesNV(self, *args): pass

    def glGenPrograms(self, *args): pass

    def glGenProgramsNV(self, *args): pass

    def glGenQueriesARB(self, *args): pass

    def glGenRenderbuffersEXT(self, *args): pass

    def glGenSymbolsEXT(self, *args): pass

    def glGenTextures(self, *args): pass

    def glGenVertexShadersEXT(self, *args): pass

    def glGenerateMipmapEXT(self, *args): pass

    def glGetActiveAttribARB(self, *args): pass

    def glGetActiveUniformARB(self, *args): pass

    def glGetActiveVaryingNV(self, *args): pass

    def glGetAttachedObjectsARB(self, *args): pass

    def glGetAttribLocationARB(self, *args): pass

    def glGetBooleanv(self, *args): pass

    def glGetBufferParameterivARB(self, *args): pass

    def glGetBufferPointervARB(self, *args): pass

    def glGetBufferSubDataARB(self, *args): pass

    def glGetClipPlane(self, *args): pass

    def glGetCombinerInputParameterfvNV(self, *args): pass

    def glGetCombinerInputParameterivNV(self, *args): pass

    def glGetCombinerOutputParameterfvNV(self, *args): pass

    def glGetCombinerOutputParameterivNV(self, *args): pass

    def glGetCompressedTexImage(self, *args): pass

    def glGetDoublev(self, *args): pass

    def glGetError(self, *args): pass

    def glGetFenceivNV(self, *args): pass

    def glGetFinalCombinerInputParameterfvNV(self, *args): pass

    def glGetFinalCombinerInputParameterivNV(self, *args): pass

    def glGetFloatv(self, *args): pass

    def glGetFramebufferAttachmentParameterivEXT(self, *args): pass

    def glGetHandleARB(self, *args): pass

    def glGetInfoLogARB(self, *args): pass

    def glGetIntegerv(self, *args): pass

    def glGetInvariantBooleanvEXT(self, *args): pass

    def glGetInvariantFloatvEXT(self, *args): pass

    def glGetInvariantIntegervEXT(self, *args): pass

    def glGetLightfv(self, *args): pass

    def glGetLightiv(self, *args): pass

    def glGetLocalConstantBooleanvEXT(self, *args): pass

    def glGetLocalConstantFloatvEXT(self, *args): pass

    def glGetLocalConstantIntegervEXT(self, *args): pass

    def glGetMapdv(self, *args): pass

    def glGetMapfv(self, *args): pass

    def glGetMapiv(self, *args): pass

    def glGetMaterialfv(self, *args): pass

    def glGetMaterialiv(self, *args): pass

    def glGetObjectParameterfvARB(self, *args): pass

    def glGetObjectParameterivARB(self, *args): pass

    def glGetOcclusionQueryivNV(self, *args): pass

    def glGetOcclusionQueryuivNV(self, *args): pass

    def glGetPixelMapfv(self, *args): pass

    def glGetPixelMapuiv(self, *args): pass

    def glGetPixelMapusv(self, *args): pass

    def glGetPointerv(self, *args): pass

    def glGetPolygonStipple(self, *args): pass

    def glGetProgramEnvParameterdv(self, *args): pass

    def glGetProgramEnvParameterfv(self, *args): pass

    def glGetProgramLocalParameterdv(self, *args): pass

    def glGetProgramLocalParameterfv(self, *args): pass

    def glGetProgramParameterdvNV(self, *args): pass

    def glGetProgramParameterfvNV(self, *args): pass

    def glGetProgramString(self, *args): pass

    def glGetProgramStringNV(self, *args): pass

    def glGetProgramiv(self, *args): pass

    def glGetProgramivNV(self, *args): pass

    def glGetQueryObjectivARB(self, *args): pass

    def glGetQueryObjectuivARB(self, *args): pass

    def glGetQueryivARB(self, *args): pass

    def glGetRenderbufferParameterivEXT(self, *args): pass

    def glGetShaderSourceARB(self, *args): pass

    def glGetString(self, *args): pass

    def glGetTexEnvfv(self, *args): pass

    def glGetTexEnviv(self, *args): pass

    def glGetTexGendv(self, *args): pass

    def glGetTexGenfv(self, *args): pass

    def glGetTexGeniv(self, *args): pass

    def glGetTexImage(self, *args): pass

    def glGetTexLevelParameterfv(self, *args): pass

    def glGetTexLevelParameteriv(self, *args): pass

    def glGetTexParameterfv(self, *args): pass

    def glGetTexParameteriv(self, *args): pass

    def glGetTrackMatrixivNV(self, *args): pass

    def glGetTransformFeedbackVaryingEXT(self, *args): pass

    def glGetTransformFeedbackVaryingNV(self, *args): pass

    def glGetUniformLocationARB(self, *args): pass

    def glGetUniformfvARB(self, *args): pass

    def glGetUniformivARB(self, *args): pass

    def glGetVariantBooleanvEXT(self, *args): pass

    def glGetVariantFloatvEXT(self, *args): pass

    def glGetVariantIntegervEXT(self, *args): pass

    def glGetVariantPointervEXT(self, *args): pass

    def glGetVaryingLocationNV(self, *args): pass

    def glGetVertexAttribPointerv(self, *args): pass

    def glGetVertexAttribPointervNV(self, *args): pass

    def glGetVertexAttribdv(self, *args): pass

    def glGetVertexAttribdvNV(self, *args): pass

    def glGetVertexAttribfv(self, *args): pass

    def glGetVertexAttribfvNV(self, *args): pass

    def glGetVertexAttribiv(self, *args): pass

    def glGetVertexAttribivNV(self, *args): pass

    def glHint(self, *args): pass

    def glIndexMask(self, *args): pass

    def glIndexPointer(self, *args): pass

    def glIndexd(self, *args): pass

    def glIndexdv(self, *args): pass

    def glIndexf(self, *args): pass

    def glIndexfv(self, *args): pass

    def glIndexi(self, *args): pass

    def glIndexiv(self, *args): pass

    def glIndexs(self, *args): pass

    def glIndexsv(self, *args): pass

    def glIndexub(self, *args): pass

    def glIndexubv(self, *args): pass

    def glInitNames(self, *args): pass

    def glInsertComponentEXT(self, *args): pass

    def glInterleavedArrays(self, *args): pass

    def glIsBufferARB(self, *args): pass

    def glIsEnabled(self, *args): pass

    def glIsFenceNV(self, *args): pass

    def glIsFramebufferEXT(self, *args): pass

    def glIsList(self, *args): pass

    def glIsOcclusionQueryNV(self, *args): pass

    def glIsProgram(self, *args): pass

    def glIsProgramNV(self, *args): pass

    def glIsQueryARB(self, *args): pass

    def glIsRenderbufferEXT(self, *args): pass

    def glIsTexture(self, *args): pass

    def glIsVariantEnabledEXT(self, *args): pass

    def glLightModelf(self, *args): pass

    def glLightModelfv(self, *args): pass

    def glLightModeli(self, *args): pass

    def glLightModeliv(self, *args): pass

    def glLightf(self, *args): pass

    def glLightfv(self, *args): pass

    def glLighti(self, *args): pass

    def glLightiv(self, *args): pass

    def glLineStipple(self, *args): pass

    def glLineWidth(self, *args): pass

    def glLinkProgramARB(self, *args): pass

    def glListBase(self, *args): pass

    def glLoadIdentity(self, *args): pass

    def glLoadMatrixd(self, *args): pass

    def glLoadMatrixf(self, *args): pass

    def glLoadName(self, *args): pass

    def glLoadProgramNV(self, *args): pass

    def glLoadTransposeMatrixd(self, *args): pass

    def glLoadTransposeMatrixdARB(self, *args): pass

    def glLoadTransposeMatrixf(self, *args): pass

    def glLoadTransposeMatrixfARB(self, *args): pass

    def glLockArraysEXT(self, *args): pass

    def glLogicOp(self, *args): pass

    def glMap1d(self, *args): pass

    def glMap1f(self, *args): pass

    def glMap2d(self, *args): pass

    def glMap2f(self, *args): pass

    def glMapBufferARB(self, *args): pass

    def glMapGrid1d(self, *args): pass

    def glMapGrid1f(self, *args): pass

    def glMapGrid2d(self, *args): pass

    def glMapGrid2f(self, *args): pass

    def glMaterialf(self, *args): pass

    def glMaterialfv(self, *args): pass

    def glMateriali(self, *args): pass

    def glMaterialiv(self, *args): pass

    def glMatrixMode(self, *args): pass

    def glMultMatrixd(self, *args): pass

    def glMultMatrixf(self, *args): pass

    def glMultTransposeMatrixd(self, *args): pass

    def glMultTransposeMatrixdARB(self, *args): pass

    def glMultTransposeMatrixf(self, *args): pass

    def glMultTransposeMatrixfARB(self, *args): pass

    def glMultiDrawArrays(self, *args): pass

    def glMultiDrawElements(self, *args): pass

    def glMultiTexCoord1d(self, *args): pass

    def glMultiTexCoord1dv(self, *args): pass

    def glMultiTexCoord1f(self, *args): pass

    def glMultiTexCoord1fv(self, *args): pass

    def glMultiTexCoord1i(self, *args): pass

    def glMultiTexCoord1iv(self, *args): pass

    def glMultiTexCoord1s(self, *args): pass

    def glMultiTexCoord1sv(self, *args): pass

    def glMultiTexCoord2d(self, *args): pass

    def glMultiTexCoord2dv(self, *args): pass

    def glMultiTexCoord2f(self, *args): pass

    def glMultiTexCoord2fv(self, *args): pass

    def glMultiTexCoord2i(self, *args): pass

    def glMultiTexCoord2iv(self, *args): pass

    def glMultiTexCoord2s(self, *args): pass

    def glMultiTexCoord2sv(self, *args): pass

    def glMultiTexCoord3d(self, *args): pass

    def glMultiTexCoord3dv(self, *args): pass

    def glMultiTexCoord3f(self, *args): pass

    def glMultiTexCoord3fv(self, *args): pass

    def glMultiTexCoord3i(self, *args): pass

    def glMultiTexCoord3iv(self, *args): pass

    def glMultiTexCoord3s(self, *args): pass

    def glMultiTexCoord3sv(self, *args): pass

    def glMultiTexCoord4d(self, *args): pass

    def glMultiTexCoord4dv(self, *args): pass

    def glMultiTexCoord4f(self, *args): pass

    def glMultiTexCoord4fv(self, *args): pass

    def glMultiTexCoord4i(self, *args): pass

    def glMultiTexCoord4iv(self, *args): pass

    def glMultiTexCoord4s(self, *args): pass

    def glMultiTexCoord4sv(self, *args): pass

    def glNewList(self, *args): pass

    def glNormal3b(self, *args): pass

    def glNormal3bv(self, *args): pass

    def glNormal3d(self, *args): pass

    def glNormal3dv(self, *args): pass

    def glNormal3f(self, *args): pass

    def glNormal3fv(self, *args): pass

    def glNormal3i(self, *args): pass

    def glNormal3iv(self, *args): pass

    def glNormal3s(self, *args): pass

    def glNormal3sv(self, *args): pass

    def glNormalPointer(self, *args): pass

    def glOrtho(self, *args): pass

    def glPNTrianglesfATI(self, *args): pass

    def glPNTrianglesiATI(self, *args): pass

    def glPassTexCoordATI(self, *args): pass

    def glPassThrough(self, *args): pass

    def glPixelMapfv(self, *args): pass

    def glPixelMapuiv(self, *args): pass

    def glPixelMapusv(self, *args): pass

    def glPixelStoref(self, *args): pass

    def glPixelStorei(self, *args): pass

    def glPixelTransferf(self, *args): pass

    def glPixelTransferi(self, *args): pass

    def glPixelZoom(self, *args): pass

    def glPointParameterf(self, *args): pass

    def glPointParameterfv(self, *args): pass

    def glPointSize(self, *args): pass

    def glPolygonMode(self, *args): pass

    def glPolygonOffset(self, *args): pass

    def glPolygonStipple(self, *args): pass

    def glPopAttrib(self, *args): pass

    def glPopClientAttrib(self, *args): pass

    def glPopMatrix(self, *args): pass

    def glPopName(self, *args): pass

    def glPrimitiveRestartIndexNV(self, *args): pass

    def glPrimitiveRestartNV(self, *args): pass

    def glPrioritizeTextures(self, *args): pass

    def glProgramEnvParameter4d(self, *args): pass

    def glProgramEnvParameter4dv(self, *args): pass

    def glProgramEnvParameter4f(self, *args): pass

    def glProgramEnvParameter4fv(self, *args): pass

    def glProgramLocalParameter4d(self, *args): pass

    def glProgramLocalParameter4dv(self, *args): pass

    def glProgramLocalParameter4f(self, *args): pass

    def glProgramLocalParameter4fv(self, *args): pass

    def glProgramParameter4dNV(self, *args): pass

    def glProgramParameter4dvNV(self, *args): pass

    def glProgramParameter4fNV(self, *args): pass

    def glProgramParameter4fvNV(self, *args): pass

    def glProgramParameters4dvNV(self, *args): pass

    def glProgramParameters4fvNV(self, *args): pass

    def glProgramString(self, *args): pass

    def glPushAttrib(self, *args): pass

    def glPushClientAttrib(self, *args): pass

    def glPushMatrix(self, *args): pass

    def glPushName(self, *args): pass

    def glRasterPos2d(self, *args): pass

    def glRasterPos2dv(self, *args): pass

    def glRasterPos2f(self, *args): pass

    def glRasterPos2fv(self, *args): pass

    def glRasterPos2i(self, *args): pass

    def glRasterPos2iv(self, *args): pass

    def glRasterPos2s(self, *args): pass

    def glRasterPos2sv(self, *args): pass

    def glRasterPos3d(self, *args): pass

    def glRasterPos3dv(self, *args): pass

    def glRasterPos3f(self, *args): pass

    def glRasterPos3fv(self, *args): pass

    def glRasterPos3i(self, *args): pass

    def glRasterPos3iv(self, *args): pass

    def glRasterPos3s(self, *args): pass

    def glRasterPos3sv(self, *args): pass

    def glRasterPos4d(self, *args): pass

    def glRasterPos4dv(self, *args): pass

    def glRasterPos4f(self, *args): pass

    def glRasterPos4fv(self, *args): pass

    def glRasterPos4i(self, *args): pass

    def glRasterPos4iv(self, *args): pass

    def glRasterPos4s(self, *args): pass

    def glRasterPos4sv(self, *args): pass

    def glReadBuffer(self, *args): pass

    def glReadPixels(self, *args): pass

    def glRectd(self, *args): pass

    def glRectdv(self, *args): pass

    def glRectf(self, *args): pass

    def glRectfv(self, *args): pass

    def glRecti(self, *args): pass

    def glRectiv(self, *args): pass

    def glRects(self, *args): pass

    def glRectsv(self, *args): pass

    def glRenderMode(self, *args): pass

    def glRenderbufferStorageEXT(self, *args): pass

    def glRequestResidentProgramsNV(self, *args): pass

    def glRotated(self, *args): pass

    def glRotatef(self, *args): pass

    def glSampleCoverage(self, *args): pass

    def glSampleMapATI(self, *args): pass

    def glScaled(self, *args): pass

    def glScalef(self, *args): pass

    def glScissor(self, *args): pass

    def glSecondaryColor3bEXT(self, *args): pass

    def glSecondaryColor3bvEXT(self, *args): pass

    def glSecondaryColor3dEXT(self, *args): pass

    def glSecondaryColor3dvEXT(self, *args): pass

    def glSecondaryColor3fEXT(self, *args): pass

    def glSecondaryColor3fvEXT(self, *args): pass

    def glSecondaryColor3iEXT(self, *args): pass

    def glSecondaryColor3ivEXT(self, *args): pass

    def glSecondaryColor3sEXT(self, *args): pass

    def glSecondaryColor3svEXT(self, *args): pass

    def glSecondaryColor3ubEXT(self, *args): pass

    def glSecondaryColor3ubvEXT(self, *args): pass

    def glSecondaryColor3uiEXT(self, *args): pass

    def glSecondaryColor3uivEXT(self, *args): pass

    def glSecondaryColor3usEXT(self, *args): pass

    def glSecondaryColor3usvEXT(self, *args): pass

    def glSecondaryColorPointerEXT(self, *args): pass

    def glSelectBuffer(self, *args): pass

    def glSetFenceNV(self, *args): pass

    def glSetFragmentShaderConstantATI(self, *args): pass

    def glSetInvariantEXT(self, *args): pass

    def glSetLocalConstantEXT(self, *args): pass

    def glShadeModel(self, *args): pass

    def glShaderOp1EXT(self, *args): pass

    def glShaderOp2EXT(self, *args): pass

    def glShaderOp3EXT(self, *args): pass

    def glShaderSourceARB(self, *args): pass

    def glStencilFunc(self, *args): pass

    def glStencilMask(self, *args): pass

    def glStencilOp(self, *args): pass

    def glSwizzleEXT(self, *args): pass

    def glTestFenceNV(self, *args): pass

    def glTexCoord1d(self, *args): pass

    def glTexCoord1dv(self, *args): pass

    def glTexCoord1f(self, *args): pass

    def glTexCoord1fv(self, *args): pass

    def glTexCoord1i(self, *args): pass

    def glTexCoord1iv(self, *args): pass

    def glTexCoord1s(self, *args): pass

    def glTexCoord1sv(self, *args): pass

    def glTexCoord2d(self, *args): pass

    def glTexCoord2dv(self, *args): pass

    def glTexCoord2f(self, *args): pass

    def glTexCoord2fv(self, *args): pass

    def glTexCoord2i(self, *args): pass

    def glTexCoord2iv(self, *args): pass

    def glTexCoord2s(self, *args): pass

    def glTexCoord2sv(self, *args): pass

    def glTexCoord3d(self, *args): pass

    def glTexCoord3dv(self, *args): pass

    def glTexCoord3f(self, *args): pass

    def glTexCoord3fv(self, *args): pass

    def glTexCoord3i(self, *args): pass

    def glTexCoord3iv(self, *args): pass

    def glTexCoord3s(self, *args): pass

    def glTexCoord3sv(self, *args): pass

    def glTexCoord4d(self, *args): pass

    def glTexCoord4dv(self, *args): pass

    def glTexCoord4f(self, *args): pass

    def glTexCoord4fv(self, *args): pass

    def glTexCoord4i(self, *args): pass

    def glTexCoord4iv(self, *args): pass

    def glTexCoord4s(self, *args): pass

    def glTexCoord4sv(self, *args): pass

    def glTexCoordPointer(self, *args): pass

    def glTexEnvf(self, *args): pass

    def glTexEnvfv(self, *args): pass

    def glTexEnvi(self, *args): pass

    def glTexEnviv(self, *args): pass

    def glTexGend(self, *args): pass

    def glTexGendv(self, *args): pass

    def glTexGenf(self, *args): pass

    def glTexGenfv(self, *args): pass

    def glTexGeni(self, *args): pass

    def glTexGeniv(self, *args): pass

    def glTexImage1D(self, *args): pass

    def glTexImage2D(self, *args): pass

    def glTexImage3D(self, *args): pass

    def glTexParameterf(self, *args): pass

    def glTexParameterfv(self, *args): pass

    def glTexParameteri(self, *args): pass

    def glTexParameteriv(self, *args): pass

    def glTexSubImage1D(self, *args): pass

    def glTexSubImage2D(self, *args): pass

    def glTexSubImage3D(self, *args): pass

    def glTrackMatrixNV(self, *args): pass

    def glTransformFeedbackAttribsNV(self, *args): pass

    def glTransformFeedbackVaryingsEXT(self, *args): pass

    def glTransformFeedbackVaryingsNV(self, *args): pass

    def glTranslated(self, *args): pass

    def glTranslatef(self, *args): pass

    def glUniform1fARB(self, *args): pass

    def glUniform1fvARB(self, *args): pass

    def glUniform1iARB(self, *args): pass

    def glUniform1ivARB(self, *args): pass

    def glUniform2fARB(self, *args): pass

    def glUniform2fvARB(self, *args): pass

    def glUniform2iARB(self, *args): pass

    def glUniform2ivARB(self, *args): pass

    def glUniform3fARB(self, *args): pass

    def glUniform3fvARB(self, *args): pass

    def glUniform3iARB(self, *args): pass

    def glUniform3ivARB(self, *args): pass

    def glUniform4fARB(self, *args): pass

    def glUniform4fvARB(self, *args): pass

    def glUniform4iARB(self, *args): pass

    def glUniform4ivARB(self, *args): pass

    def glUniformMatrix2fvARB(self, *args): pass

    def glUniformMatrix3fvARB(self, *args): pass

    def glUniformMatrix4fvARB(self, *args): pass

    def glUnlockArraysEXT(self, *args): pass

    def glUnmapBufferARB(self, *args): pass

    def glUseProgramObjectARB(self, *args): pass

    def glValidateProgramARB(self, *args): pass

    def glVariantPointerEXT(self, *args): pass

    def glVariantbvEXT(self, *args): pass

    def glVariantdvEXT(self, *args): pass

    def glVariantfvEXT(self, *args): pass

    def glVariantivEXT(self, *args): pass

    def glVariantsvEXT(self, *args): pass

    def glVariantubvEXT(self, *args): pass

    def glVariantuivEXT(self, *args): pass

    def glVariantusvEXT(self, *args): pass

    def glVertex2d(self, *args): pass

    def glVertex2dv(self, *args): pass

    def glVertex2f(self, *args): pass

    def glVertex2fv(self, *args): pass

    def glVertex2i(self, *args): pass

    def glVertex2iv(self, *args): pass

    def glVertex2s(self, *args): pass

    def glVertex2sv(self, *args): pass

    def glVertex3d(self, *args): pass

    def glVertex3dv(self, *args): pass

    def glVertex3f(self, *args): pass

    def glVertex3fv(self, *args): pass

    def glVertex3i(self, *args): pass

    def glVertex3iv(self, *args): pass

    def glVertex3s(self, *args): pass

    def glVertex3sv(self, *args): pass

    def glVertex4d(self, *args): pass

    def glVertex4dv(self, *args): pass

    def glVertex4f(self, *args): pass

    def glVertex4fv(self, *args): pass

    def glVertex4i(self, *args): pass

    def glVertex4iv(self, *args): pass

    def glVertex4s(self, *args): pass

    def glVertex4sv(self, *args): pass

    def glVertexArrayRangeNV(self, *args): pass

    def glVertexAttrib1d(self, *args): pass

    def glVertexAttrib1dNV(self, *args): pass

    def glVertexAttrib1dv(self, *args): pass

    def glVertexAttrib1dvNV(self, *args): pass

    def glVertexAttrib1f(self, *args): pass

    def glVertexAttrib1fNV(self, *args): pass

    def glVertexAttrib1fv(self, *args): pass

    def glVertexAttrib1fvNV(self, *args): pass

    def glVertexAttrib1s(self, *args): pass

    def glVertexAttrib1sNV(self, *args): pass

    def glVertexAttrib1sv(self, *args): pass

    def glVertexAttrib1svNV(self, *args): pass

    def glVertexAttrib2d(self, *args): pass

    def glVertexAttrib2dNV(self, *args): pass

    def glVertexAttrib2dv(self, *args): pass

    def glVertexAttrib2dvNV(self, *args): pass

    def glVertexAttrib2f(self, *args): pass

    def glVertexAttrib2fNV(self, *args): pass

    def glVertexAttrib2fv(self, *args): pass

    def glVertexAttrib2fvNV(self, *args): pass

    def glVertexAttrib2s(self, *args): pass

    def glVertexAttrib2sNV(self, *args): pass

    def glVertexAttrib2sv(self, *args): pass

    def glVertexAttrib2svNV(self, *args): pass

    def glVertexAttrib3d(self, *args): pass

    def glVertexAttrib3dNV(self, *args): pass

    def glVertexAttrib3dv(self, *args): pass

    def glVertexAttrib3dvNV(self, *args): pass

    def glVertexAttrib3f(self, *args): pass

    def glVertexAttrib3fNV(self, *args): pass

    def glVertexAttrib3fv(self, *args): pass

    def glVertexAttrib3fvNV(self, *args): pass

    def glVertexAttrib3s(self, *args): pass

    def glVertexAttrib3sNV(self, *args): pass

    def glVertexAttrib3sv(self, *args): pass

    def glVertexAttrib3svNV(self, *args): pass

    def glVertexAttrib4Nbv(self, *args): pass

    def glVertexAttrib4Niv(self, *args): pass

    def glVertexAttrib4Nsv(self, *args): pass

    def glVertexAttrib4Nub(self, *args): pass

    def glVertexAttrib4Nubv(self, *args): pass

    def glVertexAttrib4Nuiv(self, *args): pass

    def glVertexAttrib4Nusv(self, *args): pass

    def glVertexAttrib4bv(self, *args): pass

    def glVertexAttrib4d(self, *args): pass

    def glVertexAttrib4dNV(self, *args): pass

    def glVertexAttrib4dv(self, *args): pass

    def glVertexAttrib4dvNV(self, *args): pass

    def glVertexAttrib4f(self, *args): pass

    def glVertexAttrib4fNV(self, *args): pass

    def glVertexAttrib4fv(self, *args): pass

    def glVertexAttrib4fvNV(self, *args): pass

    def glVertexAttrib4iv(self, *args): pass

    def glVertexAttrib4s(self, *args): pass

    def glVertexAttrib4sNV(self, *args): pass

    def glVertexAttrib4sv(self, *args): pass

    def glVertexAttrib4svNV(self, *args): pass

    def glVertexAttrib4ubNV(self, *args): pass

    def glVertexAttrib4ubv(self, *args): pass

    def glVertexAttrib4ubvNV(self, *args): pass

    def glVertexAttrib4uiv(self, *args): pass

    def glVertexAttrib4usv(self, *args): pass

    def glVertexAttribPointer(self, *args): pass

    def glVertexAttribPointerNV(self, *args): pass

    def glVertexAttribs1dvNV(self, *args): pass

    def glVertexAttribs1fvNV(self, *args): pass

    def glVertexAttribs1svNV(self, *args): pass

    def glVertexAttribs2dvNV(self, *args): pass

    def glVertexAttribs2fvNV(self, *args): pass

    def glVertexAttribs2svNV(self, *args): pass

    def glVertexAttribs3dvNV(self, *args): pass

    def glVertexAttribs3fvNV(self, *args): pass

    def glVertexAttribs3svNV(self, *args): pass

    def glVertexAttribs4dvNV(self, *args): pass

    def glVertexAttribs4fvNV(self, *args): pass

    def glVertexAttribs4svNV(self, *args): pass

    def glVertexAttribs4ubvNV(self, *args): pass

    def glVertexPointer(self, *args): pass

    def glVertexWeightPointerEXT(self, *args): pass

    def glVertexWeightfEXT(self, *args): pass

    def glVertexWeightfvEXT(self, *args): pass

    def glViewport(self, *args): pass

    def glWriteMaskEXT(self, *args): pass

    def maxTextureSize(self, *args): pass

    def maxVertexAttributes(self, *args): pass

    def numTexImageUnits(self, *args): pass

    def numTexInterpolants(self, *args): pass

    def numTexUnits(self, *args): pass

    __dict__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kMGL_Version11 = 0

    kMGL_Version12 = 1

    kMGL_Version121 = 2

    kMGL_Version13 = 3

    kMGL_Version14 = 4

    kMGL_Version15 = 5

    kMGL_Version20 = 6


class uIntPtr(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def cast(self, *args): pass

    def value(self, *args): pass

    @staticmethod
    def frompointer(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MRenderTargetLegacy(_object):
    def __getattr__(self, name): pass

    def __init__(self, *args, **kwargs): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def height(self, *args): pass

    def makeTargetCurrent(self, *args): pass

    def width(self, *args): pass

    def writeColorBuffer(self, *args): pass

    __dict__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MRenderShadowData(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def worldToZbuffer(self, *args): pass

    def zbufferToWorld(self, *args): pass

    @property
    def depthMaps(self): pass

    @property
    def internalData(self): pass

    @property
    def lightPosition(self): pass

    @property
    def lightType(self): pass

    @property
    def midDistMaps(self): pass

    @property
    def perspective(self): pass

    @property
    def perspectiveMatrix(self): pass

    @property
    def projectionMatrix(self): pass

    @property
    def shadowResX(self): pass

    @property
    def shadowResY(self): pass

    @property
    def useMidDistMap(self): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kDirectional = 2

    kInvalid = 0

    kPoint = 1

    kSpot = 3


class MRenderUtil(_object):
    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    @staticmethod
    def className(*args, **kwargs): pass

    @staticmethod
    def convertPsdFile(*args, **kwargs): pass

    @staticmethod
    def diffuseReflectance(*args, **kwargs): pass

    @staticmethod
    def eval2dTexture(*args, **kwargs): pass

    @staticmethod
    def exactFileTextureName(*args, **kwargs): pass

    @staticmethod
    def exactImagePlaneFileName(*args, **kwargs): pass

    @staticmethod
    def generatingIprFile(*args, **kwargs): pass

    @staticmethod
    def getCommonRenderSettings(*args, **kwargs): pass

    @staticmethod
    def hemisphereCoverage(*args, **kwargs): pass

    @staticmethod
    def inCurrentRenderLayer(*args, **kwargs): pass

    @staticmethod
    def lightAttenuation(*args, **kwargs): pass

    @staticmethod
    def mainBeautyPassCustomTokenString(*args, **kwargs): pass

    @staticmethod
    def mainBeautyPassName(*args, **kwargs): pass

    @staticmethod
    def maximumSpecularReflection(*args, **kwargs): pass

    @staticmethod
    def mayaRenderState(*args, **kwargs): pass

    @staticmethod
    def noise1(*args, **kwargs): pass

    @staticmethod
    def noise2(*args, **kwargs): pass

    @staticmethod
    def noise3(*args, **kwargs): pass

    @staticmethod
    def noise4(*args, **kwargs): pass

    @staticmethod
    def noiseTableCubeSide(*args, **kwargs): pass

    @staticmethod
    def noiseTableSize(*args, **kwargs): pass

    @staticmethod
    def raytrace(*args, **kwargs): pass

    @staticmethod
    def raytraceFirstGeometryIntersections(*args, **kwargs): pass

    @staticmethod
    def relativeFileName(*args, **kwargs): pass

    @staticmethod
    def renderObjectItem(*args, **kwargs): pass

    @staticmethod
    def renderPass(*args, **kwargs): pass

    @staticmethod
    def sampleShadingNetwork(*args, **kwargs): pass

    @staticmethod
    def sendRenderProgressInfo(*args, **kwargs): pass

    @staticmethod
    def valueInNoiseTable(*args, **kwargs): pass

    __dict__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kAll = 0

    kAmbientOnly = 3

    kBatchRender = 1

    kColorOnly = 1

    kDiffuseOnly = 4

    kHardwareRender = 4

    kInteractiveRender = 2

    kIprRender = 3

    kNotRendering = 0

    kShadowOnly = 2

    kSpecularOnly = 5


class uCharPtr(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def cast(self, *args): pass

    def value(self, *args): pass

    @staticmethod
    def frompointer(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MGeometryRequirementsLegacy(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def addBinormal(self, *args): pass

    def addColor(self, *args): pass

    def addComponentId(self, *args): pass

    def addFaceOffsets(self, *args): pass

    def addNormal(self, *args): pass

    def addPosition(self, *args): pass

    def addTangent(self, *args): pass

    def addTexCoord(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MUniformParameterList(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def append(self, *args): pass

    def assign(self, *args): pass

    def getElement(self, *args): pass

    def length(self, *args): pass

    def setElement(self, *args): pass

    def setLength(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class intPtr(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def cast(self, *args): pass

    def value(self, *args): pass

    @staticmethod
    def frompointer(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MRenderCallback(_object):
    def __del__(self): pass

    def __disown__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def postProcessCallback(self, *args): pass

    def renderCallback(self, *args): pass

    def shadowCastCallback(self, *args): pass

    @staticmethod
    def addCallback(*args, **kwargs): pass

    @staticmethod
    def addRenderTileCallback(*args, **kwargs): pass

    @staticmethod
    def className(*args, **kwargs): pass

    @staticmethod
    def removeCallback(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MGeometryLegacy(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def binormal(self, *args): pass

    def color(self, *args): pass

    def componentId(self, *args): pass

    def data(self, *args): pass

    def normal(self, *args): pass

    def position(self, *args): pass

    def primitiveArray(self, *args): pass

    def primitiveArrayCount(self, *args): pass

    def tangent(self, *args): pass

    def texCoord(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class boolPtr(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def cast(self, *args): pass

    def value(self, *args): pass

    @staticmethod
    def frompointer(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class charPtr(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def assign(self, *args): pass

    def cast(self, *args): pass

    def value(self, *args): pass

    @staticmethod
    def frompointer(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MViewportRenderer(_object):
    def UIname(self, *args): pass

    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args, **kwargs): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def deregisterRenderer(self, *args): pass

    def initialize(self, *args): pass

    def name(self, *args): pass

    def nativelySupports(self, *args): pass

    def override(self, *args): pass

    def overrideThenStandardExclusion(self, *args): pass

    def registerRenderer(self, *args): pass

    def render(self, *args): pass

    def renderingOverride(self, *args): pass

    def setRenderingOverride(self, *args): pass

    def setUIName(self, *args): pass

    def uninitialize(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kDirect3D = 1

    kExcludeAll = -1

    kExcludeCVs = 131072

    kExcludeCameras = 32

    kExcludeDeformers = 256

    kExcludeDimensions = 4096

    kExcludeDynamicConstraints = 134217728

    kExcludeDynamics = 512

    kExcludeFluids = 2097152

    kExcludeFollicles = 4194304

    kExcludeGrid = 65536

    kExcludeHairSystems = 8388608

    kExcludeHulls = 262144

    kExcludeIkHandles = 128

    kExcludeImagePlane = 16777216

    kExcludeJoints = 64

    kExcludeLights = 16

    kExcludeLocators = 2048

    kExcludeManipulators = 268435456

    kExcludeMeshes = 4

    kExcludeMotionTrails = 1073741824

    kExcludeNCloths = 33554432

    kExcludeNParticles = 536870912

    kExcludeNRigids = 67108864

    kExcludeNone = 0

    kExcludeNurbsCurves = 1

    kExcludeNurbsSurfaces = 2

    kExcludeParticleInstancers = 1024

    kExcludePivots = 16384

    kExcludePlanes = 8

    kExcludePluginShapes = -2147483648

    kExcludeSelectHandles = 8192

    kExcludeStrokes = 524288

    kExcludeSubdivSurfaces = 1048576

    kExcludeTextures = 32768

    kNoOverride = 0

    kOpenGL = 0

    kOverrideAllDrawing = 1

    kOverrideThenStandard = 2

    kOverrideThenUI = 3

    kSoftware = 2


class MVaryingParameterList(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def append(self, *args): pass

    def assign(self, *args): pass

    def getElement(self, *args): pass

    def length(self, *args): pass

    def setElement(self, *args): pass

    def setLength(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MFnRenderPass(OpenMaya.MFnDependencyNode):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def customTokenString(self, *args): pass

    def frameBufferChannels(self, *args): pass

    def frameBufferType(self, *args): pass

    def getImplementation(self, *args): pass

    def passID(self, *args): pass

    def setImplementation(self, *args): pass

    def type(self, *args): pass

    def usesFiltering(self, *args): pass

    @staticmethod
    def className(*args, **kwargs): pass

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}


class MCommonRenderSettingsData(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def getBufferName(self, *args): pass

    def getImageName(self, *args): pass

    def isAnimated(self, *args): pass

    def isMovieFormat(self, *args): pass

    def setFieldName(self, *args): pass

    def setPassName(self, *args): pass

    def shouldRenderFrameAtTime(self, *args): pass

    @staticmethod
    def className(*args, **kwargs): pass

    @staticmethod
    def getPostRenderFrameCmd(*args, **kwargs): pass

    @staticmethod
    def getPreRenderFrameCmd(*args, **kwargs): pass

    @property
    def customExt(self): pass

    @property
    def customImageFormat(self): pass

    @property
    def deviceAspectRatio(self): pass

    @property
    def dotPerInch(self): pass

    @property
    def enableDefaultLight(self): pass

    @property
    def frameBy(self): pass

    @property
    def frameEnd(self): pass

    @property
    def framePadding(self): pass

    @property
    def frameStart(self): pass

    @property
    def height(self): pass

    @property
    def imageFormat(self): pass

    @property
    def name(self): pass

    @property
    def namePattern(self): pass

    @property
    def namingScheme(self): pass

    @property
    def pixelAspectRatio(self): pass

    @property
    def postMel(self): pass

    @property
    def postRenderLayerMel(self): pass

    @property
    def postRenderMel(self): pass

    @property
    def preMel(self): pass

    @property
    def preRenderLayerMel(self): pass

    @property
    def preRenderMel(self): pass

    @property
    def renderAll(self): pass

    @property
    def renumberBy(self): pass

    @property
    def renumberFrames(self): pass

    @property
    def renumberStart(self): pass

    @property
    def skipExistingFrames(self): pass

    @property
    def useCustomExt(self): pass

    @property
    def width(self): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kFullPathImage = 1

    kFullPathTmp = 2

    kRelativePath = 0


class MRenderSetup(_object):
    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    @staticmethod
    def className(*args, **kwargs): pass

    @staticmethod
    def getEnabledSelectedNodeNames(*args, **kwargs): pass

    __dict__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MDrawProcedureBase(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args, **kwargs): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def enabled(self, *args): pass

    def execute(self, *args): pass

    def name(self, *args): pass

    def setEnabled(self, *args): pass

    def setName(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MD3D9Renderer(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def getD3D9Device(self, *args): pass

    def makeSwatchContextCurrent(self, *args): pass

    def readSwatchContextPixels(self, *args): pass

    def setBackgroundColor(self, *args): pass

    @staticmethod
    def theRenderer(*args, **kwargs): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MHwTextureManager(_object):
    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    @staticmethod
    def className(*args, **kwargs): pass

    @staticmethod
    def deregisterTextureFile(*args, **kwargs): pass

    @staticmethod
    def glBind(*args, **kwargs): pass

    @staticmethod
    def registerTextureFile(*args, **kwargs): pass

    @staticmethod
    def textureFile(*args, **kwargs): pass

    __dict__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None


class MRenderProfile(_object):
    def __del__(self): pass

    def __getattr__(self, name): pass

    def __init__(self, *args): pass

    def __repr__(self): pass

    def __setattr__(self, name, value): pass

    def addRenderer(self, *args): pass

    def hasRenderer(self, *args): pass

    def numberOfRenderers(self, *args): pass

    __dict__ = None

    __swig_destroy__ = None

    __swig_getmethods__ = {}

    __swig_setmethods__ = {}

    __weakref__ = None

    kMayaD3D = 2

    kMayaOpenGL = 1

    kMayaSoftware = 0


def MRenderView_refresh(*args, **kwargs): pass


def MHwrCallback_swigregister(*args, **kwargs): pass


def MGeometryManager_referenceDefaultGeometry(*args, **kwargs): pass


def MRenderSetup_getEnabledSelectedNodeNames(*args, **kwargs): pass


def MRenderUtil_eval2dTexture(*args, **kwargs): pass


def MRenderUtil_noiseTableCubeSide(*args, **kwargs): pass


def charPtr_swigregister(*args, **kwargs): pass


def MRenderUtil_convertPsdFile(*args, **kwargs): pass


def MRenderView_getRenderRegion(*args, **kwargs): pass


def MFnRenderLayer_findLayerByName(*args, **kwargs): pass


def MGeometryManager_swigregister(*args, **kwargs): pass


def shortPtr_frompointer(*args, **kwargs): pass


def MRenderView_updatePixels(*args, **kwargs): pass


def MGLFunctionTable_swigregister(*args, **kwargs): pass


def MRenderUtil_className(*args, **kwargs): pass


def MRenderUtil_sampleShadingNetwork(*args, **kwargs): pass


def MGeometryManager_className(*args, **kwargs): pass


def _swig_getattr(self, class_type, name): pass


def MHwrCallback_addCallback(*args, **kwargs): pass


def uIntPtr_swigregister(*args, **kwargs): pass


def MD3D9Renderer_swigregister(*args, **kwargs): pass


def MRenderUtil_hemisphereCoverage(*args, **kwargs): pass


def MRenderTargetLegacy_swigregister(*args, **kwargs): pass


def MSwatchRenderRegister_unregisterSwatchRender(*args, **kwargs): pass


def _swig_setattr_nondynamic(self, class_type, name, value, static='1'): pass


def MHwTextureManager_className(*args, **kwargs): pass


def uCharPtr_swigregister(*args, **kwargs): pass


def MCommonRenderSettingsData_className(*args, **kwargs): pass


def MRenderUtil_mainBeautyPassName(*args, **kwargs): pass


def MSwatchRenderBase_cancelCurrentSwatchRender(*args, **kwargs): pass


def MCommonRenderSettingsData_swigregister(*args, **kwargs): pass


def MCommonRenderSettingsData_getPreRenderFrameCmd(*args, **kwargs): pass


def MHwTextureManager_registerTextureFile(*args, **kwargs): pass


def boolPtr_swigregister(*args, **kwargs): pass


def MRenderUtil_getCommonRenderSettings(*args, **kwargs): pass


def MGeometryPrimitive_swigregister(*args, **kwargs): pass


def RV_PIXEL_swigregister(*args, **kwargs): pass


def MRenderCallback_removeCallback(*args, **kwargs): pass


def MRenderUtil_exactImagePlaneFileName(*args, **kwargs): pass


def MRenderSetup_className(*args, **kwargs): pass


def _swig_repr(self): pass


def MRenderView_startRender(*args, **kwargs): pass


def MRenderData_swigregister(*args, **kwargs): pass


def MUniformParameterList_swigregister(*args, **kwargs): pass


def MRenderSetupPrivate__switchToLegacyRenderLayer(*args, **kwargs): pass


def MRenderUtil_sendRenderProgressInfo(*args, **kwargs): pass


def MRenderUtil_generatingIprFile(*args, **kwargs): pass


def MCommonRenderSettingsData_getPostRenderFrameCmd(*args, **kwargs): pass


def MFnRenderLayer_className(*args, **kwargs): pass


def RV_AOV_swigregister(*args, **kwargs): pass


def doublePtr_frompointer(*args, **kwargs): pass


def MRenderProfile_swigregister(*args, **kwargs): pass


def MRenderUtil_mayaRenderState(*args, **kwargs): pass


def MRenderUtil_noise4(*args, **kwargs): pass


def boolPtr_frompointer(*args, **kwargs): pass


def MRenderUtil_inCurrentRenderLayer(*args, **kwargs): pass


def MGeometryManager_dereferenceDefaultGeometry(*args, **kwargs): pass


def MFnRenderLayer_listAllRenderLayers(*args, **kwargs): pass


def shortPtr_swigregister(*args, **kwargs): pass


def MGeometryData_swigregister(*args, **kwargs): pass


def MFnRenderLayer_currentLayer(*args, **kwargs): pass


def MRenderView_swigregister(*args, **kwargs): pass


def MRenderView_setDrawTileBoundary(*args, **kwargs): pass


def MRenderUtil_noise1(*args, **kwargs): pass


def MRenderCallback_addRenderTileCallback(*args, **kwargs): pass


def MRenderUtil_raytrace(*args, **kwargs): pass


def MFnImageSource_className(*args, **kwargs): pass


def uCharPtr_frompointer(*args, **kwargs): pass


def MRenderView_startRegionRender(*args, **kwargs): pass


def MGeometryRequirementsLegacy_swigregister(*args, **kwargs): pass


def weakref_proxy(*args, **kwargs):
    """
    proxy(object[, callback]) -- create a proxy object that weakly
    references 'object'.  'callback', if given, is called with a
    reference to the proxy when 'object' is about to be finalized.
    """
    pass


def MVaryingParameter_swigregister(*args, **kwargs): pass


def MRenderCallback_swigregister(*args, **kwargs): pass


def MHardwareRenderer_theRenderer(*args, **kwargs): pass


def MFnRenderPass_swigregister(*args, **kwargs): pass


def MRenderView_setCurrentCamera(*args, **kwargs): pass


def MRenderCallback_addCallback(*args, **kwargs): pass


def intPtr_frompointer(*args, **kwargs): pass


def doublePtr_swigregister(*args, **kwargs): pass


def MRenderView_endRender(*args, **kwargs): pass


def MViewportRenderer_swigregister(*args, **kwargs): pass


def MFnImageSource_swigregister(*args, **kwargs): pass


def MFnRenderLayer_defaultRenderLayer(*args, **kwargs): pass


def _swig_setattr(self, class_type, name, value): pass


def MRenderUtil_diffuseReflectance(*args, **kwargs): pass


def MHwTextureManager_deregisterTextureFile(*args, **kwargs): pass


def MD3D9Renderer_theRenderer(*args, **kwargs): pass


def MHwTextureManager_swigregister(*args, **kwargs): pass


def MRenderSetupPrivate_swigregister(*args, **kwargs): pass


def MRenderUtil_swigregister(*args, **kwargs): pass


def intPtr_swigregister(*args, **kwargs): pass


def MRenderUtil_maximumSpecularReflection(*args, **kwargs): pass


def MSwatchRenderBase_swigregister(*args, **kwargs): pass


def MVaryingParameterList_swigregister(*args, **kwargs): pass


def MLightLinks_swigregister(*args, **kwargs): pass


def MFnRenderPass_className(*args, **kwargs): pass


def MRenderUtil_valueInNoiseTable(*args, **kwargs): pass


def MSwatchRenderBase_enableSwatchRender(*args, **kwargs): pass


def floatPtr_frompointer(*args, **kwargs): pass


def MGeometryList_swigregister(*args, **kwargs): pass


def MRenderUtil_noise2(*args, **kwargs): pass


def MRenderCallback_className(*args, **kwargs): pass


def MGeometryLegacy_swigregister(*args, **kwargs): pass


def MRenderUtil_renderPass(*args, **kwargs): pass


def MUniformParameter_swigregister(*args, **kwargs): pass


def MHwrCallback_removeCallback(*args, **kwargs): pass


def MFnRenderLayer_swigregister(*args, **kwargs): pass


def MRenderUtil_noiseTableSize(*args, **kwargs): pass


def charPtr_frompointer(*args, **kwargs): pass


def uIntPtr_frompointer(*args, **kwargs): pass


def MRenderUtil_exactFileTextureName(*args, **kwargs): pass


def MRenderSetup_swigregister(*args, **kwargs): pass


def MRenderView_doesRenderEditorExist(*args, **kwargs): pass


def MRenderUtil_renderObjectItem(*args, **kwargs): pass


def MRenderUtil_raytraceFirstGeometryIntersections(*args, **kwargs): pass


def MHwTextureManager_textureFile(*args, **kwargs): pass


def MSwatchRenderRegister_swigregister(*args, **kwargs): pass


def MHardwareRenderer_swigregister(*args, **kwargs): pass


def MRenderingInfo_swigregister(*args, **kwargs): pass


def MRenderUtil_lightAttenuation(*args, **kwargs): pass


def MSwatchRenderRegister_registerSwatchRender(*args, **kwargs): pass


def MDrawProcedureBase_swigregister(*args, **kwargs): pass


def MHwTextureManager_glBind(*args, **kwargs): pass


def MRenderView_className(*args, **kwargs): pass


def MRenderSetupPrivate__triggerSelectionChanged(*args, **kwargs): pass


def floatPtr_swigregister(*args, **kwargs): pass


def MGeometryManager_getGeometry(*args, **kwargs): pass


def MRenderUtil_relativeFileName(*args, **kwargs): pass


def MRenderUtil_noise3(*args, **kwargs): pass


def MRenderUtil_mainBeautyPassCustomTokenString(*args, **kwargs): pass


def MRenderSetupPrivate_className(*args, **kwargs): pass


def MRenderShadowData_swigregister(*args, **kwargs): pass


MGL_OP_ROUND_EXT = 34704

MGL_DSDT_MAG_NV = 34550

MGL_VARIANT_EXT = 34753

MGL_LINE_STIPPLE = 2852

MGL_TEXTURE_COORD_ARRAY_TYPE_EXT = 32905

kMGLext_NV_vertex_program = 72

MGL_OP_FLOOR_EXT = 34703

MGL_TEXTURE_COMPRESSED = 34465

MGL_DSDT_NV = 34549

MGL_TEXTURE_COORD_ARRAY_SIZE_EXT = 32904

MGL_VERTEX_ARRAY = 32884

MGL_OP_CLAMP_EXT = 34702

MGL_HILO_NV = 34548

MGL_INDEX_ARRAY_COUNT_EXT = 32903

MGL_OP_SET_LT_EXT = 34701

MGL_TEXTURE9_ARB = 33993

MGL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 34547

MGL_INDEX_ARRAY_STRIDE_EXT = 32902

MGL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = 34064

MGL_OP_SET_GE_EXT = 34700

MGL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 34546

kMGLext_multi_draw_arrays = 18

MGL_INDEX_ARRAY_TYPE_EXT = 32901

MGL_OP_MIN_EXT = 34699

MGL_MATRIX27 = 35035

MGL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 34545

MGL_COLOR_ARRAY_COUNT_EXT = 32900

MGL_DOT3_RGB_ARB = 34478

MGL_PASS_THROUGH_NV = 34534

MGL_OP_MAX_EXT = 34698

kMGLext_MGLX_get_visual_from_fbconfig_sgix = 98

MGL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 34544

MGL_MATRIX_EXT = 34752

MGL_COLOR_ARRAY_STRIDE_EXT = 32899

MGL_OP_FRAC_EXT = 34697

MGL_TEXTURE_COMPRESSED_IMAGE_SIZE = 34464

kMGLext_EXT_vertex_shader = 59

MGL_DOT_PRODUCT_TEXTURE_3D_NV = 34543

MGL_COLOR_ARRAY_TYPE_EXT = 32898

MGL_TEXTURE_BINDING_2D = 32873

MGL_OP_MADD_EXT = 34696

MGL_DOT_PRODUCT_TEXTURE_2D_NV = 34542

MGL_COLOR_ARRAY_SIZE_EXT = 32897

MGL_OP_ADD_EXT = 34695

MGL_TEXTURE8_ARB = 33992

MGL_DOT_PRODUCT_DEPTH_REPLACE_NV = 34541

MGL_NORMAL_ARRAY_COUNT_EXT = 32896

MGL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 34063

MGL_OP_MUL_EXT = 34694

MGL_DOT_PRODUCT_NV = 34540

MGL_NORMAL_ARRAY_STRIDE_EXT = 32895

MGL_OP_DOT4_EXT = 34693

MGL_STENCIL = 6146

MGL_NORMAL_ARRAY_TYPE_EXT = 32894

MGL_ACCUM_ALPHA_BITS = 3419

MGL_OP_DOT3_EXT = 34692

MGL_LUMINANCE16_ALPHA16 = 32840

MGL_TRANSFORM_FEEDBACK_BUFFER_NV = 35982

MGL_VERTEX_ARRAY_COUNT_EXT = 32893

MGL_OP_NEGATE_EXT = 34691

MGL_TEXTURE_COMPRESSION_HINT = 34031

MGL_LUMINANCE12_ALPHA12 = 32839

MGL_VERTEX_ARRAY_STRIDE_EXT = 32892

MGL_TEXTURE_BINDING_1D = 32872

MGL_OP_INDEX_EXT = 34690

MGL_LUMINANCE12_ALPHA4 = 32838

MGL_VERTEX_ARRAY_TYPE_EXT = 32891

MGL_VERTEX_SHADER_BINDING_EXT = 34689

MGL_DRAW_FRAMEBUFFER = 36009

MGL_LUMINANCE8_ALPHA8 = 32837

kMGLext_convolution = 29

MGL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = 34062

MGL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = 35972

MGL_VERTEX_SHADER_EXT = 34688

MGL_LUMINANCE6_ALPHA2 = 32836

MGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 34070

MGL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 34808

MGL_MATRIX25 = 35033

MGL_LUMINANCE4_ALPHA4 = 32835

MGL_MATRIX4_NV = 34356

MGL_PREVIOUS_TEXTURE_INPUT_NV = 34532

MGL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 34807

MGL_TRANSPOSE_COLOR_MATRIX = 34022

MGL_LUMINANCE16 = 32834

MGL_VERTEX_ATTRIB_ARRAY_TYPE = 34341

MGL_SCALAR_EXT = 34750

MGL_MATRIX3_NV = 34355

MGL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 34806

MGL_COMPRESSED_RGBA = 34030

MGL_LUMINANCE12 = 32833

MGL_TEXTURE_HI_SIZE_NV = 34587

MGL_MATRIX2_NV = 34354

MGL_TEXTURE_RESIDENT = 32871

kMGLext_EXT_texture_filter_anisotropic = 60

MGL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 34805

MGL_LUMINANCE8 = 32832

MGL_MATRIX1_NV = 34353

MGL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 34804

MGL_VERTEX_ATTRIB_ARRAY_ENABLED = 34338

MGL_READ_FRAMEBUFFER = 36008

MGL_LUMINANCE4 = 32831

MGL_MATRIX0_NV = 34352

MGL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = 34061

MGL_ALPHA16 = 32830

MGL_MAX_TRACK_MATRICES_NV = 34351

MGL_EXPAND_NORMAL_NV = 34104

MGL_BLEND_COLOR_EXT = 32773

MGL_ALPHA12 = 32829

MGL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = 34350

MGL_OFFSET_TEXTURE_2D_BIAS_NV = 34531

MGL_UNSIGNED_INVERT_NV = 34103

MGL_ALPHA8 = 32828

MGL_PACK_ALIGNMENT = 3333

MGL_INVERSE_TRANSPOSE_NV = 34349

MGL_UNSIGNED_IDENTITY_NV = 34102

kMGLext_WMGL_ARB_pixel_format = 86

MGL_TEXTURE_COORD_ARRAY_STRIDE = 32906

MGL_ALPHA4 = 32827

MGL_TRANSPOSE_NV = 34348

MGL_UNPACK_SKIP_IMAGES = 32877

MGL_SPARE0_PLUS_SECONDARY_COLOR_NV = 34098

MGL_TEXTURE_DEPTH = 32881

MGL_POLYGON_OFFSET_FILL = 32823

MGL_INVERSE_NV = 34347

MGL_E_TIMES_F_NV = 34097

MGL_COMBINE_EXT = 34160

MGL_TEXTURE5_ARB = 33989

MGL_POLYGON_OFFSET_LINE = 10754

MGL_IDENTITY_NV = 34346

MGL_VERTEX_WEIGHT_ARRAY_EXT = 34060

MGL_DISCARD_NV = 34096

kMGLext_SGIX_depth_texture = 37

MGL_POLYGON_OFFSET_POINT = 10753

MGL_MODELVIEW_PROJECTION_NV = 34345

MGL_SPARE1_NV = 34095

MGL_POLYGON_OFFSET_UNITS = 10752

MGL_PROGRAM_STRING_NV = 34344

MGL_ACCUM_RED_BITS = 3416

MGL_SPARE0_NV = 34094

MGL_POLYGON_OFFSET_FACTOR = 32824

MGL_MAP_COLOR = 3344

MGL_PROGRAM_LENGTH_NV = 34343

kMGLext_NV_vertex_array_range = 71

MGL_SECONDARY_COLOR_NV = 34093

MGL_TEXTURE_COORD_ARRAY_TYPE = 32905

MGL_REPEAT = 10497

MGL_CURRENT_ATTRIB_NV = 34342

MGL_PACK_IMAGE_HEIGHT_EXT = 32876

MGL_PRIMARY_COLOR_NV = 34092

MGL_CLAMP = 10496

MGL_ATTRIB_ARRAY_TYPE_NV = 34341

kMGLext_WMGL_ARB_pbuffer = 85

MGL_OUTPUT_TEXTURE_COORD27_EXT = 34744

MGL_CONSTANT_COLOR1_NV = 34091

MGL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = 33884

MGL_CLIENT_ACTIVE_TEXTURE_ARB = 34017

MGL_ATTRIB_ARRAY_STRIDE_NV = 34340

MGL_FLOAT_R16_NV = 34948

MGL_CONSTANT_COLOR0_NV = 34090

MGL_UNPACK_SWAP_BYTES = 3312

MGL_ACTIVE_TEXTURE_ARB = 34016

kMGLext_transpose_matrix = 17

MGL_ATTRIB_ARRAY_SIZE_NV = 34339

MGL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 35976

MGL_VARIABLE_G_NV = 34089

MGL_FOG_START = 2915

MGL_TEXTURE31_ARB = 34015

MGL_SOURCE0_RGB_EXT = 34176

MGL_OFFSET_TEXTURE_2D_MATRIX_NV = 34529

MGL_VARIABLE_F_NV = 34088

kMGLext_MGLX_create_context_with_config_sgix = 97

MGL_TEXTURE30_ARB = 34014

MGL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = 35978

MGL_VERTEX_PROGRAM_NV = 34336

MGL_VARIABLE_E_NV = 34087

MGL_TEXTURE_COORD_ARRAY_SIZE = 32904

MGL_LINEAR_MIPMAP_LINEAR = 9987

MGL_OPERAND3_ALPHA_NV = 34203

MGL_PACK_IMAGE_HEIGHT = 32876

MGL_VARIABLE_D_NV = 34086

MGL_NEAREST_MIPMAP_LINEAR = 9986

MGL_COLOR_ATTACHMENT4 = 36068

MGL_OPERAND3_RGB_NV = 34195

MGL_VARIABLE_C_NV = 34085

MGL_SECONDARY_COLOR_ARRAY_TYPE_EXT = 33883

MGL_LINEAR_MIPMAP_NEAREST = 9985

MGL_CURRENT_SECONDARY_COLOR_EXT = 33881

kMGLext_texture_env_combine = 14

MGL_SOURCE3_ALPHA_NV = 34187

MGL_MODELVIEW1_EXT = 34058

MGL_VARIABLE_B_NV = 34084

MGL_NEAREST_MIPMAP_NEAREST = 9984

MGL_SOURCE3_RGB_NV = 34179

MGL_VARIABLE_A_NV = 34083

MGL_MODELVIEW = 5888

MGL_LINEAR = 9729

MGL_COMBINE4_NV = 34051

MGL_CURRENT_VERTEX_EXT = 34786

MGL_REGISTER_COMBINERS_NV = 34082

MGL_NEAREST = 9728

MGL_INDEX_SHIFT = 3346

MGL_OPERAND2_ALPHA_EXT = 34202

MGL_VERTEX_ATTRIB_ARRAY9_NV = 34393

MGL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 34099

MGL_INDEX_ARRAY_STRIDE = 32902

MGL_EYE_PLANE = 9474

MGL_OPERAND1_ALPHA_EXT = 34201

MGL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 36048

MGL_VERTEX_ARRAY_RANGE_POINTER_NV = 34081

MGL_OBJECT_PLANE = 9473

MGL_COLOR_MATERIAL = 2903

MGL_OPERAND0_ALPHA_EXT = 34200

MGL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 34080

MGL_LIGHT5 = 16389

MGL_TEXTURE21_ARB = 34005

kMGLext_color_table = 28

MGL_DEPTH_RANGE = 2928

MGL_READ_WRITE_ARB = 35002

MGL_TRANSFORM_FEEDBACK_VARYINGS_EXT = 35971

MGL_VERTEX_ARRAY_RANGE_VALID_NV = 34079

MGL_TEXTURE20_ARB = 34004

MGL_DEPTH_TEST = 2929

MGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 34069

MGL_VERTEX_ARRAY_RANGE_LENGTH_NV = 34078

MGL_COLOR_INDEXES = 5635

MGL_OBJECT_LINEAR = 9217

MGL_OPERAND0_RGB_EXT = 34192

MGL_FULL_RANGE_EXT = 34785

MGL_VERTEX_ARRAY_RANGE_NV = 34077

MGL_TRANSPOSE_TEXTURE_MATRIX = 34021

MGL_TEXTURE18_ARB = 34002

MGL_INDEX_OFFSET = 3347

MGL_SOURCE2_ALPHA_EXT = 34186

MGL_CLIP_PLANE3 = 12291

MGL_FIXED_ONLY = 35101

MGL_COMPRESSED_ALPHA = 34025

MGL_TEXTURE17_ARB = 34001

MGL_TEXTURE_BORDER_VALUES_NV = 34586

MGL_SOURCE1_ALPHA_EXT = 34185

MGL_RENDERBUFFER_BINDING = 36007

MGL_CLAMP_READ_COLOR = 35100

MGL_TEXTURE16_ARB = 34000

MGL_COLOR_ATTACHMENT2 = 36066

MGL_SOURCE0_ALPHA_EXT = 34184

MGL_CLAMP_FRAGMENT_COLOR = 35099

MGL_TEXTURE1_ARB = 33985

MGL_TEXTURE15_ARB = 33999

MGL_NEVER = 512

MGL_COLOR_LOGIC_OP = 3058

MGL_VERTEX_WEIGHTING_EXT = 34057

MGL_ZOOM_X = 3350

MGL_CLAMP_VERTEX_COLOR = 35098

MGL_DECAL = 8449

MGL_SOURCE1_RGB_EXT = 34177

MGL_RGBA_FLOAT_MODE = 34848

MGL_CONSTANT_ALPHA = 32771

MGL_TEXTURE13_ARB = 33997

MGL_FOG_MODE = 2917

MGL_DRAW_BUFFER = 3073

MGL_MAX_RECTANGLE_TEXTURE_SIZE = 34040

MGL_GREATER = 516

MGL_TEXTURE12_ARB = 33996

MGL_PRIMITIVES_GENERATED_NV = 35975

MGL_PREVIOUS_EXT = 34168

MGL_PROXY_TEXTURE_RECTANGLE = 34039

MGL_MAX_CUBE_MAP_TEXTURE_SIZE = 34076

MGL_TEXTURE11_ARB = 33995

MGL_TEXTURE_2D = 3553

MGL_PRIMARY_COLOR_EXT = 34167

MGL_RESCALE_NORMAL_EXT = 32826

MGL_TEXTURE_BINDING_RECTANGLE = 34038

MGL_PROXY_TEXTURE_3D_EXT = 32880

MGL_MAX_NAME_STACK_DEPTH = 3383

MGL_TEXTURE10_ARB = 33994

MGL_ACCUM_CLEAR_VALUE = 2944

MGL_CONSTANT_EXT = 34166

MGL_TEXTURE_RECTANGLE = 34037

MGL_TEXTURE0_ARB = 33984

MGL_TEXTURE24 = 34008

MGL_INTERPOLATE_EXT = 34165

MGL_MODELVIEW_MATRIX1_EXT = 34054

MGL_LUMINANCE_ALPHA16F = 34847

kMGLext_ARB_shadow_ambient = 36

MGL_TEXTURE23 = 34007

MGL_TEXTURE_GEN_R = 3170

MGL_LUMINANCE16F = 34846

MGL_ONE_MINUS_CONSTANT_COLOR_EXT = 32770

MGL_TEXTURE22 = 34006

MGL_FUNC_ADD = 32774

MGL_READ_BUFFER = 3074

kMGLext_SGIS_generate_mipmap = 78

MGL_INTENSITY16F = 34845

MGL_TEXTURE21 = 34005

MGL_OUTPUT_TEXTURE_COORD26_EXT = 34743

MGL_PROJECTION_MATRIX = 2983

MGL_ALPHA16F = 34844

MGL_COLOR_ARRAY_TYPE = 32898

MGL_TEXTURE20 = 34004

MGL_LINE_SMOOTH_HINT = 3154

MGL_BLEND_COLOR = 32773

MGL_UNSIGNED_INT_10_10_10_2_EXT = 32822

MGL_RGB16F = 34843

kMGLext_NV_texture_shader = 70

MGL_TEXTURE19 = 34003

MGL_DEPTH_FUNC = 2932

MGL_ONE_MINUS_CONSTANT_ALPHA_EXT = 32772

MGL_RGBA16F = 34842

MGL_LIGHT2 = 16386

MGL_TEXTURE18 = 34002

MGL_ONE_MINUS_CONSTANT_ALPHA = 32772

MGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 34869

MGL_UNPACK_LSB_FIRST = 3313

MGL_TEXTURE17 = 34001

MGL_POLYGON_STIPPLE_BIT = 16

MGL_CONSTANT_ALPHA_EXT = 32771

MGL_PROGRAM_ERROR_POSITION = 34379

MGL_MATRIX17 = 35025

MGL_TEXTURE16 = 34000

MGL_FOG_HINT = 3156

MGL_ONE_EXT = 34782

MGL_PROGRAM_STRING = 34344

kMGLext_MGLX_choose_fbconfig_sgix = 96

MGL_TEXTURE15 = 33999

MGL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 35973

MGL_FRAGMENT_PROGRAM_BINDING_NV = 34931

MGL_POLYGON_SMOOTH_HINT = 3155

MGL_TEXTURE_COORD_ARRAY_EXT = 32888

MGL_DEPTH_BITS = 3414

MGL_TEXTURE14 = 33998

MGL_ONE_MINUS_CONSTANT_COLOR = 32770

MGL_UNSIGNED_INT_8_8_8_8_EXT = 32821

MGL_MAX_PROGRAM_ENV_PARAMETERS = 34997

MGL_TEXTURE_MATRIX = 2984

MGL_TEXTURE13 = 33997

MGL_DEPTH_CLEAR_VALUE = 2931

MGL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 35187

MGL_POINT_SMOOTH_HINT = 3153

MGL_MAX_PROGRAM_LOCAL_PARAMETERS = 34996

kMGLext_ARB_fragment_program_shadow = 47

MGL_SECONDARY_COLOR_ARRAY_POINTER_EXT = 33885

MGL_TEXTURE12 = 33996

MGL_COLOR_SUM_EXT = 33880

MGL_PERSPECTIVE_CORRECTION_HINT = 3152

MGL_RGBA_FLOAT_MODE_ATI = 34848

MGL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS = 34995

MGL_TEXTURE_GREEN_TYPE = 35857

MGL_TEXTURE11 = 33995

MGL_RENDER_MODE = 3136

MGL_MATRIX19 = 35027

MGL_INVARIANT_DATATYPE_EXT = 34795

MGL_PROGRAM_NATIVE_ADDRESS_REGISTERS = 34994

MGL_CONSTANT_COLOR_EXT = 32769

MGL_TEXTURE10 = 33994

MGL_MODELVIEW_STACK_DEPTH = 2979

MGL_ZERO_EXT = 34781

MGL_MAX_PROGRAM_ADDRESS_REGISTERS = 34993

MGL_TEXTURE9 = 33993

MGL_PIXEL_MAP_I_TO_I = 3184

MGL_TRANSFORM_FEEDBACK_BUFFER_START_NV = 35972

MGL_PROJECTION_STACK_DEPTH = 2980

MGL_PROGRAM_ADDRESS_REGISTERS = 34992

MGL_FENCE_CONDITION_NV = 34036

MGL_TEXTURE8 = 33992

MGL_DOT3_RGB = 34478

MGL_UNSIGNED_SHORT_5_5_5_1_EXT = 32820

MGL_MAX_PROGRAM_NATIVE_ATTRIBS = 34991

MGL_TEXTURE7 = 33991

MGL_DEPTH_WRITEMASK = 2930

MGL_PREVIOUS = 34168

MGL_PROGRAM_NATIVE_ATTRIBS = 34990

MGL_ACCUM = 256

MGL_BLUE_BIAS = 3355

MGL_TEXTURE6 = 33990

kMGLext_color_matrix = 27

MGL_PRIMARY_COLOR = 34167

MGL_BLUE_BITS = 3412

MGL_MAX_PROGRAM_ATTRIBS = 34989

MGL_TEXTURE5 = 33989

MGL_CONSTANT = 34166

MGL_TEXTURE_BINDING_CUBE_MAP_ARB = 34068

MGL_ALPHA_TEST = 3008

MGL_TEXTURE4 = 33988

MGL_SUBTRACT = 34023

MGL_INDEX_CLEAR_VALUE = 3104

MGL_MAX_PROGRAM_NATIVE_PARAMETERS = 34987

MGL_TRANSPOSE_PROJECTION_MATRIX = 34020

MGL_TEXTURE3 = 33987

MGL_OUTPUT_TEXTURE_COORD23_EXT = 34740

MGL_INTERPOLATE = 34165

MGL_MAX_VERTEX_ATTRIBS = 34921

MGL_INDEX_LOGIC_OP = 3057

MGL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072

MGL_TEXTURE2 = 33986

MGL_VIBRANCE_BIAS_NV = 34585

MGL_ADD_SIGNED = 34164

MGL_DEPTH_COMPONENT = 6402

MGL_UNSIGNED_SHORT_4_4_4_4_EXT = 32819

MGL_LOGIC_OP_MODE = 3056

kMGLext_EXT_vertex_weighting = 58

MGL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 36060

MGL_TEXTURE_FREE_MEMORY_ATI = 34812

MGL_RGB_SCALE = 34163

MGL_BLEND = 3042

MGL_NICEST = 4354

MGL_FLOAT_VEC2_ARB = 35664

MGL_TEXTURE0 = 33984

MGL_OPERAND2_ALPHA = 34202

MGL_MATRIX30 = 35038

MGL_MIRROR_CLAMP_ATI = 34626

MGL_MAX_PROGRAM_NATIVE_TEMPORARIES = 34983

MGL_TEXTURE_COMPONENTS = 4099

MGL_OPERAND1_ALPHA = 34201

MGL_BLEND_DST = 3040

MGL_ABGR_EXT = 32768

MGL_LOGIC_OP = 3057

MGL_SECONDARY_COLOR_ARRAY_EXT = 33886

MGL_OPERAND0_ALPHA = 34200

MGL_CLIENT_ATTRIB_STACK_DEPTH = 2993

MGL_MAP1_VERTEX_ATTRIB3_4_NV = 34403

MGL_DITHER = 3024

MGL_PROGRAM_UNDER_NATIVE_LIMITS = 34998

MGL_NUM_FRAGMENT_CONSTANTS_ATI = 35183

MGL_GENERATE_MIPMAP_SGIS = 33169

MGL_GREEN_BIAS = 3353

MGL_OPERAND2_RGB = 34194

MGL_PROGRAM_TEMPORARIES = 34980

MGL_VERTEX_ARRAY_STRIDE = 32892

kMGLext_WMGL_ARB_buffer_region = 84

MGL_OCCLUSION_TEST_RESULT_HP = 33126

MGL_OPERAND1_RGB = 34193

MGL_VERTEX_ATTRIB_ARRAY_STRIDE = 34340

MGL_UNSIGNED_BYTE_3_3_2_EXT = 32818

MGL_MAX_PROGRAM_NATIVE_INSTRUCTIONS = 34979

MGL_OCCLUSION_TEST_HP = 33125

MGL_ONE_MINUS_SRC_ALPHA = 771

MGL_OPERAND0_RGB = 34192

MGL_TRANSFORM_FEEDBACK_BUFFER_EXT = 35982

MGL_COLOR_WRITEMASK = 3107

MGL_CURRENT_FOG_COORDINATE_EXT = 33875

MGL_FOG_SPECULAR_TEXTURE_WIN = 33004

MGL_SOURCE2_ALPHA = 34186

MGL_TEXTURE_MAG_SIZE_NV = 34591

MGL_COLOR_CLEAR_VALUE = 3106

MGL_PHONG_HINT_WIN = 33003

kMGLext_SGIX_shadow = 38

MGL_FRONT_LEFT = 1024

MGL_INDEX_WRITEMASK = 3105

MGL_CLAMP_TO_EDGE = 33071

MGL_PHONG_WIN = 33002

MGL_SOURCE0_ALPHA = 34184

MGL_PROGRAM_BINDING = 34423

MGL_COLOR_INDEX16_EXT = 32999

MGL_MAP1_VERTEX_ATTRIB9_4_NV = 34409

MGL_DOUBLE = 5130

MGL_LIST_MODE = 2864

MGL_STENCIL_PASS_DEPTH_PASS = 2966

kMGLext_NV_register_combiners = 69

kMGLext_MGLX_create_new_context = 92

MGL_COLOR_INDEX12_EXT = 32998

MGL_4_BYTES = 5129

MGL_OBJECT_ACTIVE_ATTRIBUTES_ARB = 35721

MGL_STENCIL_PASS_DEPTH_FAIL = 2965

MGL_COLOR_INDEX8_EXT = 32997

MGL_DST_ALPHA = 772

MGL_3_BYTES = 5128

MGL_STENCIL_FAIL = 2964

MGL_FRAGMENT_DEPTH_EXT = 33874

MGL_COLOR_INDEX4_EXT = 32996

MGL_COMBINE_ALPHA = 34162

MGL_MAX_TEXTURE_IMAGE_UNITS_ARB = 34930

MGL_STENCIL_VALUE_MASK = 2963

MGL_UNPACK_ROW_LENGTH = 3314

MGL_COLOR_INDEX2_EXT = 32995

MGL_VERTEX_ARRAY_SIZE_EXT = 32890

kMGLext_texture_env_dot3 = 15

MGL_FLOAT = 5126

MGL_TRANSFORM_FEEDBACK_RECORD_NV = 35974

MGL_STENCIL_FUNC = 2962

MGL_RGBA32F = 34836

MGL_COMBINE = 34160

MGL_COPY_PIXEL_TOKEN = 1798

MGL_TEXTURE_COMPRESSED_ARB = 34465

MGL_STENCIL_CLEAR_VALUE = 2961

kMGLext_MGLX_create_pbuffer_sgix = 95

MGL_PN_TRIANGLES_NORMAL_MODE_ATI = 34803

MGL_LINE_SMOOTH = 2848

MGL_CLAMP_TO_BORDER_SGIS = 33069

MGL_STENCIL_TEST = 2960

MGL_TEXTURE_CUBE_MAP_POSITIVE_X = 34069

MGL_ALPHA_BITS = 3413

MGL_PN_TRIANGLES_POINT_MODE_ATI = 34802

MGL_CLAMP_TO_BORDER = 33069

MGL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 35661

MGL_PIXEL_MAP_S_TO_S = 3185

MGL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 34801

MGL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 36057

MGL_COMPRESSED_TEXTURE_FORMATS = 34467

MGL_STEREO = 3123

kMGLext_ARB_color_buffer_float = 46

MGL_PN_TRIANGLES_ATI = 34800

MGL_NUM_COMPRESSED_TEXTURE_FORMATS = 34466

MGL_SUBPIXEL_BITS = 3408

MGL_DOUBLEBUFFER = 3122

MGL_QUERY_RESULT_AVAILABLE_ARB = 34919

MGL_4D_COLOR_TEXTURE = 1540

MGL_INVARIANT_VALUE_EXT = 34794

MGL_COLOR_SUM = 33880

MGL_TEXTURE_STACK_DEPTH = 2981

MGL_QUERY_RESULT_ARB = 34918

MGL_3D_COLOR_TEXTURE = 1539

MGL_ZOOM_Y = 3351

MGL_W_EXT = 34776

MGL_PIXEL_MAP_A_TO_A = 3193

MGL_CURRENT_QUERY_ARB = 34917

MGL_MAP1_VERTEX_ATTRIB7_4_NV = 34407

MGL_3D_COLOR = 1538

MGL_PIXEL_MAP_B_TO_B = 3192

MGL_PROGRAM_NATIVE_PARAMETERS = 34986

MGL_SAMPLES_PASSED_ARB = 35092

MGL_REG_4_ATI = 35109

MGL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 35660

MGL_PIXEL_MAP_G_TO_G = 3191

MGL_PIXEL_COUNTER_BITS_ARB = 34916

MGL_DST_COLOR = 774

MGL_2D = 1536

MGL_PIXEL_MAP_R_TO_R = 3190

MGL_PIXEL_COUNT_AVAILABLE_NV = 34919

MGL_VERTEX_ARRAY_TYPE = 32891

kMGLext_histogram = 26

MGL_REG_2_ATI = 35107

MGL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 34832

MGL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = 35967

MGL_PIXEL_MAP_I_TO_A = 3189

MGL_VERTEX_ATTRIB_ARRAY4_NV = 34388

MGL_PIXEL_COUNT_NV = 34918

MGL_REG_1_ATI = 35106

MGL_TEXTURE_CUBE_MAP_ARB = 34067

MGL_TEXTURE_DEPTH_TYPE = 35862

MGL_CURRENT_OCCLUSION_QUERY_ID_NV = 34917

MGL_LEQUAL = 515

MGL_Z_EXT = 34775

MGL_PIXEL_MAP_I_TO_G = 3187

MGL_TRANSPOSE_MODELVIEW_MATRIX = 34019

MGL_PIXEL_COUNTER_BITS_NV = 34916

MGL_OUTPUT_TEXTURE_COORD18_EXT = 34735

MGL_BYTE = 5120

MGL_PIXEL_MAP_I_TO_R = 3186

MGL_TEXTURE_CUBE_MAP = 34067

MGL_FLOAT_RGBA_MODE_NV = 34958

MGL_LOCAL_CONSTANT_DATATYPE_EXT = 34797

MGL_MAX_VARYING_FLOATS_ARB = 35659

MGL_CLIP_PLANE5 = 12293

kMGLext_EXT_fog_coord = 57

MGL_FLOAT_CLEAR_COLOR_VALUE_NV = 34957

MGL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 36055

MGL_LOCAL_CONSTANT_VALUE_EXT = 34796

MGL_CLIP_PLANE4 = 12292

MGL_VERTEX_PROGRAM_TWO_SIDE = 34371

MGL_TEXTURE_FLOAT_COMPONENTS_NV = 34956

MGL_POINT_TOKEN = 1793

MGL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 34831

MGL_COLOR_ARRAY = 32886

MGL_FLOAT_RGBA32_NV = 34955

MGL_COLOR_BUFFER_BIT = 16384

MGL_NORMAL_ARRAY = 32885

MGL_TEXTURE_INTENSITY_TYPE = 35861

MGL_COMPRESSED_ALPHA_ARB = 34025

MGL_ENABLE_BIT = 8192

MGL_Y_EXT = 34774

MGL_CLIP_PLANE1 = 12289

MGL_FLOAT_RGB32_NV = 34953

MGL_MAP1_VERTEX_ATTRIB5_4_NV = 34405

MGL_TRANSFORM_BIT = 4096

kMGLext_WMGL_NV_allocate_memory = 89

MGL_CLIP_PLANE0 = 12288

MGL_COMBINE_RGB_EXT = 34161

kMGLext_WMGL_ARB_extensions_string = 83

MGL_FLOAT_RGB16_NV = 34952

MGL_VARIANT_ARRAY_TYPE_EXT = 34791

MGL_BLEND_EQUATION_EXT = 32777

MGL_SRC_ALPHA_SATURATE = 776

MGL_TEXTURE_3D_EXT = 32879

MGL_FLOAT_RG32_NV = 34951

MGL_STENCIL_BUFFER_BIT = 1024

MGL_FOG_INDEX = 2913

MGL_FLOAT_RG16_NV = 34950

MGL_MAX_TEXTURE_STACK_DEPTH = 3385

MGL_TEXTURE_PRIORITY = 32870

MGL_FLOAT_R32_NV = 34949

MGL_ALWAYS = 519

MGL_TEXTURE_2D_BINDING = 32873

MGL_TEXTURE_LUMINANCE_TYPE = 35860

MGL_CURRENT_VERTEX_WEIGHT_EXT = 34059

MGL_GEQUAL = 518

MGL_X_EXT = 34773

MGL_TEXTURE_1D_BINDING = 32872

MGL_FLOAT_RGBA_NV = 34947

MGL_MAP1_VERTEX_ATTRIB4_4_NV = 34404

MGL_FOG_COLOR = 2918

MGL_POINT = 6912

MGL_PROXY_TEXTURE_2D = 32868

kMGLext_NV_fence = 68

MGL_PROGRAM_ATTRIBS = 34988

MGL_FLOAT_RGB_NV = 34946

MGL_AUX_BUFFERS = 3072

MGL_VERTEX_SHADER_ARB = 35633

MGL_PROXY_TEXTURE_1D = 32867

MGL_PROGRAM_FORMAT = 34934

MGL_FLOAT_RG_NV = 34945

MGL_NORMALIZED_RANGE_EXT = 34784

MGL_TEXTURE_INTENSITY_SIZE = 32865

MGL_FLOAT_R_NV = 34944

MGL_NEGATIVE_ONE_EXT = 34783

MGL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 34829

MGL_TEXTURE_LUMINANCE_SIZE = 32864

MGL_MODELVIEW0_MATRIX_EXT = 2982

MGL_SCISSOR_BOX = 3088

MGL_TEXTURE_ALPHA_SIZE = 32863

MGL_TEXTURE_ALPHA_TYPE = 35859

MGL_MODELVIEW1_STACK_DEPTH_EXT = 34050

MGL_SCISSOR_TEST = 3089

MGL_VERTEX_SHADER_OPTIMIZED_EXT = 34772

MGL_TEXTURE_IMAGE_SIZE_ARB = 34464

MGL_TEXTURE_BLUE_SIZE = 32862

kMGLext_MGLX_destroy_pbuffer = 94

MGL_MIRROR_CLAMP_TO_EDGE_ATI = 34627

MGL_OUTPUT_TEXTURE_COORD15_EXT = 34732

MGL_NEGATIVE_W_EXT = 34780

MGL_TEXTURE_GREEN_SIZE = 32861

MGL_EMBOSS_MAP_NV = 34143

MGL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 34047

MGL_NEGATIVE_Z_EXT = 34779

MGL_FLOAT_MAT4_ARB = 35676

MGL_TEXTURE_RED_SIZE = 32860

MGL_RED_BITS = 3410

MGL_NEGATIVE_Y_EXT = 34778

MGL_RGBA16 = 32859

kMGLext_ARB_texture_float = 45

MGL_INDEX_BITS = 3409

MGL_FOG_COORDINATE_ARRAY_POINTER_EXT = 33878

MGL_NEGATIVE_X_EXT = 34777

MGL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 34828

MGL_RGBA12 = 32858

MGL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074

MGL_MAX_TEXTURE_COORDS_ARB = 34929

MGL_TEXTURE2_ARB = 33986

MGL_LINE_RESET_TOKEN = 1799

MGL_VARIANT_ARRAY_POINTER_EXT = 34793

MGL_RGB10_A2 = 32857

MGL_TEXTURE_BLUE_TYPE = 35858

MGL_TEXTURE_MAG_FILTER = 10240

MGL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 3387

MGL_EXP = 2048

MGL_VERTEX_SHADER_LOCALS_EXT = 34771

MGL_RGBA8 = 32856

MGL_MAX_VIEWPORT_DIMS = 3386

MGL_MAP1_VERTEX_ATTRIB2_4_NV = 34402

MGL_EXP2 = 2049

MGL_RGB5_A1 = 32855

MGL_VERTEX_ATTRIB_ARRAY6_NV = 34390

MGL_SAMPLE_COVERAGE_INVERT = 32939

MGL_TRACK_MATRIX_TRANSFORM_NV = 34377

MGL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 34830

MGL_CW = 2304

MGL_FLOAT_MAT3_ARB = 35675

MGL_RGBA4 = 32854

MGL_MAX_PROJECTION_STACK_DEPTH = 3384

MGL_CCW = 2305

MGL_RGBA2 = 32853

MGL_MAGNITUDE_BIAS_NV = 34584

kMGLext_blend_subtract = 25

MGL_COEFF = 2560

MGL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 34827

MGL_RGB16 = 32852

MGL_MAX_MODELVIEW_STACK_DEPTH = 3382

MGL_ORDER = 2561

MGL_RGB12 = 32851

MGL_TEXTURE_BORDER = 4101

MGL_MAX_ATTRIB_STACK_DEPTH = 3381

MGL_VIEWPORT_BIT = 2048

MGL_DOMAIN = 2562

MGL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 34770

MGL_RGB10 = 32850

MGL_MAX_PIXEL_MAP_TABLE = 3380

MGL_MAP1_VERTEX_ATTRIB1_4_NV = 34401

MGL_CURRENT_COLOR = 2816

MGL_TRANSPOSE_CURRENT_MATRIX = 34999

MGL_RGB8 = 32849

MGL_MAX_PROGRAM_PARAMETERS = 34985

MGL_MAX_TEXTURE_SIZE = 3379

MGL_DT_BIAS_NV = 34583

MGL_CURRENT_INDEX = 2817

MGL_MIN_EXT = 32775

MGL_RGB5 = 32848

kMGLext_EXT_secondary_color = 56

MGL_SWIZZLE_STR_DR_ATI = 35192

MGL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 34766

MGL_RGB4 = 32847

MGL_TEXTURE1 = 33985

MGL_VERTEX_PROGRAM_POINT_SIZE = 34370

MGL_PROGRAM_TEX_INSTRUCTIONS_ARB = 34822

MGL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 34765

MGL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 34826

MGL_R3_G3_B2 = 10768

MGL_OUTPUT_TEXTURE_COORD12_EXT = 34729

MGL_MAX_EVAL_ORDER = 3376

MGL_CURRENT_RASTER_COLOR = 2820

MGL_INTENSITY16 = 32845

MGL_TEXTURE_BORDER_COLOR = 4100

MGL_DEPTH_BIAS = 3359

kMGLext_NV_float_buffer = 49

MGL_OBJECT_COMPILE_STATUS_ARB = 35713

MGL_VERTEX_SHADER_INVARIANTS_EXT = 34769

MGL_INTENSITY12 = 32844

MGL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 34920

MGL_MAX_LIST_NESTING = 2865

MGL_OBJECT_DELETE_STATUS_ARB = 35712

MGL_INTENSITY8 = 32843

MGL_PRIMITIVE_RESTART_INDEX_NV = 34137

kMGLext_texture_array = 82

MGL_ALPHA_BIAS = 3357

MGL_CURRENT_RASTER_POSITION = 2823

MGL_BOOL_VEC4_ARB = 35673

MGL_INTENSITY4 = 32842

MGL_NUM_INSTRUCTIONS_TOTAL_ATI = 35186

MGL_ACCUM_BUFFER_BIT = 512

MGL_OBJECT_TYPE_ARB = 35662

MGL_INTERLEAVED_ATTRIBS_EXT = 35980

MGL_INTENSITY = 32841

MGL_MAX_TEXTURE_IMAGE_UNITS_NV = 34930

MGL_PROGRAM_OBJECT_ARB = 35648

MGL_BACK_RIGHT = 1027

MGL_SWIZZLE_STRQ_ATI = 35194

MGL_TEXTURE_RED_TYPE = 35856

MGL_PIXEL_MAP_S_TO_S_SIZE = 3249

MGL_MODELVIEW0_STACK_DEPTH_EXT = 2979

MGL_POINT_SMOOTH = 2832

MGL_RENDERBUFFER_STENCIL_SIZE = 36181

MGL_MATRIX3 = 35011

MGL_SAMPLE_COVERAGE_VALUE = 32938

MGL_FRAGMENT_PROGRAM_NV = 34928

MGL_POINT_SIZE = 2833

MGL_VERTEX_SHADER_VARIANTS_EXT = 34768

MGL_RENDERBUFFER_DEPTH_SIZE = 36180

MGL_PIXEL_MAP_I_TO_G_SIZE = 3251

MGL_LIST_BASE = 2866

MGL_POINT_SIZE_RANGE = 2834

MGL_RENDERBUFFER_ALPHA_SIZE = 36179

kMGLext_ATI_texture_mirror_once = 67

MGL_PRIMITIVE_RESTART_NV = 34136

MGL_PIXEL_MAP_I_TO_B_SIZE = 3252

MGL_POINT_SIZE_GRANULARITY = 2835

MGL_BOOL_VEC3_ARB = 35672

MGL_RENDERBUFFER_BLUE_SIZE = 36178

MGL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX = 36938

MGL_SOURCE1_RGB = 34177

MGL_RENDERBUFFER_GREEN_SIZE = 36177

MGL_PIXEL_MAP_R_TO_R_SIZE = 3254

MGL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX = 36937

MGL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 34824

MGL_RENDERBUFFER_RED_SIZE = 36176

MGL_POLYGON = 9

MGL_UNPACK_SKIP_PIXELS = 3316

MGL_REG_31_ATI = 35136

MGL_STACK_UNDERFLOW = 1284

MGL_MATRIX2 = 35010

MGL_LERP_ATI = 35177

MGL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX = 36935

MGL_VERTEX_SHADER_INSTRUCTIONS_EXT = 34767

MGL_TEXTURE_COMPRESSION_HINT_ARB = 34031

MGL_STENCIL_INDEX8 = 36168

kMGLext_MGLX_destroy_window = 93

MGL_PIXEL_MAP_A_TO_A_SIZE = 3257

MGL_OUTPUT_TEXTURE_COORD10_EXT = 34727

MGL_TEXTURE_INTERNAL_FORMAT = 4099

MGL_INVALID_OPERATION = 1282

MGL_STENCIL_INDEX4 = 36167

MGL_PROGRAM_NATIVE_TEMPORARIES = 34982

MGL_GREEN_BITS = 3411

MGL_DOT4_ATI = 35175

MGL_INVALID_VALUE = 1281

MGL_STENCIL_INDEX1 = 36166

MGL_DOT3_ATI = 35174

MGL_NUM_PASSES_ATI = 35184

MGL_SEPARATE_ATTRIBS_EXT = 35981

MGL_INTENSITY32F = 34839

MGL_RENDERBUFFER_INTERNAL_FORMAT = 36164

kMGLext_ARB_half_float_pixel = 44

MGL_SUB_ATI = 35173

MGL_FOG_COORDINATE_ARRAY_STRIDE_EXT = 33877

MGL_2_BYTES = 5127

MGL_AUX3 = 1036

MGL_PROGRAM_TEX_INDIRECTIONS_ARB = 34823

MGL_RENDERBUFFER_HEIGHT = 36163

MGL_TEXTURE_CUBE_MAP_POSITIVE_Z = 34073

MGL_MUL_ATI = 35172

MGL_Q = 8195

MGL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = 35979

MGL_MATRIX16 = 35024

MGL_VARIANT_ARRAY_EXT = 34792

MGL_RENDERBUFFER_WIDTH = 36162

MGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 34074

MGL_4X_BIT_ATI = 2

MGL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 34762

MGL_CURRENT_NORMAL = 2818

MGL_RENDERBUFFER = 36161

MGL_2X_BIT_ATI = 1

MGL_OUTPUT_TEXTURE_COORD9_EXT = 34726

MGL_MODELVIEW_MATRIX = 2982

MGL_MAX_VERTEX_SHADER_LOCALS_EXT = 34761

MGL_FRAMEBUFFER = 36160

MGL_VERTEX_ATTRIB_ARRAY5_NV = 34389

MGL_COMBINER6_NV = 34134

MGL_PROGRAM_PARAMETERS = 34984

MGL_FALSE = 0

MGL_FRONT_AND_BACK = 1032

MGL_BOOL_ARB = 35670

MGL_STENCIL_ATTACHMENT = 36128

MGL_VECTOR_EXT = 34751

MGL_CLIENT_ALL_ATTRIB_BITS = -1

MGL_RIGHT = 1031

MGL_DEPTH_ATTACHMENT = 36096

MGL_CON_29_ATI = 35166

MGL_LEFT = 1030

MGL_SWIZZLE_STQ_ATI = 35191

MGL_COLOR_ATTACHMENT15 = 36079

MGL_CON_28_ATI = 35165

MGL_REG_29_ATI = 35134

MGL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 34757

MGL_OPERAND1_RGB_EXT = 34193

MGL_NORMAL_MAP_ARB = 34065

MGL_COLOR_ATTACHMENT14 = 36078

MGL_SELECTION_BUFFER_SIZE = 3572

MGL_CON_27_ATI = 35164

MGL_SPHERE_MAP = 9218

MGL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 34825

MGL_LOCAL_EXT = 34756

MGL_CURRENT_TEXTURE_COORDS = 2819

MGL_COLOR_ATTACHMENT13 = 36077

MGL_CLIENT_ACTIVE_TEXTURE = 34017

MGL_CON_26_ATI = 35163

MGL_POLYGON_SMOOTH = 2881

MGL_LOCAL_CONSTANT_EXT = 34755

MGL_CURRENT_MATRIX = 34369

MGL_COLOR_ATTACHMENT12 = 36076

MGL_RGBA_MODE = 3121

MGL_VERTEX_ARRAY_POINTER = 32910

MGL_CON_25_ATI = 35162

MGL_VARIANT_DATATYPE_EXT = 34789

MGL_INVARIANT_EXT = 34754

MGL_LO_BIAS_NV = 34581

MGL_COLOR_ATTACHMENT11 = 36075

kMGLext_EXT_cull_vertex = 55

MGL_CON_24_ATI = 35161

MGL_REG_0_ATI = 35105

MGL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = 35958

MGL_COLOR_ATTACHMENT10 = 36074

MGL_VERTEX_PROGRAM = 34336

MGL_CON_23_ATI = 35160

MGL_PACK_ROW_LENGTH = 3330

MGL_SWIZZLE_STR_ATI = 35190

MGL_BLEND_SRC = 3041

MGL_COLOR_ATTACHMENT9 = 36073

MGL_CON_22_ATI = 35159

MGL_REG_28_ATI = 35133

MGL_PACK_SKIP_ROWS = 3331

MGL_COLOR_ATTACHMENT8 = 36072

MGL_SELECTION_BUFFER_POINTER = 3571

MGL_CON_21_ATI = 35158

MGL_PACK_SKIP_PIXELS = 3332

MGL_COLOR_ATTACHMENT7 = 36071

MGL_CON_20_ATI = 35157

MGL_POLYGON_STIPPLE = 2882

MGL_INTERLEAVED_ATTRIBS_NV = 35980

MGL_CONSTANT_COLOR = 32769

MGL_COLOR_ATTACHMENT6 = 36070

MGL_MULTISAMPLE = 32925

kMGLext_framebuffer_multisample = 81

MGL_CON_19_ATI = 35156

MGL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 35979

MGL_INT_VEC3_ARB = 35668

MGL_COLOR_ATTACHMENT5 = 36069

MGL_UNPACK_IMAGE_HEIGHT_EXT = 32878

MGL_CON_18_ATI = 35155

MGL_MAX_VERTEX_SHADER_INVARIANTS_EXT = 34759

MGL_TRANSPOSE_TEXTURE_MATRIX_ARB = 34021

MGL_OUTPUT_TEXTURE_COORD30_EXT = 34747

MGL_FOG = 2912

MGL_CON_17_ATI = 35154

MGL_RASTERIZER_DISCARD_NV = 35977

MGL_VERTEX_STATE_PROGRAM_NV = 34337

MGL_COLOR_ALPHA_PAIRING_ATI = 35189

MGL_COLOR_ATTACHMENT3 = 36067

MGL_CON_16_ATI = 35153

MGL_TEXTURE_MIN_FILTER = 10241

MGL_NOTEQUAL = 517

MGL_OUTPUT_TEXTURE_COORD28_EXT = 34745

MGL_COLOR_MATERIAL_PARAMETER = 2902

MGL_FEEDBACK_BUFFER_TYPE = 3570

MGL_RED_SCALE = 3348

MGL_CURRENT_RASTER_INDEX = 2821

MGL_COLOR_ATTACHMENT1 = 36065

MGL_CON_15_ATI = 35152

MGL_VERTEX_ATTRIB_ARRAY10_NV = 34394

MGL_RED_BIAS = 3349

MGL_COLOR_ATTACHMENT0 = 36064

MGL_PROGRAM_NATIVE_INSTRUCTIONS = 34978

MGL_CON_14_ATI = 35151

MGL_OUTPUT_TEXTURE_COORD25_EXT = 34742

MGL_VIBRANCE_SCALE_NV = 34579

MGL_MAX_COLOR_ATTACHMENTS = 36063

MGL_VERTEX_ATTRIB_ARRAY_POINTER = 34373

MGL_CON_13_ATI = 35150

MGL_TRANSPOSE_PROJECTION_MATRIX_ARB = 34020

MGL_OUTPUT_TEXTURE_COORD24_EXT = 34741

MGL_FRAMEBUFFER_UNSUPPORTED = 36061

MGL_TEXTURE_MAX_ANISOTROPY_EXT = 34046

MGL_CON_12_ATI = 35149

MGL_GREEN_SCALE = 3352

MGL_AUX0 = 1033

MGL_NUM_LOOPBACK_COMPONENTS_ATI = 35188

MGL_SRC_ALPHA = 770

MGL_CON_11_ATI = 35148

MGL_UNPACK_ALIGNMENT = 3317

MGL_REG_26_ATI = 35131

MGL_TEXTURE7_ARB = 33991

MGL_OUTPUT_TEXTURE_COORD22_EXT = 34739

kMGLext_texture_cube_map = 12

MGL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 36059

MGL_TRANSFORM_FEEDBACK_VARYINGS_NV = 35971

MGL_MAX_PROGRAM_MATRICES = 34351

MGL_CON_10_ATI = 35147

MGL_BLUE_SCALE = 3354

MGL_CURRENT_RASTER_TEXTURE_COORDS = 2822

MGL_TEXTURE_WRAP_R_EXT = 32882

MGL_FRAMEBUFFER_INCOMPLETE_FORMATS = 36058

MGL_CON_9_ATI = 35146

MGL_COLOR_INDEX1_EXT = 32994

MGL_TEXTURE_HEIGHT = 4097

MGL_MAP1_VERTEX_ATTRIB8_4_NV = 34408

MGL_MAX_PROGRAM_INSTRUCTIONS = 34977

MGL_CON_8_ATI = 35145

MGL_LIGHTING_BIT = 64

MGL_MAGNITUDE_SCALE_NV = 34578

MGL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT = 36056

MGL_VERTEX_ATTRIB_ARRAY8_NV = 34392

MGL_CON_7_ATI = 35144

MGL_TRANSPOSE_MODELVIEW_MATRIX_ARB = 34019

MGL_LINE_WIDTH_RANGE = 2850

MGL_ALPHA32F = 34838

MGL_ONE_MINUS_DST_COLOR = 775

kMGLext_ARB_vertex_buffer_object = 43

MGL_CON_6_ATI = 35143

kMGLext_texture_env_add = 13

MGL_PROGRAM_ERROR_STRING_NV = 34932

MGL_LIST_BIT = 131072

MGL_CON_5_ATI = 35142

MGL_VERSION = 7938

MGL_OUTPUT_TEXTURE_COORD16_EXT = 34733

MGL_TEXTURE_BIT = 262144

MGL_SOURCE1_ALPHA = 34185

MGL_CON_4_ATI = 35141

MGL_LINE_STIPPLE_PATTERN = 2853

MGL_OBJECT_SUBTYPE_ARB = 35663

MGL_SCISSOR_BIT = 524288

MGL_CON_3_ATI = 35140

MGL_COLOR_TABLE_INTENSITY_SIZE_EXT = 32991

MGL_OUTPUT_TEXTURE_COORD14_EXT = 34731

MGL_ALL_ATTRIB_BITS = 1048575

MGL_PROGRAM_INSTRUCTIONS = 34976

MGL_CON_2_ATI = 35139

MGL_OUTPUT_TEXTURE_COORD13_EXT = 34730

MGL_DT_SCALE_NV = 34577

MGL_SRC_COLOR = 768

MGL_CON_1_ATI = 35138

MGL_MAX_TEXTURE_UNITS_ARB = 34018

MGL_MAP1_VERTEX_ATTRIB0_4_NV = 34400

MGL_ONE_MINUS_SRC_COLOR = 769

MGL_CON_0_ATI = 35137

MGL_OUTPUT_TEXTURE_COORD11_EXT = 34728

kMGLext_blend_color = 23

MGL_ALPHA_SCALE = 3356

MGL_VIEWPORT = 2978

MGL_MODULATE = 8448

MGL_RENDERER = 7937

MGL_LIST_INDEX = 2867

MGL_NORMALIZE = 2977

MGL_HALF_FLOAT = 5131

MGL_REG_30_ATI = 35135

MGL_POLYGON_MODE = 2880

MGL_CURRENT_RASTER_POSITION_VALID = 2824

MGL_MATRIX_MODE = 2976

MGL_R = 8194

MGL_COLOR_TABLE_LUMINANCE_SIZE_EXT = 32990

MGL_OUTPUT_TEXTURE_COORD8_EXT = 34725

MGL_STENCIL_WRITEMASK = 2968

MGL_STENCIL_REF = 2967

MGL_T = 8193

MGL_OUTPUT_TEXTURE_COORD7_EXT = 34724

MGL_DS_SCALE_NV = 34576

kMGLext_EXT_compiled_vertex_array = 54

MGL_REG_27_ATI = 35132

MGL_TEXTURE_WRAP_T = 10243

MGL_EDGE_FLAG = 2883

MGL_SWIZZLE_STRQ_DQ_ATI = 35195

MGL_EXTENSIONS = 7939

MGL_CULL_FACE = 2884

MGL_NUM_INSTRUCTIONS_PER_PASS_ATI = 35185

MGL_REG_3_ATI = 35108

MGL_ALPHA_TEST_REF = 3010

MGL_REG_25_ATI = 35130

MGL_VENDOR = 7936

MGL_CULL_FACE_MODE = 2885

MGL_ALPHA_TEST_FUNC = 3009

MGL_SOURCE2_RGB = 34178

MGL_REG_24_ATI = 35129

MGL_FRONT_FACE = 2886

MGL_CURRENT_RASTER_DISTANCE = 2825

MGL_EMISSION = 5632

MGL_VERTEX_ATTRIB_ARRAY15_NV = 34399

MGL_REG_23_ATI = 35128

MGL_LIGHTING = 2896

MGL_COLOR_TABLE_ALPHA_SIZE_EXT = 32989

MGL_SET = 5391

MGL_COLOR_SUM_CLAMP_NV = 34127

kMGLext_packed_depth_stencil = 80

MGL_REG_22_ATI = 35127

MGL_LIGHT_MODEL_LOCAL_VIEWER = 2897

MGL_TEXTURE_GEN_Q = 3171

MGL_LO_SCALE_NV = 34575

MGL_LESS = 513

MGL_UNPACK_IMAGE_HEIGHT = 32878

MGL_REG_21_ATI = 35126

MGL_MAX_CLIP_PLANES = 3378

MGL_TEXTURE_WRAP_S = 10242

MGL_TEXTURE29_ARB = 34013

MGL_COLOR_TABLE_GREEN_SIZE_EXT = 32987

kMGLext_ARB_depth_texture = 34

MGL_OR_INVERTED = 5389

MGL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = 35978

MGL_REG_20_ATI = 35125

MGL_LIGHT_MODEL_AMBIENT = 2899

kMGLext_ARB_texture_non_power_of_two = 20

MGL_MAX_TEXTURE_COORDS_NV = 34929

MGL_COPY_INVERTED = 5388

MGL_KEEP = 7680

MGL_DECR = 7683

MGL_SHADE_MODEL = 2900

MGL_ADD = 260

MGL_REFLECTION_MAP_ARB = 34066

MGL_REG_18_ATI = 35123

MGL_COLOR_MATERIAL_FACE = 2901

MGL_RENDERBUFFER_FREE_MEMORY_ATI = 34813

MGL_RETURN = 258

MGL_FLAT = 7424

MGL_COLOR_TABLE_BLUE_SIZE_EXT = 32988

MGL_T4F_C4F_N3F_V4F = 10797

MGL_EQUIV = 5385

MGL_PROGRAM_LENGTH = 34343

kMGLext_ATI_fragment_shader = 65

MGL_REG_16_ATI = 35121

MGL_PROGRAM_ERROR_POSITION_NV = 34379

MGL_OBJECT_SHADER_SOURCE_LENGTH_ARB = 35720

MGL_NOR = 5384

MGL_FEEDBACK = 7169

MGL_NAND = 5390

MGL_T2F_N3F_V3F = 10795

MGL_OR = 5383

MGL_OUTPUT_TEXTURE_COORD21_EXT = 34738

MGL_RENDER = 7168

MGL_PIXEL_MAP_I_TO_R_SIZE = 3250

MGL_LOAD = 257

MGL_REG_13_ATI = 35118

MGL_PACK_SWAP_BYTES = 3328

MGL_INCR = 7682

MGL_TEXTURE6_ARB = 33990

MGL_T2F_C4UB_V3F = 10793

kMGLext_texture_compression = 11

MGL_NOOP = 5381

MGL_SOURCE0_RGB = 34176

MGL_LINE = 6913

MGL_PROGRAM_RESIDENT_NV = 34375

MGL_AND_INVERTED = 5380

kMGLext_MGLX_choose_fbconfig = 91

MGL_REG_11_ATI = 35116

MGL_LIGHT_MODEL_TWO_SIDE = 2898

MGL_TEXTURE_WIDTH = 4096

MGL_PROGRAM_TARGET_NV = 34374

MGL_ATTRIB_STACK_DEPTH = 2992

MGL_MAX_GENERAL_COMBINERS_NV = 34125

MGL_BITMAP = 6656

MGL_ATTRIB_ARRAY_POINTER_NV = 34373

MGL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 35719

MGL_AND_REVERSE = 5378

MGL_LUMINANCE_ALPHA = 6410

MGL_EQUAL = 514

MGL_N3F_V3F = 10789

MGL_AND = 5377

kMGLext_ARB_occlusion_query = 42

MGL_LUMINANCE = 6409

MGL_UNSIGNED_INT = 5125

MGL_C3F_V3F = 10788

MGL_NUM_FRAGMENT_REGISTERS_ATI = 35182

MGL_CLEAR = 5376

MGL_RGBA = 6408

MGL_REPLACE = 7681

MGL_C4UB_V3F = 10787

MGL_VARIANT_ARRAY_STRIDE_EXT = 34790

MGL_COMPILE_AND_EXECUTE = 4865

MGL_DECR_WRAP_EXT = 34056

MGL_ONE_MINUS_DST_ALPHA = 773

MGL_RGB = 6407

MGL_C4UB_V2F = 10786

MGL_VBO_FREE_MEMORY_ATI = 34811

MGL_COMPILE = 4864

kMGLext_NV_transform_feedback = 76

MGL_ALPHA = 6406

MGL_COLOR_TABLE_RED_SIZE_EXT = 32986

MGL_FOG_DENSITY = 2914

MGL_CURRENT_MATRIX_STACK_DEPTH_NV = 34368

MGL_QUADRATIC_ATTENUATION = 4617

MGL_CURRENT_VERTEX_ATTRIB = 34342

MGL_ARRAY_BUFFER_ARB = 34962

MGL_MATRIX7_NV = 34359

MGL_SIGNED_RGB_UNSIGNED_ALPHA_NV = 34572

MGL_LINEAR_ATTENUATION = 4616

MGL_OUTPUT_FOG_EXT = 34749

MGL_GREEN = 6404

MGL_MULT = 259

MGL_VERTEX_ATTRIB_ARRAY7_NV = 34391

MGL_EDGE_FLAG_ARRAY_POINTER = 32915

MGL_CONSTANT_ATTENUATION = 4615

MGL_RED = 6403

MGL_PIXEL_MAP_I_TO_A_SIZE = 3253

MGL_MATRIX5_NV = 34357

kMGLext_imaging_subset = 22

MGL_FENCE_STATUS_NV = 34035

MGL_SPOT_CUTOFF = 4614

MGL_SEPARATE_ATTRIBS_NV = 35981

MGL_MATRIX29 = 35037

MGL_REG_19_ATI = 35124

MGL_INDEX_ARRAY_POINTER = 32913

MGL_SPOT_EXPONENT = 4613

MGL_INCR_WRAP_EXT = 34055

MGL_STENCIL_INDEX = 6401

MGL_COLOR_ARRAY_POINTER = 32912

MGL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX = 36939

MGL_SPOT_DIRECTION = 4612

MGL_TEXTURE31 = 34015

MGL_COLOR_INDEX = 6400

MGL_COLOR_TABLE_WIDTH_EXT = 32985

MGL_NORMAL_ARRAY_POINTER = 32911

MGL_POSITION = 4611

MGL_TEXTURE30 = 34014

MGL_MATRIX26 = 35034

MGL_SWIZZLE_STQ_DQ_ATI = 35193

MGL_DSDT8_MAG8_INTENSITY8_NV = 34571

MGL_COLOR = 6144

MGL_SPECULAR = 4610

kMGLext_ARB_ES2_compatibility = 53

MGL_DEPTH = 6145

MGL_OR_REVERSE = 5387

MGL_EDGE_FLAG_ARRAY_STRIDE = 32908

MGL_DIFFUSE = 4609

MGL_MATRIX24 = 35032

MGL_COMPRESSED_RGB = 34029

MGL_DOT2_ADD_ATI = 35180

MGL_AMBIENT = 4608

MGL_TEXTURE = 5890

MGL_SMOOTH = 7425

MGL_COMPRESSED_INTENSITY = 34028

MGL_TEXTURE_GEN_S = 3168

MGL_LIGHT7 = 16391

MGL_MAP2_VERTEX_4 = 3512

MGL_MATRIX22 = 35030

MGL_COMPRESSED_LUMINANCE_ALPHA = 34027

MGL_UNSIGNED_BYTE = 5121

MGL_LIGHT6 = 16390

MGL_VERTEX_ATTRIB_ARRAY14_NV = 34398

MGL_MATRIX21 = 35029

MGL_COLOR_TABLE_FORMAT_EXT = 32984

MGL_COMPRESSED_LUMINANCE = 34026

MGL_SECONDARY_COLOR_ARRAY_SIZE_EXT = 33882

MGL_TEXTURE29 = 34013

kMGLext_frame_buffer_object = 79

MGL_MATRIX20 = 35028

MGL_XOR = 5382

MGL_INDEX_ARRAY_TYPE = 32901

MGL_DSDT8_MAG8_NV = 34570

MGL_LIGHT4 = 16388

MGL_UNPACK_SKIP_IMAGES_EXT = 32877

MGL_AMBIENT_AND_DIFFUSE = 5634

MGL_MAX_LIGHTS = 3377

MGL_INVERT = 5386

MGL_TEXTURE28_ARB = 34012

MGL_COLOR_ARRAY_STRIDE = 32899

kMGLext_ARB_texture_env_crossbar = 33

MGL_LIGHT3 = 16387

MGL_MATRIX18 = 35026

MGL_PROXY_TEXTURE_CUBE_MAP = 34075

MGL_CND0_ATI = 35179

MGL_FOG_COORDINATE_ARRAY_EXT = 33879

MGL_LUMINANCE_ALPHA32F = 34841

MGL_REG_17_ATI = 35122

MGL_COLOR_ARRAY_SIZE = 32897

MGL_LIGHT1 = 16385

MGL_INT = 5124

MGL_SAMPLE_COVERAGE = 32928

MGL_LUMINANCE32F = 34840

MGL_NORMAL_ARRAY_STRIDE = 32895

MGL_OUT_OF_MEMORY = 1285

MGL_LIGHT0 = 16384

MGL_MATRIX15 = 35023

MGL_BITMAP_TOKEN = 1796

MGL_NORMAL_ARRAY_TYPE = 32894

MGL_FOG_COORDINATE_ARRAY_TYPE_EXT = 33876

MGL_TEXTURE28 = 34012

MGL_MATRIX14 = 35022

MGL_TEXTURE_CUBE_MAP_POSITIVE_Y = 34071

MGL_DSDT8_NV = 34569

MGL_FASTEST = 4353

MGL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 34922

MGL_RGB32F = 34837

MGL_TEXTURE26_ARB = 34010

MGL_TEXTURE_CUBE_MAP_NEGATIVE_X = 34070

MGL_COMBINE_RGB = 34161

MGL_DONT_CARE = 4352

MGL_OUTPUT_TEXTURE_COORD20_EXT = 34737

MGL_MATRIX12 = 35020

MGL_ADD_SIGNED_EXT = 34164

MGL_PIXEL_MAP_G_TO_G_SIZE = 3255

MGL_FOG_COORDINATE_EXT = 33873

MGL_MATRIX11 = 35019

MGL_SELECT = 7170

kMGLext_blend_minmax = 24

MGL_RGB_SCALE_EXT = 34163

kMGLext_multisample = 10

MGL_FOG_COORDINATE_SOURCE_EXT = 33872

MGL_MAP2_TEXTURE_COORD_4 = 3510

MGL_MATRIX10 = 35018

MGL_COMBINE_ALPHA_EXT = 34162

MGL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX = 36936

MGL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 33779

kMGLext_MGLX_create_pbuffer = 90

MGL_MATRIX9 = 35017

MGL_T2F_C4F_N3F_V3F = 10796

MGL_REFLECTION_MAP = 34066

MGL_ALL_COMPLETED_NV = 34034

MGL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 33778

MGL_VERTEX_ATTRIB_ARRAY_SIZE = 34339

MGL_MATRIX8 = 35016

MGL_NORMAL_MAP = 34065

MGL_STENCIL_INDEX16 = 36169

MGL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 33777

MGL_MATRIX7 = 35015

MGL_TEXTURE25_ARB = 34009

MGL_MULTISAMPLE_BIT = 536870912

MGL_SECONDARY_INTERPOLATOR_ATI = 35181

MGL_COMPRESSED_RGB_S3TC_DXT1_EXT = 33776

kMGLext_ARB_fragment_program = 41

MGL_MATRIX6 = 35014

MGL_EMBOSS_CONSTANT_NV = 34142

MGL_PIXEL_MAP_B_TO_B_SIZE = 3256

MGL_MIRRORED_REPEAT_IBM = 33648

MGL_MATRIX5 = 35013

MGL_REG_15_ATI = 35120

MGL_EMBOSS_LIGHT_NV = 34141

MGL_MATRIX13 = 35021

MGL_SEPARATE_SPECULAR_COLOR = 33274

MGL_SHORT = 5122

MGL_MATRIX4 = 35012

MGL_SAMPLES = 32937

MGL_STACK_OVERFLOW = 1283

MGL_LINE_WIDTH = 2849

MGL_SINGLE_COLOR = 33273

kMGLext_NV_primitive_restart = 75

MGL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 34076

MGL_VERTEX_PROGRAM_BINDING_NV = 34378

MGL_SAMPLE_BUFFERS = 32936

MGL_LIGHT_MODEL_COLOR_CONTROL = 33272

MGL_COMBINER_MUX_SUM_NV = 34119

MGL_VERTEX_ATTRIB_ARRAY2_NV = 34386

MGL_MAX_PROGRAM_TEMPORARIES = 34981

MGL_PROXY_TEXTURE_CUBE_MAP_ARB = 34075

MGL_COMBINER7_NV = 34135

MGL_CULL_VERTEX_OBJECT_POSITION_EXT = 33196

MGL_OUTPUT_TEXTURE_COORD31_EXT = 34748

MGL_MATRIX1 = 35009

MGL_TEXTURE24_ARB = 34008

MGL_SAMPLE_ALPHA_TO_ONE = 32927

MGL_CULL_VERTEX_EYE_POSITION_EXT = 33195

MGL_MATRIX0 = 35008

MGL_SAMPLE_ALPHA_TO_COVERAGE = 32926

kMGLext_ARB_texture_rectangle = 21

MGL_MAD_ATI = 35176

MGL_CULL_VERTEX_EXT = 33194

MGL_VERTEX_ATTRIB_ARRAY3_NV = 34387

MGL_PROGRAM_ERROR_STRING = 34932

MGL_REG_14_ATI = 35119

MGL_COMBINER4_NV = 34132

MGL_ARRAY_ELEMENT_LOCK_COUNT_EXT = 33193

MGL_MAP2_TEXTURE_COORD_2 = 3508

MGL_MAX_PROGRAM_MATRIX_STACK_DEPTH = 34350

MGL_COMBINER3_NV = 34131

MGL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = 35983

MGL_ARRAY_ELEMENT_LOCK_FIRST_EXT = 33192

MGL_FEEDBACK_BUFFER_SIZE = 3569

MGL_T2F_C3F_V3F = 10794

MGL_COMBINER2_NV = 34130

MGL_CLAMP_TO_BORDER_ARB = 33069

MGL_PROGRAM_FORMAT_ASCII = 34933

MGL_FEEDBACK_BUFFER_POINTER = 3568

MGL_COMBINER1_NV = 34129

MGL_TEXTURE_COMPARE_FAIL_VALUE_ARB = 32959

kMGLext_ARB_instanced_arrays = 52

MGL_CURRENT_MATRIX_STACK_DEPTH = 34368

MGL_TEXTURE23_ARB = 34007

MGL_COMBINER0_NV = 34128

MGL_TEXTURE_GEQUAL_R_SGIX = 33181

MGL_TEXTURE_1D = 3552

MGL_MAX_TEXTURE_UNITS = 34018

MGL_TRIANGLE_FAN = 6

MGL_TEXTURE_LEQUAL_R_SGIX = 33180

MGL_MAP2_GRID_SEGMENTS = 3539

MGL_FILL = 6914

MGL_NUM_GENERAL_COMBINERS_NV = 34126

MGL_MAP_STENCIL = 3345

MGL_TEXTURE_COMPARE_OPERATOR_SGIX = 33179

MGL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 34466

MGL_MAP2_GRID_DOMAIN = 3538

MGL_ACTIVE_TEXTURE = 34016

MGL_TEXTURE_COMPARE_SGIX = 33178

MGL_VERTEX_ATTRIB_ARRAY13_NV = 34397

MGL_MAP1_GRID_SEGMENTS = 3537

MGL_TRACK_MATRIX_NV = 34376

MGL_COMBINER_SUM_OUTPUT_NV = 34124

MGL_DOT3_RGBA = 34479

MGL_COMPARE_R_TO_TEXTURE_ARB = 34894

MGL_COMBINER_AB_DOT_PRODUCT_NV = 34117

MGL_MAP1_GRID_DOMAIN = 3536

MGL_COMBINER_CD_OUTPUT_NV = 34123

MGL_TEXTURE_COMPARE_FUNC_ARB = 34893

MGL_DOT3_RGBA_EXT = 34479

MGL_TEXTURE22_ARB = 34006

MGL_TEXTURE27_ARB = 34011

MGL_COMBINER_AB_OUTPUT_NV = 34122

MGL_EIGHTH_BIT_ATI = 32

MGL_TEXTURE_COMPARE_MODE_ARB = 34892

MGL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = 35976

MGL_COMBINER5_NV = 34133

MGL_DOT3_RGBA_ARB = 34479

MGL_COMBINER_BIAS_NV = 34121

MGL_TRIANGLE_STRIP = 5

MGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 34073

MGL_DEPTH_TEXTURE_MODE_ARB = 34891

MGL_DOT3_RGB_EXT = 34478

MGL_REG_12_ATI = 35117

MGL_COMBINER_SCALE_NV = 34120

MGL_TEXTURE_DEPTH_SIZE_ARB = 34890

MGL_REG_6_ATI = 35111

MGL_MAP2_TEXTURE_COORD_3 = 3509

MGL_EDGE_FLAG_ARRAY_EXT = 32889

MGL_INVALID_ENUM = 1280

MGL_DEPTH_COMPONENT32_ARB = 33191

MGL_COMPRESSED_TEXTURE_FORMATS_ARB = 34467

MGL_T4F_V4F = 10792

MGL_COMBINER_CD_DOT_PRODUCT_NV = 34118

MGL_TEXTURE_DT_SIZE_NV = 34590

MGL_DEPTH_COMPONENT24_ARB = 33190

MGL_COLOR_ARRAY_EXT = 32886

kMGLext_ARB_sync = 63

MGL_MAP2_TEXTURE_COORD_1 = 3507

MGL_INDEX_ARRAY_EXT = 32887

MGL_DEPTH_COMPONENT16_ARB = 33189

MGL_MAP2_NORMAL = 3506

MGL_TEXTURE_GEN_MODE = 9472

MGL_COMBINER_COMPONENT_USAGE_NV = 34116

MGL_POINT_DISTANCE_ATTENUATION_ARB = 33065

MGL_OUTPUT_TEXTURE_COORD19_EXT = 34736

MGL_MAP2_INDEX = 3505

MGL_COMBINER_MAPPING_NV = 34115

MGL_8X_BIT_ATI = 4

MGL_MAP2_COLOR_4 = 3504

MGL_OPERAND2_RGB_EXT = 34194

MGL_TEXTURE4_ARB = 33988

MGL_COMBINER_INPUT_NV = 34114

MGL_ACTIVE_VARYING_MAX_LENGTH_NV = 35970

MGL_REG_5_ATI = 35110

MGL_MAP1_VERTEX_4 = 3480

MGL_BIAS_BY_NEGATIVE_ONE_HALF_NV = 34113

MGL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 34764

MGL_ACTIVE_VARYINGS_NV = 35969

MGL_COMPRESSED_RGB_ARB = 34029

MGL_T2F_V3F = 10791

MGL_SCALE_BY_ONE_HALF_NV = 34112

MGL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 35968

MGL_NORMAL_ARRAY_EXT = 32885

MGL_COMPRESSED_INTENSITY_ARB = 34028

MGL_TRANSPOSE_COLOR_MATRIX_ARB = 34022

MGL_SCALE_BY_FOUR_NV = 34111

MGL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 35967

MGL_COMPRESSED_LUMINANCE_ALPHA_ARB = 34027

MGL_COPY = 5379

MGL_SCALE_BY_TWO_NV = 34110

MGL_UNSIGNED_NORMALIZED = 35863

MGL_TRANSFORM_FEEDBACK_ATTRIBS_NV = 35966

kMGLext_ARB_vertex_program = 40

MGL_MAP1_TEXTURE_COORD_2 = 3476

MGL_SIGNED_NEGATE_NV = 34109

MGL_UNSIGNED_SHORT = 5123

MGL_LINE_STRIP = 3

MGL_GENERIC_ATTRIB_NV = 35965

MGL_MAP1_TEXTURE_COORD_1 = 3475

MGL_REG_10_ATI = 35115

MGL_SIGNED_IDENTITY_NV = 34108

MGL_PRIMITIVE_ID_NV = 35964

MGL_VARIANT_VALUE_EXT = 34788

MGL_3D = 1537

MGL_DEPENDENT_GB_TEXTURE_2D_NV = 34538

MGL_HALF_BIAS_NEGATE_NV = 34107

MGL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 34763

MGL_VERTEX_ID_NV = 35963

kMGLext_NV_occlusion_query = 74

MGL_DEPENDENT_AR_TEXTURE_2D_NV = 34537

MGL_C4F_N3F_V3F = 10790

MGL_TEXTURE_GEN_T = 3169

MGL_PROXY_TEXTURE_3D = 32880

MGL_CLIP_DISTANCE_NV = 35962

MGL_VERTEX_ARRAY_EXT = 32884

MGL_VERTEX_ATTRIB_ARRAY1_NV = 34385

MGL_MAP1_COLOR_4 = 3472

MGL_EXPAND_NEGATE_NV = 34105

MGL_FOG_BIT = 128

MGL_TEXTURE_COORD_NV = 35961

MGL_AUTO_NORMAL = 3456

MGL_TEXTURE19_ARB = 34003

MGL_TEXTURE_3D = 32879

MGL_BACK_SECONDARY_COLOR_NV = 35960

MGL_NAME_STACK_DEPTH = 3440

MGL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 36054

MGL_ADD_ATI = 35171

MGL_BACK_PRIMARY_COLOR_NV = 35959

MGL_CONST_EYE_NV = 34533

MGL_REG_9_ATI = 35114

MGL_FRAMEBUFFER_COMPLETE = 36053

MGL_BUFFER_MAP_POINTER_ARB = 35005

MGL_COMPRESSED_RGBA_ARB = 34030

MGL_ACCUM_BLUE_BITS = 3418

MGL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET = 36052

MGL_PROGRAM_ALU_INSTRUCTIONS_ARB = 34821

MGL_AUX1 = 1034

MGL_BUFFER_MAPPED_ARB = 35004

MGL_ACCUM_GREEN_BITS = 3417

MGL_PROGRAM_PARAMETER_NV = 34372

MGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 34072

MGL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 36051

MGL_BUFFER_ACCESS_ARB = 35003

MGL_MAX_3D_TEXTURE_SIZE_EXT = 32883

MGL_OFFSET_TEXTURE_2D_SCALE_NV = 34530

MGL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 36050

MGL_DRAW_PIXEL_TOKEN = 1797

MGL_PROJECTION = 5889

MGL_BUFFER_USAGE_ARB = 34661

kMGLext_ARB_explicit_attrib_location = 51

MGL_STENCIL_BITS = 3415

MGL_EYE_LINEAR = 9216

MGL_SHININESS = 5633

MGL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 36049

MGL_BUFFER_SIZE_ARB = 34660

MGL_CULL_MODES_NV = 34528

MGL_VERTEX_ARRAY_SIZE = 32890

MGL_PACK_SKIP_IMAGES_EXT = 32875

MGL_MOV_ATI = 35169

MGL_MATRIX23 = 35031

MGL_INDEX_MODE = 3120

MGL_SHADER_OPERATION_NV = 34527

MGL_REG_8_ATI = 35113

MGL_PACK_SKIP_IMAGES = 32875

MGL_WRITE_ONLY_ARB = 35001

MGL_MAP1_VERTEX_3 = 3479

MGL_TEXTURE_SHADER_NV = 34526

kMGLext_ATI_pixel_format_float = 48

MGL_FRAMEBUFFER_BINDING = 36006

MGL_RASTERIZER_DISCARD_EXT = 35977

MGL_READ_ONLY_ARB = 35000

MGL_VERTEX_ATTRIB_ARRAY12_NV = 34396

MGL_SHADER_CONSISTENT_NV = 34525

MGL_VERTEX_PROGRAM_TWO_SIDE_NV = 34371

MGL_MAX_RENDERBUFFER_SIZE = 34024

MGL_DYNAMIC_COPY_ARB = 35050

MGL_MAX_3D_TEXTURE_SIZE = 32883

MGL_DSDT_MAG_INTENSITY_NV = 34524

kMGLext_NVX_gpu_memory_info = 77

MGL_INVALID_FRAMEBUFFER_OPERATION = 1286

MGL_DYNAMIC_READ_ARB = 35049

MGL_UNSIGNED_INT_S8_S8_8_8_REV_NV = 34523

MGL_TEXTURE_ENV = 8960

MGL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 35657

kMGLext_ARB_matrix_palette = 31

MGL_DYNAMIC_DRAW_ARB = 35048

MGL_UNSIGNED_INT_S8_S8_8_8_NV = 34522

MGL_FRAGMENT_SHADER_ARB = 35632

MGL_CON_31_ATI = 35168

MGL_STATIC_COPY_ARB = 35046

MGL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 34521

MGL_REG_7_ATI = 35112

MGL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 35722

MGL_POLYGON_TOKEN = 1795

MGL_STATIC_READ_ARB = 35045

MGL_MAP1_TEXTURE_COORD_4 = 3478

MGL_MAP2_VERTEX_ATTRIB15_4_NV = 34431

kMGLext_ARB_shadow = 35

MGL_FUNC_REVERSE_SUBTRACT_EXT = 32779

MGL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 34760

MGL_STATIC_DRAW_ARB = 35044

MGL_MAP2_VERTEX_ATTRIB14_4_NV = 34430

MGL_VERTEX_PROGRAM_POINT_SIZE_NV = 34370

MGL_FUNC_REVERSE_SUBTRACT = 32779

MGL_TEXTURE_DS_SIZE_NV = 34589

MGL_STREAM_COPY_ARB = 35042

MGL_PIXEL_MAP_I_TO_B = 3188

kMGLext_EXT_transform_feedback = 62

MGL_MAP2_VERTEX_ATTRIB13_4_NV = 34429

MGL_FUNC_SUBTRACT_EXT = 32778

MGL_STREAM_READ_ARB = 35041

MGL_MAP2_VERTEX_ATTRIB12_4_NV = 34428

MGL_TEXTURE_ENV_COLOR = 8705

MGL_FUNC_SUBTRACT = 32778

MGL_CON_30_ATI = 35167

MGL_STREAM_DRAW_ARB = 35040

MGL_MAP2_VERTEX_ATTRIB11_4_NV = 34427

MGL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 35658

MGL_PACK_LSB_FIRST = 3329

MGL_BACK = 1029

MGL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 34975

MGL_MAP2_VERTEX_ATTRIB10_4_NV = 34426

MGL_TEXTURE3_ARB = 33987

MGL_BLEND_EQUATION = 32777

MGL_BIAS_BIT_ATI = 8

MGL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = 34974

MGL_MAP1_TEXTURE_COORD_3 = 3477

MGL_MAP2_VERTEX_ATTRIB9_4_NV = 34425

MGL_MAX_EXT = 32776

MGL_PRIMITIVES_GENERATED_EXT = 35975

MGL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 34973

MGL_MAP2_VERTEX_ATTRIB8_4_NV = 34424

kMGLext_WMGL_ARB_render_texture = 88

MGL_CURRENT_MATRIX_NV = 34369

MGL_MAX = 32776

MGL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 34972

MGL_TEXTURE_WRAP_R = 32882

MGL_MAP2_VERTEX_ATTRIB7_4_NV = 34423

MGL_FLOAT_MAT2_ARB = 35674

MGL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 34971

MGL_MAP2_VERTEX_ATTRIB6_4_NV = 34422

MGL_TEXTURE_ENV_MODE = 8704

MGL_MIN = 32775

MGL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 34970

kMGLext_ARB_texgen_reflection = 39

MGL_MAP2_VERTEX_ATTRIB5_4_NV = 34421

MGL_FUNC_ADD_EXT = 32774

MGL_INDEX_ARRAY_BUFFER_BINDING_ARB = 34969

MGL_TEXTURE_BINDING_CUBE_MAP = 34068

MGL_MAP2_VERTEX_ATTRIB4_4_NV = 34420

MGL_SOURCE2_RGB_EXT = 34178

MGL_BOOL_VEC2_ARB = 35671

MGL_COLOR_ARRAY_BUFFER_BINDING_ARB = 34968

MGL_MVP_MATRIX_EXT = 34787

MGL_FRAGMENT_SHADER_ATI = 35104

MGL_MAP2_VERTEX_ATTRIB3_4_NV = 34419

MGL_DS_BIAS_NV = 34582

MGL_MAX_VERTEX_SHADER_VARIANTS_EXT = 34758

MGL_AUX2 = 1035

MGL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 35983

MGL_LINE_WIDTH_GRANULARITY = 2851

MGL_NORMAL_ARRAY_BUFFER_BINDING_ARB = 34967

kMGLext_NV_fragment_program = 73

MGL_MAP2_VERTEX_ATTRIB2_4_NV = 34418

MGL_V3F = 10785

MGL_INT_VEC4_ARB = 35669

MGL_VERTEX_ARRAY_BUFFER_BINDING_ARB = 34966

MGL_EDGE_FLAG_ARRAY = 32889

MGL_VERTEX_ATTRIB_ARRAY0_NV = 34384

MGL_MAP2_VERTEX_ATTRIB1_4_NV = 34417

MGL_HI_BIAS_NV = 34580

MGL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = 34965

MGL_OUTPUT_TEXTURE_COORD29_EXT = 34746

MGL_MAP2_VERTEX_ATTRIB0_4_NV = 34416

MGL_TEXTURE14_ARB = 33998

MGL_INT_VEC2_ARB = 35667

MGL_ARRAY_BUFFER_BINDING_ARB = 34964

MGL_MAP1_VERTEX_ATTRIB15_4_NV = 34415

MGL_UNPACK_SKIP_ROWS = 3315

MGL_FLOAT_VEC4_ARB = 35666

kMGLext_texture_mirrored_repeat = 19

MGL_MAP1_VERTEX_ATTRIB14_4_NV = 34414

MGL_FOG_END = 2916

MGL_FLOAT_VEC3_ARB = 35665

MGL_POINT_FADE_THRESHOLD_SIZE_ARB = 33064

MGL_MAP1_VERTEX_ATTRIB13_4_NV = 34413

MGL_FRAGMENT_PROGRAM_ARB = 34820

MGL_POINT_SIZE_MAX_ARB = 33063

MGL_MAP1_VERTEX_ATTRIB12_4_NV = 34412

MGL_V2F = 10784

MGL_SHADER_OBJECT_ARB = 35656

MGL_POINT_SIZE_MIN_ARB = 33062

MGL_TEXTURE_COORD_ARRAY = 32888

MGL_MAP1_VERTEX_ATTRIB11_4_NV = 34411

MGL_HI_SCALE_NV = 34574

kMGLext_NUMBER_OF_EXTENSIONS = 99

MGL_CLIP_VOLUME_CLIPPING_HINT_EXT = 33008

kMGLext_ATI_meminfo = 66

kMGLext_ARB_OpenMGL20 = 50

MGL_MAP1_VERTEX_ATTRIB10_4_NV = 34410

MGL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 34573

MGL_FRONT_RIGHT = 1025

MGL_BGRA_EXT = 32993

MGL_OBJECT_LINK_STATUS_ARB = 35714

MGL_OBJECT_ACTIVE_UNIFORMS_ARB = 35718

MGL_BGR_EXT = 32992

MGL_OUTPUT_TEXTURE_COORD6_EXT = 34723

MGL_MATRIX31 = 35039

MGL_OBJECT_ATTACHED_OBJECTS_ARB = 35717

MGL_S = 8192

MGL_MULTISAMPLE_BIT_ARB = 536870912

MGL_MAP1_NORMAL = 3474

MGL_OUTPUT_TEXTURE_COORD5_EXT = 34722

MGL_OBJECT_INFO_LOG_LENGTH_ARB = 35716

MGL_FRONT = 1028

MGL_SAMPLE_COVERAGE_INVERT_ARB = 32939

MGL_VERTEX_ATTRIB_ARRAY11_NV = 34395

MGL_OUTPUT_TEXTURE_COORD4_EXT = 34721

MGL_MATRIX6_NV = 34358

MGL_OBJECT_VALIDATE_STATUS_ARB = 35715

MGL_SAMPLE_COVERAGE_VALUE_ARB = 32938

MGL_INDEX_ARRAY = 32887

MGL_OUTPUT_TEXTURE_COORD3_EXT = 34720

MGL_SIGNED_INTENSITY8_NV = 34568

MGL_SAMPLES_ARB = 32937

MGL_OUTPUT_TEXTURE_COORD2_EXT = 34719

MGL_TEXTURE27 = 34011

MGL_DEPTH_SCALE = 3358

MGL_SIGNED_INTENSITY_NV = 34567

kMGLext_ARB_vertex_blend = 30

MGL_SAMPLE_BUFFERS_ARB = 32936

MGL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = 35973

MGL_OUTPUT_TEXTURE_COORD1_EXT = 34718

MGL_SIGNED_ALPHA8_NV = 34566

MGL_SAMPLE_COVERAGE_ARB = 32928

MGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 34071

MGL_OUTPUT_TEXTURE_COORD0_EXT = 34717

MGL_EVAL_BIT = 65536

MGL_SIGNED_ALPHA_NV = 34565

MGL_LINE_TOKEN = 1794

MGL_SAMPLE_ALPHA_TO_ONE_ARB = 32927

MGL_MAP1_INDEX = 3473

MGL_OUTPUT_COLOR1_EXT = 34716

MGL_SIGNED_LUMINANCE8_ALPHA8_NV = 34564

MGL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = 35968

MGL_SAMPLE_ALPHA_TO_COVERAGE_ARB = 32926

MGL_OUTPUT_COLOR0_EXT = 34715

MGL_TEXTURE_COORD_ARRAY_POINTER = 32914

MGL_SIGNED_LUMINANCE_ALPHA_NV = 34563

MGL_TEXTURE_LO_SIZE_NV = 34588

MGL_BLUE = 6405

MGL_MULTISAMPLE_ARB = 32925

MGL_HALF_BIAS_NORMAL_NV = 34106

kMGLext_texture_compression_s3tc = 61

MGL_OUTPUT_VERTEX_EXT = 34714

MGL_SIGNED_LUMINANCE8_NV = 34562

MGL_EDGE_FLAG_ARRAY_POINTER_EXT = 32915

MGL_OP_MOV_EXT = 34713

MGL_TEXTURE26 = 34010

MGL_SIGNED_LUMINANCE_NV = 34561

MGL_ELEMENT_ARRAY_BUFFER_ARB = 34963

MGL_TEXTURE_COORD_ARRAY_POINTER_EXT = 32914

MGL_COMPRESSED_LUMINANCE_ARB = 34026

MGL_OUTPUT_TEXTURE_COORD17_EXT = 34734

MGL_OP_MULTIPLY_MATRIX_EXT = 34712

MGL_SIGNED_RGB8_NV = 34559

MGL_INDEX_ARRAY_POINTER_EXT = 32913

MGL_OP_CROSS_PRODUCT_EXT = 34711

MGL_PIXEL_MAP_I_TO_I_SIZE = 3248

MGL_HINT_BIT = 32768

MGL_SIGNED_RGB_NV = 34558

MGL_QUADS = 7

MGL_COLOR_ARRAY_POINTER_EXT = 32912

MGL_OFFSET_TEXTURE_2D_NV = 34536

MGL_MAP1_VERTEX_ATTRIB6_4_NV = 34406

MGL_OP_SUB_EXT = 34710

MGL_SIGNED_RGBA8_NV = 34556

MGL_BACK_LEFT = 1026

MGL_NORMAL_ARRAY_POINTER_EXT = 32911

MGL_ISOTROPIC_BRDF_NV = 34539

MGL_OP_RECIP_SQRT_EXT = 34709

kMGLext_WMGL_ARB_make_current_read = 87

MGL_SIGNED_RGBA_NV = 34555

MGL_VERTEX_ARRAY_POINTER_EXT = 32910

MGL_CLIP_PLANE2 = 12290

MGL_OP_RECIP_EXT = 34708

MGL_TEXTURE_DEPTH_EXT = 32881

MGL_SIGNED_HILO16_NV = 34554

MGL_EDGE_FLAG_ARRAY_COUNT_EXT = 32909

MGL_LINE_STIPPLE_REPEAT = 2854

MGL_OP_POWER_EXT = 34707

MGL_TEXTURE25 = 34009

MGL_SIGNED_HILO_NV = 34553

MGL_CND_ATI = 35178

MGL_EDGE_FLAG_ARRAY_STRIDE_EXT = 32908

MGL_FLOAT_RGBA16_NV = 34954

MGL_OP_LOG_BASE_2_EXT = 34706

MGL_MAP2_VERTEX_3 = 3511

MGL_HILO16_NV = 34552

MGL_PASS_THROUGH_TOKEN = 1792

MGL_MODELVIEW0_EXT = 5888

MGL_TEXTURE_COORD_ARRAY_COUNT_EXT = 32907

MGL_OP_EXP_BASE_2_EXT = 34705

MGL_MATRIX28 = 35036

MGL_DSDT_MAG_VIB_NV = 34551

MGL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 32906

MGL_CULL_FRAGMENT_NV = 34535
